char * vs std :: string in c ++ [geschlossen]

Wann sollte ich verwenden std::stringund wann sollte ich char*Arrays von chars in C ++ verwalten?

Es scheint, dass Sie verwenden sollten, char*wenn Leistung (Geschwindigkeit) entscheidend ist und Sie aufgrund der Speicherverwaltung bereit sind, ein riskantes Geschäft zu akzeptieren.

Gibt es andere zu berücksichtigende Szenarien?

Sie können std :: Strings als Referenz übergeben, wenn sie groß sind, um ein Kopieren zu vermeiden, oder einen Zeiger auf die Instanz, sodass ich keinen wirklichen Vorteil bei der Verwendung von Zeichenzeigern sehe.

Ich benutze std :: string / wstring für mehr oder weniger alles, was tatsächlicher Text ist. char *ist jedoch für andere Datentypen nützlich, und Sie können sicher sein, dass die Zuordnung wie gewünscht aufgehoben wird. Ansonsten ist std :: vector der richtige Weg.

Es gibt wahrscheinlich Ausnahmen von all dem.

Mein Standpunkt ist:

• Verwenden Sie niemals char *, wenn Sie keinen "C" -Code aufrufen.
• Verwenden Sie immer std :: string: Es ist einfacher, benutzerfreundlicher, optimiert, Standard, verhindert Fehler, es wurde überprüft und funktioniert nachweislich.

Verwendung von Rohzeichenfolgen

Ja, manchmal kann man das wirklich. Wenn Sie const char *, char-Arrays, die auf dem Stack zugewiesen sind, und String-Literale verwenden, können Sie dies so tun, dass überhaupt keine Speicherzuweisung erfolgt.

Das Schreiben eines solchen Codes erfordert oft mehr Nachdenken und Sorgfalt als die Verwendung von Zeichenfolgen oder Vektoren, kann jedoch mit geeigneten Techniken durchgeführt werden. Mit den richtigen Techniken kann der Code sicher sein, aber Sie müssen immer sicherstellen, dass Sie beim Kopieren in char [] entweder einige Garantien für die Länge der zu kopierenden Zeichenfolge haben oder dass Sie übergroße Zeichenfolgen ordnungsgemäß prüfen und handhaben. Wenn Sie dies nicht tun, hat die strcpy-Funktionsfamilie den Ruf, unsicher zu sein.

Wie Vorlagen beim Schreiben sicherer Zeichenpuffer helfen können

In Bezug auf die Sicherheit von char [] -Puffern können Vorlagen hilfreich sein, da sie eine Kapselung für die Behandlung der Puffergröße für Sie erstellen können. Vorlagen wie diese werden z. B. von Microsoft implementiert, um strcpy sicher zu ersetzen. Das Beispiel hier ist aus meinem eigenen Code extrahiert, der echte Code hat viel mehr Methoden, aber dies sollte ausreichen, um die Grundidee zu vermitteln:

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;
}

Eine Gelegenheit, die Sie verwenden MÜSSEN char*und nicht, std::stringist, wenn Sie statische Zeichenfolgenkonstanten benötigen. Der Grund dafür ist, dass Sie keine Kontrolle über die Reihenfolge haben, in der Module ihre statischen Variablen initialisieren, und ein anderes globales Objekt aus einem anderen Modul möglicherweise auf Ihre Zeichenfolge verweist, bevor es initialisiert wird. http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Global_Variables

std::string Profis:

• verwaltet den Speicher für Sie (der String kann wachsen und die Implementierung weist Ihnen einen größeren Puffer zu)
• Übergeordnete Programmierschnittstelle, funktioniert gut mit dem Rest von STL.

std::stringNachteile: - Zwei unterschiedliche STL-Zeichenfolgeninstanzen können nicht denselben zugrunde liegenden Puffer gemeinsam nutzen. Wenn Sie also den Wert übergeben, erhalten Sie immer eine neue Kopie. - Es gibt einige Leistungseinbußen, aber ich würde sagen, wenn Ihre Anforderungen nicht besonders sind, ist dies vernachlässigbar.

