Какая оптимизация используется в строках C++?

Оптимизация в строках C++ (SSO)

В современном C++ для оптимизации работы со строками применяется техника Small String Optimization (SSO) — оптимизация малых строк. Это одна из самых важных оптимизаций в std::string, которая существенно улучшает производительность.

Суть SSO

Вместо того чтобы всегда выделять память в куче (heap) для хранения строки, SSO позволяет хранить строку прямо в объекте std::string, если её длина не превышает определённый порог (обычно 15-23 байта в зависимости от платформы):

std::string short_str = "hello";     // 5 символов
// Хранится в самом объекте, heap НЕ используется!

std::string long_str = "very long string that exceeds the threshold";
// Превышает порог, выделяется память в heap

Внутренняя структура

std::string обычно содержит:

template<typename CharT>
class basic_string {
private:
    CharT* ptr_;           // Указатель на данные (или буфер SSO)
    size_t length_;        // Длина строки
    size_t capacity_;      // Выделенная ёмкость
    union {
        CharT buffer_[N];  // Встроенный буфер для SSO (N ≈ 16-24)
        // Флаг, указывающий используется ли встроенный буфер
    };
};

Как это работает

std::string s1 = "short";  // 5 символов
// Данные хранятся в встроенном буфере (buffer_)
// Указатель ptr_ может указывать на buffer_[0]
// Нет динамического выделения памяти!

std::string s2 = "this is a very long string that exceeds optimization";
// 51 символ — превышает буфер
// Выделяется память в heap через new[]
// ptr_ указывает на выделенную память

// После обычных операций могут вернуться к SSO:
s2.clear(); // Может вернуться к встроенному буферу
s2 = "hi";  // 2 символа — теперь в SSO

Преимущества SSO

1. Отсутствие динамического выделения памяти для коротких строк:

   std::string path = "/tmp/file";  // Без malloc/free
   

2. Лучшая локальность кэша — данные в том же объекте

3. Быстрое копирование малых строк — просто копируем буфер

4. Меньше фрагментации памяти

Пример производительности

// Без SSO (гипотетически)
std::string s = "hello";  // malloc + free при уничтожении
int total_time = 1000 операций * (время malloc + время free)

// С SSO (реальность)
std::string s = "hello";  // Никаких malloc/free
int total_time = 0 операций malloc/free = быстрее

Пороговое значение SSO

Порог зависит от платформы и компилятора:

// Linux x86_64, GCC/Clang
// sizeof(std::string) = 24 байта
// Буфер SSO ≈ 16 символов (с учётом служебной информации)

// Windows MSVC
// sizeof(std::string) = 56 байт (в Debug)
// Буфер SSO может быть значительно больше

std::string s;
std::cout << sizeof(s);  // Размер объекта
std::cout << s.capacity(); // Ёмкость для SSO

Проверка использования SSO

Нет официального способа проверить, использует ли строка SSO, но можно сделать косвенную проверку:

#include <memory>

bool is_using_sso(const std::string& str) {
    // Если capacity() близко к sizeof объекта, то вероятно SSO
    // Это зависит от реализации!
    return str.capacity() < sizeof(std::string);
}

std::string short_str = "hi";
std::string long_str = "very long string that definitely exceeds sso limit";

std::cout << is_using_sso(short_str) << " "; // Вероятно true
std::cout << is_using_sso(long_str) << " "; // Вероятно false

Практические следствия SSO

1. Копирование коротких строк дешево:

   std::string original = "test";
   std::string copy = original;  // Очень быстро с SSO
   

2. Избегайте ненужных очисток:

   std::string s = "hello";
   s.clear();           // С SSO просто меняет length, буфер остаётся
   s = "world";        // Может переиспользовать буфер
   

3. Временные строки эффективны:

   std::string getMessage() {
       return "Error";  // С SSO может избежать heap выделения
   }
   

4. Reserve осторожнее:

   std::string s = "hi";
   s.reserve(100);  // Выход за SSO порог — выделит heap
   

Когда SSO не помогает

• Строки длиной > ~20 символов (зависит от реализации)
• Частые переассигнения больших строк
• Конкатенация множества строк в цикле (используй ostringstream)

SSO — это одна из причин, почему std::string часто работает эффективнее наивных реализаций с указателями.