char* vs. std::string in c++ [closed]

Lesezeit: 6 Minuten

Wann sollte ich verwenden std::string und wann sollte ich verwenden char* um Arrays von zu verwalten chars in C++?

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

Gibt es andere Szenarien zu berücksichtigen?

Mein Standpunkt ist:

  • Verwenden Sie niemals char *, wenn Sie keinen “C”-Code aufrufen.
  • Verwenden Sie immer std::string: Es ist einfacher, es ist benutzerfreundlicher, es ist optimiert, es ist Standard, es verhindert, dass Sie Fehler haben, es wurde überprüft und hat sich bewährt.

Benutzer-Avatar
Skurmedel

Sie können durch std::strings als Referenz, wenn sie groß sind, um ein Kopieren zu vermeiden, oder ein Zeiger auf die Instanz, sodass ich keinen wirklichen Vorteil sehe char Zeiger.

ich benutze std::string/wstring für mehr oder weniger alles, was eigentlicher Text ist. char * ist jedoch für andere Datentypen nützlich, und Sie können sicher sein, dass die Zuweisung aufgehoben wird, wie es sollte. Ansonsten std::vector<char> ist der Weg zu gehen.

Von all dem gibt es wohl Ausnahmen.

  • Gibt es einen Leistungsunterschied vor den beiden?

    – vtd-xml-Autor

    11. September 2010 um 1:55 Uhr

  • @vtd-xml-author: Einige vielleicht. Gerade char * hat fast keinen Overhead. Genau was Overhead std::string weiß ich nicht, es ist wahrscheinlich implementierungsabhängig. Ich erwarte kaum, dass der Aufwand viel größer ist als der eines bloßen Zeichenzeigers. Da ich keine Kopie des Standards besitze, kann ich die Garantien des Standards nicht wirklich detailliert beschreiben. Jeder Leistungsunterschied wird wahrscheinlich in Abhängigkeit von den durchzuführenden Operationen variieren. std::string::size könnte die Größe neben den Zeichendaten speichern und somit schneller sein als strlen.

    – Skurmedel

    11. September 2010 um 2:08 Uhr


  • Warum nicht std::string für Nicht-Text-Daten verwenden? Sie sind nicht nullterminiert, also sollten Sie in der Lage sein, alles zu speichern, was Sie wollen.

    – Casey Rodarmor

    13. März 2012 um 0:01 Uhr

  • @rodarmor Du kann Speichern Sie alles, was Sie wollen, obwohl es ein bisschen riskant ist, da string für nullterminierte Zeichenfolgen entwickelt wurde. Sie müssen darauf achten, nur binärsichere Operationen zu verwenden, z append(const string&) und append(const char*, size_t) anstatt operator+=().

    – Knabenhaft

    13. März 2012 um 11:53 Uhr

  • Bist du sicher? Ich weiß, dass viele Operationen davon ausgehen, dass ein char* eine nullterminierte Zeichenfolge ist, aber ich kann mir keine vorstellen, die davon ausgeht, dass eine std::string keine Nullen enthält.

    – Casey Rodarmor

    14. März 2012 um 0:00 Uhr

Benutzer-Avatar
Suma

Raw-String-Verwendung

Ja, manchmal kann man das wirklich. Bei der Verwendung von const char *, auf dem Stapel zugewiesenen char-Arrays und Zeichenfolgenliteralen 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 Strings oder Vektoren, aber mit einer geeigneten Technik ist dies möglich. Mit den richtigen Techniken kann der Code sicher sein, aber Sie müssen immer sicherstellen, wenn Sie in char kopieren [] Sie haben entweder einige Garantien für die Länge der zu kopierenden Zeichenfolge, oder Sie überprüfen und handhaben übergroße Zeichenfolgen ordnungsgemäß. Dies nicht zu tun, hat der strcpy-Funktionsfamilie den Ruf eingebracht, unsicher zu sein.

Wie Vorlagen helfen können, sichere Zeichenpuffer zu schreiben