Sie sollten die Verwendung char*in folgenden Fällen in Betracht ziehen :

• Dieses Array wird im Parameter übergeben.
• Sie kennen im Voraus die maximale Größe Ihres Arrays (Sie kennen es ODER Sie legen es fest).
• Sie werden keine Transformation für dieses Array durchführen.

Tatsächlich werden sie in C ++ char*häufig für feste kleine Wörter wie Optionen, Dateinamen usw. verwendet.

Wann wird ein c ++ std :: string verwendet?

• Zeichenfolgen sind insgesamt sicherer als char *. Wenn Sie Dinge mit char * tun, müssen Sie normalerweise überprüfen, ob die Dinge richtig sind. In der Zeichenfolgenklasse wird dies alles für Sie erledigt.
• Wenn Sie char * verwenden, müssen Sie normalerweise den von Ihnen zugewiesenen Speicher freigeben. Dies müssen Sie nicht mit string tun, da der interne Puffer bei Zerstörung freigegeben wird.
• Strings funktionieren gut mit C ++ - Stringstream. Formatierte E / A sind sehr einfach.

Wann wird char * verwendet?

• Mit char * haben Sie mehr Kontrolle darüber, was "hinter" den Kulissen passiert, sodass Sie die Leistung bei Bedarf optimieren können.

Verwenden Sie (const) char * als Parameter, wenn Sie eine Bibliothek schreiben. std :: string-Implementierungen unterscheiden sich zwischen verschiedenen Compilern.

Wenn Sie C-Bibliotheken verwenden möchten, müssen Sie sich mit C-Strings befassen. Gleiches gilt, wenn Sie Ihre API C aussetzen möchten.

Sie können davon ausgehen, dass die meisten Operationen an einem std :: string (z. B. z. B. find) so optimiert wie möglich sind, sodass sie wahrscheinlich mindestens so gut wie ein reines C-Gegenstück funktionieren .

Es ist auch erwähnenswert, dass std :: string-Iteratoren häufig Zeigern in das zugrunde liegende char-Array zugeordnet werden. Daher ist jeder Algorithmus, den Sie über Iteratoren entwickeln, in Bezug auf die Leistung im Wesentlichen identisch mit demselben Algorithmus über char *.

Beachten Sie beispielsweise operator[]Folgendes: Die meisten STL-Implementierungen führen keine Grenzwertprüfung durch und sollten dies in dieselbe Operation für das zugrunde liegende Zeichenarray übersetzen. AFAIK STLPort kann optional eine Grenzwertprüfung durchführen. Zu diesem Zeitpunkt wäre dieser Operator etwas langsamer.

Was bringt Ihnen die Verwendung von std :: string? Es befreit Sie von der manuellen Speicherverwaltung. Das Ändern der Größe des Arrays wird einfacher, und Sie müssen im Allgemeinen weniger über die Freigabe von Speicher nachdenken.

Wenn Sie sich beim Ändern der Größe eines Strings Sorgen um die Leistung machen, gibt es eine reserveFunktion, die Sie möglicherweise nützlich finden.

Wenn Sie das Zeichenarray in ähnlichem Text usw. verwenden, verwenden Sie std :: string flexibler und benutzerfreundlicher. Wenn Sie es für etwas anderes wie Datenspeicherung verwenden? Arrays verwenden (Vektoren bevorzugen)

Auch wenn die Leistung entscheidend ist, sollten Sie sie besser nutzen vector<char>- sie ermöglicht die Speicherzuweisung im Voraus (Reserve () -Methode) und hilft Ihnen, Speicherlecks zu vermeiden. Die Verwendung von vector :: operator [] führt zu einem Overhead, aber Sie können die Adresse des Puffers jederzeit extrahieren und genau so indizieren, als wäre es ein Zeichen *.

AFAIK implementiert intern die meisten std :: string-Kopien beim Schreiben, referenzgezählte Semantik, um Overhead zu vermeiden, selbst wenn Strings nicht als Referenz übergeben werden.