char * vs std :: string в c ++ [закрыто]

Когда я должен использовать std::stringи когда я должен использовать char*для управления массивами chars в C ++?

Похоже, вам следует использовать, char*если производительность (скорость) имеет решающее значение, и вы готовы принять некоторые из рискованных дел из-за управления памятью.

Можно ли рассмотреть другие сценарии?

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

Я использую std :: string / wstring для более или менее всего, что является фактическим текстом. char *однако полезно для других типов данных, и вы можете быть уверены, что они будут освобождены, как и должны. В противном случае std :: vector - это путь.

Из всего этого, наверное, есть исключения.

Моя точка зрения такова:

• Никогда не используйте char *, если вы не вызываете код "C".
• Всегда используйте std :: string: это проще, удобнее, оптимизировано, стандартно, избавит от ошибок, проверено и доказано, что работает.

Использование необработанной строки

Да, иногда это действительно удается. При использовании массивов const char *, char, выделенных в стеке, и строковых литералов вы можете сделать это таким образом, чтобы память не выделялась вообще.

Написание такого кода часто требует большего мышления и осторожности, чем использование строки или вектора, но с помощью надлежащих методов это можно сделать. При правильной технике код может быть безопасным, но вам всегда нужно быть уверенным, что при копировании в char [] у вас либо есть гарантии относительно длины копируемой строки, либо вы проверяете и обрабатываете слишком большие строки изящно. Невыполнение этого требования и дало семейству функций strcpy репутацию небезопасных.

Как шаблоны могут помочь в написании безопасных буферов символов

Что касается безопасности буферов char [], могут помочь шаблоны, поскольку они могут создавать инкапсуляцию для обработки размера буфера за вас. Подобные шаблоны реализованы, например, Microsoft, чтобы обеспечить безопасную замену strcpy. Пример здесь извлечен из моего собственного кода, в реальном коде гораздо больше методов, но этого должно быть достаточно, чтобы передать основную идею:

template <int Size>
class BString
{
  char _data[Size];

  public:
  BString()
  {
    _data[0]=0;
    // note: last character will always stay zero
    // if not, overflow occurred
    // all constructors should contain last element initialization
    // so that it can be verified during destruction
    _data[Size-1]=0;
  }
  const BString &operator = (const char *src)
  {
    strncpy(_data,src,Size-1);
    return *this;
  }

  operator const char *() const {return _data;}
};

//! overloads that make conversion of C code easier 
template <int Size>
inline const BString<Size> & strcpy(BString<Size> &dst, const char *src)
{
  return dst = src;
}

Один случай , который вы должны использовать , char*а не std::stringкогда вам нужны статические строковые константы. Причина в том, что у вас нет никакого контроля над модулями заказа, инициализирующими свои статические переменные, а другой глобальный объект из другого модуля может ссылаться на вашу строку до ее инициализации. http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Global_Variables

std::string плюсы:

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

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

Вам следует подумать об использовании char*в следующих случаях:

• Этот массив будет передан в параметре.
• Вы заранее знаете максимальный размер вашего массива (вы его знаете ИЛИ навязываете).
• Вы не будете выполнять никаких преобразований в этом массиве.

На самом деле, в C ++ char*часто используются фиксированные маленькие слова, такие как параметры, имя файла и т. Д.

Когда использовать c ++ std :: string:

• Строки в целом более безопасны, чем char *. Обычно, когда вы делаете что-то с char *, вам нужно все проверять, чтобы убедиться, что все в порядке, в классе строк все это делается за вас.
• Обычно при использовании char * вам нужно освободить выделенную память, вам не нужно делать это со строкой, поскольку она освободит свой внутренний буфер при разрушении.
• Строки хорошо работают со строковым потоком C ++, форматировать ввод-вывод очень просто.

Когда использовать char *

• Использование char * дает вам больше контроля над тем, что происходит «за кулисами», что означает, что вы можете настроить производительность, если вам нужно.

Используйте (const) char * в качестве параметров, если вы пишете библиотеку. Реализации std :: string различаются между разными компиляторами.

Если вы хотите использовать библиотеки C, вам придется иметь дело с C-строками. То же самое применимо, если вы хотите предоставить свой API для C.

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

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

На что следует обратить внимание, например, operator[]большинство реализаций STL не выполняют проверку границ и должны преобразовывать это в ту же операцию с базовым массивом символов. AFAIK STLPort может дополнительно выполнять проверку границ, после чего этот оператор будет немного медленнее.

Так что же дает вам использование std :: string? Это освобождает вас от ручного управления памятью; изменить размер массива становится проще, и обычно вам нужно меньше думать об освобождении памяти.

Если вы беспокоитесь о производительности при изменении размера строки, есть reserve функция, которая может вам пригодиться.

если вы используете массив символов в подобном тексте и т.д., используйте std :: string более гибким и простым в использовании. Если вы используете его для чего-то еще, например, для хранения данных? использовать массивы (предпочитать векторы)

Даже когда производительность имеет решающее значение, лучше использовать vector<char>- он позволяет заранее выделить память (метод резерв ()) и поможет избежать утечек памяти. Использование vector :: operator [] приводит к накладным расходам, но вы всегда можете извлечь адрес буфера и проиндексировать его точно так же, как если бы это был char *.

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