Почему в С++ следует использовать std::string вместо строк в стиле c?

1. std::string управляет своей собственной памятью, поэтому вы можете легко копировать, создавать и уничтожать их.
2. Вы не можете использовать свой собственный буфер как std::string.
3. Вам нужно передать строку c / буфер чему-то, что ожидает получить право собственности на буфер, например, сторонней библиотеке C.

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

Например, для определения длины массива символов требуется «подсчет» символов в массиве. Напротив, std::string обеспечивает эффективную работу для этой конкретной задачи. (см. https://stackoverflow.com/a/1467497/129622)

1. Для мощности, эффективности и здравомыслия
2. Больший объем памяти, чем «просто» массив символов
3. Когда вам просто нужен массив символов

3) Совет всегда использовать string, конечно, нужно воспринимать с долей здравого смысла. Строковые литералы — это const char[], и если вы передаете литерал функции, которая принимает const char* (например, std::ifstream::open()), нет абсолютно никакого смысла оборачивать его в std::string.

char* в основном является указателем на символ. То, что делает C, часто заставляет этот указатель указывать на первый символ в массиве.

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

Причины использовать char* вместо std::string:

C backwards-compatibility.
Performance (potentially).
char*s have lower-level access.

Причины использовать std::string вместо char*:

Much more intuitive to use.
Better searching, replacement, and manipulation functions.
Reduced risk of segmentation faults.

Пример :

char* должен использоваться в сочетании либо с массивом символов, либо с динамически выделяемым массивом символов. В конце концов, указатель бесполезен, если он на самом деле не указывает на что-то. Это в основном используется в программах C:

char somebuffer[100] = "a string";
char* ptr = somebuffer;  // ptr now points to somebuffer
cout << ptr; // prints "a string"
somebuffer[0] = 'b';  // change somebuffer
cout << ptr;  // prints "b string" 

обратите внимание, что когда вы меняете 'somebuffer', 'ptr' также меняется. Это связано с тем, что в этом случае somebuffer является фактической строкой. ptr просто указывает/ссылается на него.

С std::string это менее странно:

std::string a = "a string";
std::string b = a;
cout << b;  // prints "a string"
a[0] = 'b';  // change 'a'
cout << b;  // prints "a string" (not "b string") 

Здесь вы можете видеть, что изменение «a» не влияет на «b», потому что «b» — это фактическая строка.

Но на самом деле главное отличие состоит в том, что с массивами char вы отвечаете за управление памятью, тогда как std::string делает это за вас. В C++ очень мало причин использовать массивы символов вместо строк. В 99 случаях из 100 вам лучше использовать строку.

Пока вы полностью не разберетесь в управлении памятью и указателях, просто избавьте себя от головной боли и используйте std::string.

Почему в С++ следует использовать std::string вместо строк в стиле c?

Основная причина в том, что это освобождает вас от управления временем жизни строковых данных. Вы можете просто рассматривать строки как значения и позволить компилятору/библиотеке беспокоиться об управлении памятью.

Ручное управление выделением памяти и временем жизни утомительно и чревато ошибками.

Каковы недостатки (если они есть) практики, упомянутой в № 1?

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

Если вы не будете осторожны, вы можете получить много ненужного копирования данных (в реализации без подсчета ссылок) или манипуляции со счетчиком ссылок (в реализации с подсчетом ссылок)

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

Каковы сценарии, в которых противоположность совету, упомянутому в № 1, является хорошей практикой?

У разных людей будут разные мнения по этому поводу, но ИМО

• Для аргументов функции передача строк в "const char *" является хорошим выбором, так как это позволяет избежать ненужного копирования/пересчета ссылок и дает вызывающей стороне гибкость в отношении того, что они передают.
• Для вещей, используемых во взаимодействии с другими языками, у вас нет другого выбора, кроме как использовать строки в стиле c.
• Когда у вас есть известный предел длины, может быть быстрее использовать массивы фиксированного размера.
• При работе с очень длинными строками может быть лучше использовать конструкцию, которая определенно будет пересчитана, а не скопирована (например, массив символов, обернутый в shared_ptr), или вообще использовать другой тип структуры данных.

В общем, вы всегда должны использовать std::string, так как он менее подвержен ошибкам. Имейте в виду, что накладные расходы памяти для std::string значительны. Недавно я провел несколько экспериментов с накладными расходами std::string. В общем это около 48 байт! Статья находится здесь: http://jovislab.com/blog/?p=76.