C++ 返回从缓冲区和函数读取的字符串，而不进行动态分配？

在不动态分配内存的情况下，如何返回从函数中的缓冲区生成的字符串

目前，我需要考虑以下功能：

    // Reads null-terminated string from buffer in instance of buffer class.
    // uint16 :: unsigned short
    // ubyte :: unsigned char
    ubyte* Readstr( void ) {
        ubyte* Result = new ubyte[]();

        for( uint16 i = 0; i < ByteSize; i ++ ) {
            Result[ i ] = Buffer[ ByteIndex ];
            ByteIndex ++;

            if ( Buffer[ ByteIndex - 1 ] == ubyte( 0 ) ) {
                ByteIndex ++;
                break;
            };
        };

        return Result;
    };

//从缓冲区类实例中的缓冲区中读取以null结尾的字符串。
//uint16:：无符号短
//ubyte:：无符号字符
ubyte*Readstr（无效）{
ubyte*结果=新ubyte[]（）；
对于（uint16 i=0；i

虽然我可以返回构建的字符串，但是如果没有动态分配，我就不能这样做。如果考虑以下用法：这将成为一个问题：

// Instance of buffer class "Buffer" calling Readstr():
    cout << Buffer.Readstr() << endl;
    // or...
    ubyte String[] = Buffer.String();

//缓冲区类“buffer”调用Readstr（）的实例：
就我个人而言，我建议只返回
std:：string
或
std:：vector
：这巧妙地避免了内存泄漏，而且字符串不会为小字符串分配内存（好吧，大多数实现都是这样的，但并非所有实现都是这样）

另一种方法是创建一个类，该类可以容纳足够大的数组并返回以下类型的对象：

struct buffer {
     enum { maxsize = 16 };
     ubyte buffer[maxsize];
};

如果你想变得更花哨，支持更大的字符串，然后只分配内存，你需要处理更多的构造函数、析构函数等（或者只是使用
std:：vector
并克服它）。
个人，我建议只返回
std:：string
或
std:：vector
：这样可以巧妙地避免内存泄漏，而且字符串不会为小字符串分配内存（好吧，大多数实现都是这样，但不是所有实现都是这样）

另一种方法是创建一个类，该类可以容纳足够大的数组并返回以下类型的对象：

struct buffer {
     enum { maxsize = 16 };
     ubyte buffer[maxsize];
};

如果你想变得更花哨，支持更大的字符串，然后只分配内存，那么你需要更多地处理构造函数、析构函数等（或者只是使用
std:：vector
并克服它）。
至少有三种方法可以重新实现该方法，以避免直接分配
new

好人：
使用
std:：vector
（这将分配堆内存）：

std:：vector Readstr（）
{
std：：向量结果；
对于（uint16 i=0；i

坏消息：
强制调用方提供输出缓冲区和可能的大小以避免溢出（不直接分配内存）：

ubyte*Readstr（ubyte*outputBuffer，size\u t maxCount）
{
对于（uint16 i=0；i

丑八怪：
使用内部静态数组并返回对其的引用：

ubyte* Readstr() 
{
    enum { MAX_SIZE = 2048 }; // Up to you to decide the max size...
    static ubyte outputBuffer[MAX_SIZE];

    for (uint16 i = 0; i < ByteSize; i++) 
    {
        if (i == MAX_SIZE)
            break;

        outputBuffer[i] = Buffer[ByteIndex];
        ByteIndex++;

        if (Buffer[ByteIndex - 1] == ubyte(0)) 
        {
            ByteIndex++;
            break;
        }
    }
    return outputBuffer;
}

ubyte*Readstr（）
{
枚举{MAX_SIZE=2048}；//由您决定最大大小。。。
静态ubyte输出缓冲区[MAX_SIZE]；
对于（uint16 i=0；i

请注意，最后一个选项有几个限制，包括多线程应用程序中可能存在数据争用，以及无法在递归函数中调用它，以及其他一些微妙的问题。但是，如果您采取一些预防措施并对调用代码进行一些假设，则它可能是最接近您所寻找的，并且可以安全地使用。
至少有三种方法可以重新实现该方法，以避免使用
new
直接分配

好人：
使用
std:：vector
（这将分配堆内存）：

std:：vector Readstr（）
{
std：：向量结果；
对于（uint16 i=0；i

坏消息：
强制调用方提供输出缓冲区和可能的大小以避免溢出（不直接分配内存）：

ubyte*Readstr（ubyte*outputBuffer，size\u t maxCount）
{
对于（uint16 i=0；i

丑八怪：
使用内部静态数组并返回对其的引用：

ubyte* Readstr() 
{
    enum { MAX_SIZE = 2048 }; // Up to you to decide the max size...
    static ubyte outputBuffer[MAX_SIZE];

    for (uint16 i = 0; i < ByteSize; i++) 
    {
        if (i == MAX_SIZE)
            break;

        outputBuffer[i] = Buffer[ByteIndex];
        ByteIndex++;

        if (Buffer[ByteIndex - 1] == ubyte(0)) 
        {
            ByteIndex++;
            break;
        }
    }
    return outputBuffer;
}

ubyte*Readstr（）
{
枚举{MAX_SIZE=2048}；//由您决定最大大小。。。
静态ubyte输出缓冲区[MAX_SIZE]；
对于（uint16 i=0；i

请注意，最后一个选项有几个限制，包括多线程应用程序中可能存在数据争用，以及无法在递归函数中调用它，以及其他一些微妙的问题。但除此之外，它可能是最接近您所寻找的，并且如果您采取一些预防措施并做出相应调整，它可以安全使用