строки в C++

Это почти никогда не необходимо или желательно сказать

string * s = new string("hello");

В конце концов, Вы (почти) никогда не говорили бы:

int * i = new int(42);

Необходимо вместо этого сказать

string s( "hello" );

или

string s = "hello";

И да, строки C++ изменяемы.

string a;
a = "hello!";

2 операции: называет конструктора по умолчанию std:string () и затем называет оператор:: =

string *a; a = new string("hello!"); ... delete(a);

только одна операция: вызывает конструктора std:string (символ константы*), но Вы не должны забывать выпускать свой указатель.

Что относительно строки ("привет");

Существует ли определенная причина, почему Вы постоянно используете присвоение вместо инициализации? Таким образом, почему Вы не пишете

string a = "Hello";

и т.д.? Это избегает конструкции по умолчанию и просто имеет больше смысла семантически. Создание указателя на строку только ради выделения его на "куче" никогда не значимо, т.е. Ваш случай 2 не имеет смысла и немного менее эффективен.

Относительно Вашего последнего вопроса, да, строки в C++ изменяемы, если не объявлено const.

В случае, если 1.1, Ваши строковые участники (которые включают указатель на данные) сдержаны stack и память, занятая экземпляром класса, освобождена когда a выходит из объема.

В случае, если 1.2, память для участников выделяется динамично от "кучи" также.

Когда Вы присваиваете a char* постоянный к строке, память, которая будет содержать данные, будет realloc'редактор для установки новым данным.

Можно видеть, сколько памяти выделяется путем вызова string::capacity().

Когда Вы звоните string a("hello"), память выделяется в конструкторе.

И конструктор и оператор присваивания называют те же методы внутренне к выделенной памяти и копируют новые данные там.

Создание строки непосредственно в "куче" обычно является не хорошей идеей, точно так же, как создание базовых типов. Это не стоит того, так как объект может легко остаться на стеке, и это имеет всех конструкторов копии и оператор присваивания, необходимый для эффективной копии.

Сам std:string имеет буфер в "куче", которая может быть совместно использована несколькими строками в зависимости от реализации.

Для intsance с реализацией STL Microsoft Вы могли сделать это:

string a = "Hello!";
string b = a;

И обе строки совместно использовали бы тот же буфер, пока Вы не изменили его:

a = "Something else!";

Вот почему это было очень плохо для хранения c_str () для последнего использования; c_str () гарантируют только законность, пока другой вызов к тому строковому объекту не будет выполнен.

Этот вывод к очень противным ошибкам параллелизма, которые потребовали, чтобы эта функциональность совместного использования была выключена с определением при использовании их в многопоточном приложении

Если Вы смотрите на документы для строкового класса STL (я полагаю, что документы SGI совместимы к спецификации), многие методы перечисляют гарантии сложности. Я полагаю, что многие гарантии сложности намеренно оставляют неопределенными для разрешения различных реализаций. Я думаю, что некоторые реализации на самом деле используют подход copy-modify, таким образом, что присвоение одной строки другому является постоянно-разовой операцией, но можно понести неожиданные расходы, когда Вы пытаетесь изменить один из тех экземпляров. Не уверенный, если это все еще верно в современном STL все же.

Необходимо также проверить capacity() функция, которая скажет Вам максимальную строку длины, которую можно поместить в приведенный строковый пример, прежде чем это будет вынуждено перераспределить память. Можно также использовать reserve() вызвать перераспределение к определенной сумме, если Вы знаете, что собираетесь быть хранением большой строки в переменной в более позднее время.

Как другие сказали, насколько Ваши примеры идут, необходимо действительно одобрить инициализацию по другим подходам для предотвращения создания временных объектов.

Скорее всего,

   string a("hello!");

быстрее, чем что-либо еще.

Вы происходите из Java, правильно? В C++ объекты рассматривают то же (большинством способов) как основные типы значения. Объекты могут жить на стеке или в статическом устройстве хранения данных и быть переданы значением. Когда Вы объявляете строку в функции, которая выделяет на стеке однако много байтов, строковый объект берет. Сам строковый объект использует динамическую память для хранения фактических символов, но это очевидно для Вас. Другая вещь помнить состоит в том, что то, когда функциональные выходы и строка Вы объявили, больше не находится в объеме, вся память, которую это использовало, освобождена. Никакая потребность в сборке "мусора" (RAII является Вашим лучшим другом).

В Вашем примере:

string a;
a = "less"; 
a = "moreeeeeee";

Это помещает блок памяти на стеке и называет это a, затем конструктора вызывают и инициализированного к пустой строке. Компилятор хранит байты для "меньше" и "moreeeeeee" в (я думаю), .rdata раздел Вашего exe. Строка желание имеет несколько полей, как поле длины и символ* (я упрощаю значительно). Когда Вы присваиваетесь "меньше" к a, оператор = (), метод называют. Это динамично выделяет память для хранения входного значения, затем копирует его в. При позже присвоении "moreeeeeee" a, оператор = (), метод снова называют, и он перераспределяет достаточно памяти для содержания нового значения при необходимости, затем копирует его в во внутренний буфер.

То, когда строковый объем a's выходит, строковый деструктор называют и память, которая была динамично выделена для содержания фактических символов, освобождено. Затем указатель вершины стека постепенно уменьшается и память, которая не содержала больше "на" стеке.