Как выпустить неиспользованную способность строки

Почему бы вам тогда не использовать массив символов?

Изложение ответа Навина :

string x = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
cerr << x.capacity() << "\n";    // MSVC++: 63    g++: 52

// This tends not to work (although in theory it could):
//x = "XYZ";
//cerr << x.capacity() << "\n";  // MSVC++: 63    g++: 52

// This tends to work (although in theory it might not):
string("XYZ").swap(x);
cerr << x.capacity() << "\n";    // MSVC++: 15    g++: 3

Обратите внимание, что если базовый распределитель выделяет больше, чем n байт при построении строки длины n (например, путем округления до ближайшего 32, как это делает MSVC ++), нет способа сделать он использует меньше байтов . Но вы, вероятно, не захотите делать это в любом случае, так как это «округление» сделано для того, чтобы сделать процесс динамического выделения памяти более эффективным, а также побочным эффектом ускорения конкатенации коротких строк в среднем (поскольку требуется меньше перераспределений). произойти).

Я думаю, что вы можете использовать метод подкачки для освобождения данных. поменяйте местами пустую локальную строку, чтобы, когда локальная строка вышла из области видимости, память была освобождена.

Try the std::string swap-trick to shrink your strings:

std::string( str.data(), str.size() ).swap( str ) 

Where str is the string you want to cut down to size.

В основном это зависит от реализации. Идея состоит в том, чтобы минимизировать запросы выделения и фрагментации памяти. Легко доказать, что, удваивая существующий размер при каждом расширении блока, количество выделений и фрагментация памяти сводятся к минимуму. Поэтому, как правило, реализации контейнера STL удваивают существующий блок при расширении.

Одна вещь, которую вы можете сделать, это использовать собственный распределитель, который не будет выделять больше, чем необходимо, затем создайте свой std ::

емкость НИКОГДА не будет меньше 15 с dinkumware STL. std :: basic_string имеет объединение, которое является указателем на выделенный буфер или 16-байтовый буфер (если Capacity () <= 15) (для строковых символов)

, смотрите файл заголовка xstring

в приведенном вами примере где вы резервируете 16, вы фактически резервируете 17 (один для нуля), который> 16, поэтому он размещается, а не кэшируется в 16 байтах в объединении указателей кэша. Это распределение удваивает предыдущий размер (16), так что вы получите 32. Емкость этой строки тогда, вероятно, равна 31.

Но это зависит от реализации STL.

Изменение параметра шаблона распределителя в шаблоне decl из std :: basic_string НЕ достаточно - выбор того, когда выделять и сколько, находится в std :: basic_string; алгоритм роста НЕ в распределителе. Удвоение предыдущего размера (и сокращение при <

Не существует гарантированной минимальной емкости для std :: string . Вы можете запросить любую емкость, которую хотите, вызвав резерв , но конкретная реализация гарантирует только установку емкости на некоторое количество, большее или равное запрошенному размеру.

Вот модифицированная версия вашей программы, которая тестирует несколько методы сжатия строк:

#include <string>
#include <iostream>
using namespace ::std;

template< typename S >
S & reserve_request( S & s, typename S::size_type n ) {
    s.reserve( n ); return s;
}

template< typename S >
S & shrink_request1( S & s ) { s.reserve(); return s; }

template< typename S >
S & shrink_request2( S & s ) { S( s ).swap( s ); return s; }

template< typename S >
S & shrink_request3( S & s ) { S( s.c_str() ).swap( s ); return s; }

template< typename S >
void test( S & s ) { cout << s.capacity() << endl; }

int main() {
    string temp = "1234567890123456";    // length 16
    string str;

    test( str );                         // 15
    test( reserve_request( str, 16 ) );  // 31
    test( str += temp );                 // 31
    test( reserve_request( str, 16 ) );  // 31
    test( shrink_request1( str ) );      // 31
    test( shrink_request2( str ) );      // 31
    test( shrink_request3( str ) );      // 31
    return 0;
}

Может показаться, что std :: string Visual C ++ обычно сохраняет некоторую свободную емкость.

Если ваш проект загружает большое количество строк, считанных из внешнего источника, размер которого затем никогда не меняется, вам может быть лучше (как другие предлагали) хранить их в одном большом блоке символьной памяти, разделенном символами '\ 0' (то есть в виде C-строк). Если хочешь, Вы можете предоставить функции-оболочки, которые возвращают std :: string s на лету.