Can you explain the concept of Small Buffer Optimization and in which cases it is used?

Small Buffer Optimization (SBO) is an optimization technique in C++ (and other languages) that allows small objects (e.g., short strings) to be stored directly within the object itself, without allocating separate dynamic memory on the heap.

The idea is that for small data, allocating memory on the heap is costly in terms of time and memory (fragmentation, overhead). Therefore, a small fixed buffer (e.g., an array of 15-23 bytes) is allocated inside the object, where data is stored if it fits in size. If the data is larger, memory is allocated dynamically.

Example: std::string in some implementations uses SBO so that short strings are stored inside the std::string object itself, rather than on the heap.

When to use:

• When working frequently with small objects (short strings, small arrays).
• When performance and minimizing allocations are important.

Example of a simplified SBO implementation for a string:

class SmallString {
    static const size_t SBO_SIZE = 16;
    union {
        char sboBuffer[SBO_SIZE];
        char* heapBuffer;
    } data;
    size_t length;
    bool isSmall;

public:
    SmallString(const char* str) {
        length = strlen(str);
        if (length < SBO_SIZE) {
            memcpy(data.sboBuffer, str, length + 1);
            isSmall = true;
        } else {
            data.heapBuffer = new char[length + 1];
            strcpy(data.heapBuffer, str);
            isSmall = false;
        }
    }
    ~SmallString() {
        if (!isSmall) delete[] data.heapBuffer;
    }
    // ...
};

Thus, SBO improves performance by reducing the number of dynamic allocations for small objects.