Wie für Char [] Puffersicherheit können Vorlagen hilfreich sein, da sie eine Kapselung für die Handhabung der Puffergröße für Sie erstellen können. Vorlagen wie diese werden zB von Microsoft implementiert, um einen sicheren Ersatz für strcpy bereitzustellen. Das Beispiel hier ist aus meinem eigenen Code extrahiert, der echte Code hat viel mehr Methoden, aber das sollte reichen, 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;
}

  • +1 für “Wenn Sie const char *, auf dem Stapel zugewiesene char-Arrays und Zeichenfolgenliterale verwenden, können Sie dies so tun, dass überhaupt keine Speicherzuweisung erfolgt.” Die Leute vergessen, dass die “Zuweisung” von Stacks viel schneller ist als die von Heaps.

    – NoSenseetAl

    12. Oktober 2011 um 12:02 Uhr

  • char* Strings sind nicht immer auf dem Stack. char *str = (char*)malloc(1024); str[1024] = 0;

    – Cole Tobin

    26. April 2013 um 19:27 Uhr

  • @ColeJohnson Ich behaupte das nicht, ich meine nur, wenn Sie möchten, dass Ihre Zeichenfolge dem Stapel zugewiesen wird, müssen Sie const char * in Verbindung mit Zeichenfolgenliteralen verwenden, nicht std::string.

    – Suma

    27. April 2013 um 22:30 Uhr

Benutzer-Avatar
dasselbe

Eine Gelegenheit, die Sie nutzen MÜSSEN char* und nicht std::string ist, 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 auf Ihren String verweisen kann, bevor es initialisiert wird. http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Global_Variables

std::string Vorteile:

  • verwaltet den Speicher für Sie (die Zeichenfolge kann wachsen, und die Implementierung weist Ihnen einen größeren Puffer zu)
  • Programmierschnittstelle auf höherer Ebene, funktioniert gut mit dem Rest von STL.

std::string Nachteile: – Zwei unterschiedliche STL-String-Instanzen können nicht denselben zugrunde liegenden Puffer teilen. Wenn Sie also nach Wert übergeben, erhalten Sie immer eine neue Kopie. – Es gibt einige Leistungseinbußen, aber ich würde sagen, es sei denn, Ihre Anforderungen sind speziell, es ist vernachlässigbar.

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

  • Dieses Array wird als Parameter übergeben.
  • Sie kennen die maximale Größe Ihres Arrays im Voraus (Sie wissen es ODER Sie legen es fest).
  • Sie werden an diesem Array keine Transformation vornehmen.

Eigentlich in C++, char* werden oft für feste kleine Wörter, als Optionen, Dateinamen usw. verwendet.

  • Das Array wird nicht übergeben, ein Zeiger auf das Array. Das ist ein Zeiger – ein Zeiger auf ein Objekt.

    – Cole Tobin

    26. April 2013 um 19:23 Uhr

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

  • Das Array wird nicht übergeben, ein Zeiger auf das Array. Das ist ein Zeiger – ein Zeiger auf ein Objekt.

    – Cole Tobin

    26. April 2013 um 19:23 Uhr

Benutzer-Avatar
Vishnu CS

Wann sollte man einen c++ std::string verwenden:

  • strings sind insgesamt sicherer als char*Normalerweise, wenn Sie Dinge mit tun char* Sie müssen die Dinge überprüfen, um sicherzustellen, dass die Dinge in Ordnung sind string Klasse, das alles wird für Sie erledigt.
  • Normalerweise bei der Verwendung char*müssen Sie den zugewiesenen Speicher freigeben, das müssen Sie nicht tun string da es seinen internen Puffer freigibt, wenn es zerstört wird.
  • strings funktionieren gut mit c++ stringstreamformatierte IO ist sehr einfach.

Wann verwendet man char*

  • Verwenden char* gibt Ihnen mehr Kontrolle darüber, was “hinter” den Kulissen passiert, was bedeutet, dass Sie die Leistung bei Bedarf anpassen können.

1013410cookie-checkchar* vs. std::string in c++ [closed]

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy