Как предварительно выделить память для объекта std::string?

Ответ 1

std::string есть метод .reserve для предварительного выделения.

std::string s;
s.reserve(1048576); // reserve 1 MB
read_file_into(s);

Ответ 2

Это не столько ответ сам по себе, сколько своего рода комментарий/сводка/сравнение нескольких других ответов (а также быстрая демонстрация того, почему я рекомендовал стиль кода @Johannes - в его ответе). Поскольку @sbi опубликовала альтернативу, которая выглядела довольно хорошо, и (особенно) избегала дополнительной копии, связанной с чтением в строковый поток, а затем с помощью члена .str(), чтобы получить строку, я решил написать быстрое сравнение двух:

[Edit: я добавил третий тестовый пример с использованием кода на основе @Tyler McHenry istreambuf_iterator и добавил строку для печати длины каждой строки, которая была прочитана, чтобы гарантировать, что оптимизатор не оптимизировал чтение, потому что результат никогда не использовался.]

[Edit2: И теперь добавлен код Мартина Йорка...]

#include <fstream>
#include <sstream>
#include <string>
#include <iostream>
#include <iterator>
#include <time.h>

int main() {
    std::ostringstream os;
    std::ifstream file("equivs2.txt");

    clock_t start1 = clock();
    os << file.rdbuf();
    std::string s = os.str();
    clock_t stop1 = clock();

    std::cout << "\ns.length() = " << s.length();

    std::string s2;

    clock_t start2 = clock();
    file.seekg( 0, std::ios_base::end );
    const std::streampos pos = file.tellg();
    file.seekg(0, std::ios_base::beg);

    if( pos!=std::streampos(-1) )
        s2.reserve(static_cast<std::string::size_type>(pos));
    s2.assign(std::istream_iterator<char>(file), std::istream_iterator<char>());
    clock_t stop2 = clock();

    std::cout << "\ns2.length = " << s2.length();

    file.clear();

    std::string s3;

    clock_t start3 = clock();   
    file.seekg(0, std::ios::end);   
    s3.reserve(file.tellg());
    file.seekg(0, std::ios::beg);

    s3.assign((std::istreambuf_iterator<char>(file)),
            std::istreambuf_iterator<char>());
    clock_t stop3 = clock();

    std::cout << "\ns3.length = " << s3.length();

    // New Test
    std::string s4;

    clock_t start4 = clock();
    file.seekg(0, std::ios::end);
    s4.resize(file.tellg());
    file.seekg(0, std::ios::beg);

    file.read(&s4[0], s4.length());
    clock_t stop4 = clock();

    std::cout << "\ns4.length = " << s3.length();

    std::cout << "\nTime using rdbuf: " << stop1 - start1;
    std::cout << "\nTime using istream_iterator: " << stop2- start2;
    std::cout << "\nTime using istreambuf_iterator: " << stop3 - start3;
    std::cout << "\nTime using read: " << stop4 - start4;
    return 0;
}

Теперь впечатляющая часть - результаты. Сначала с VС++ (если кто-то заботится, код Мартина достаточно быстр, я увеличил размер файла, чтобы получить для него осмысленное время):

s.length() = 7669436
s2.length = 6390688
s3.length = 7669436
s4.length = 7669436
Время использования rdbuf: 184
Время использования istream_iterator: 1332
Время использования istreambuf_iterator: 249
Время использования: 48

Затем с gcc (cygwin):

s.length() = 8278035
s2.length = 6390689
s3.length = 8278035
s4.length = 8278035
Время с использованием rdbuf: 62
Время использования istream_iterator: 2199
Время использования istreambuf_iterator: 156
Время использования: 16

[конец редактирования - выводы остаются, хотя победитель изменился - код Мартина явно самый быстрый. ]

Результаты вполне согласуются с тем, что является самым быстрым и медленным. Единственная несогласованность заключается в том, насколько быстрее или медленнее, чем в другой. Хотя места размещения одинаковы, различия скорости намного больше с gcc, чем с VС++.

Ответ 3

Это должно быть все, что вам нужно:

ostringstream os;
ifstream file("name.txt");
os << file.rdbuf();

string s = os.str();

Это считывает символы из file и вставляет их в строку. Впоследствии он получает строку, созданную за кулисами. Обратите внимание, что я попал в следующую ловушку: использование оператора извлечения будет пропускать начальные пробелы. Вы должны использовать оператор вставки, как указано выше, или использовать манипулятор noskipws:

// Beware, skips initial whitespace!
file >> os.rdbuf();

// This does not skip it
file >> noskipws >> os.rdbuf(); 

Эти функции описываются как чтение символа потока по символу (хотя не уверен, что оптимизация здесь возможна), я не приурочил их к определению их скорости.

Ответ 4

Просто для удовольствия, вот еще один способ сделать это:

// Beware, brain-compiled code ahead!

std::ifstream ifs( /* ... */ );
if( !ifs.good() ) return; // whatever

std::string str;

ifs.seekg( 0, std::ios_base::end );
const std::streampos pos = ifs.tellg();
ifs.seekg( 0, std::ios_base::beg );
if( pos!=std::streampos(-1) ) // can get stream size? 
  str.reserve(static_cast<std::string::size_type>(pos));

str.assign( std::istream_iterator<char>(ifs)
          , std::istream_iterator<char>() );

Надеюсь, я тоже не сильно ударил.

Ответ 5

std::string:: reserve()

std:: getline()

Ответ 6

Кажется, вы спрашиваете, как выполнить операцию типа CString:: GetBuffer, ReleaseBuffer с помощью std::string.

Я не знаю, как это сделать прямо, простым способом было бы просто создать бункер с исходным буфером C, прочитать в буфер, а затем скопировать буфер в std::string с помощью назначения или чего-то еще. Конечно, вам придется беспокоиться о проблемах с переполнением буфера и т.д., Также я бы использовал std:: autoptr для управления указателем необработанного буфера, освобождением enusre при исключении и т.д. Это немного проще, чем использование stringstream и т.д. Я могу предоставить пример, если это необходимо.

Девин Эллингсон

Ответ 7

std::string::resize() фактически выделяет необходимое пространство.

std::string::reserve() не может (это запрос).