0x00 und char-arrays

Warum char-arrays halten direkt vor einem 0x00-byte erkannt wird und wie kann dieses problem vermieden werden (vielleicht durch ein mit einem anderen Datentyp (welche und warum) oder einen "trick" mit dem char)?

Zum Beispiel in dem folgenden code, wird der Ausgang "a" nur die anderen bytes werden nicht angezeigt:

unsigned char cbuffer[]={0x61,0x00,0x62,0x63,0x0};
std::string sbuffer=reinterpret_cast<const char*>(cbuffer);

cout << sbuffer << endl;

Ähnlich wie im folgenden code, wird der Ausgang "ab":

unsigned char cbuffer[]={0x61,0x62,0x00,0x63,0x0};
std::string sbuffer=reinterpret_cast<const char*>(cbuffer);

Einfache und wirksame Abhilfen, um das problem (wo 0x00 gehalten wird, in das array wie eine normale byte) würde geschätzt.

Ähmm. Weil strings in C sind arrays von char beendet mit einem null-byte?
std::vector mit überladenen operator << (ostream&, const vector<char>&).
Nicht unbedingt. Es ist nicht ungewöhnlich, nicht zu verwenden, nachfolgende Nullen. Die Sprache selbst nur erfordert es für string-Literale. Die Bibliotheken können auch verlangen, aber das ist nicht das gleiche.

InformationsquelleAutor Chris Smith | 2011-12-14

c++char

6

Ist es üblich, in C zu übergeben, um strings als Zeiger auf null-terminierte char arrays. null wird vertreten durch 0x00. Um die Konvertierung einfach, die std::string ist constructable von einem Zeiger auf eine null-terminierte char-array, das ist, was passiert mit Ihrem code. Aber wenn es findet, der null ist, er denkt, dass das das Ende der Zeichenfolge. Wenn Sie cout ein char-array direkt, Sie werden feststellen, es macht die gleiche Annahme, weil Sie keinen anderen Weg, um zu bestimmen, das Ende der Zeichenkette gezeigt, durch eine char*. (Sie könnte theoretisch sagen, die Länge ist in Ihrem Fall, wenn Sie verstehen char (&)[], aber fast nichts in die standard-Bibliothek bietet leider).

Den beabsichtigten Problemumgehungen verwenden Sie diesen Konstruktor, stattdessen:
```
int len = sizeof(cbuffer)/sizeof(cbuffer[0]);
std::string sbuffer(cbuffer, len); //5 characters in cbuffer, 1 byte each
```
oder
```
int len = sizeof(cbuffer)/sizeof(cbuffer[0]);
std::cout.write(cbuffer, len); //5 characters in buffer, 1 byte each
```
Aber Sie müssen vorsichtig sein, mit sizeof(cbuffer). Wenn cbuffer ist ein char* (Zeiger) statt einer char(&)[] (array), dann sizeof(ptr) wird es wieder den falschen Wert, und es gibt keinen Weg, um die richtige Länge an diesem Punkt, wenn der string nicht null-terminiert ist.
- Dies ist gut, außer für nicht befürworten usign sizeof zu bestimmen, die Länge des Puffers.
- Hatte ich eigentlich, dass auf den ersten, aber dann entfernt, weil der gemeinsame "warum sizeof(ptr) return 4 habe ich 10 Briefe!". Ich werde Bearbeiten Sie die Antwort, um zu beschreiben, die vor-und Nachteile.
- "NULL-terminiert" NUL!
- Was? Denkst du meine Terminologie/Schreibweise falsch ist?
- Ente. Deine Rechtschreibung ist falsch. NULL ist ein Zeiger und NUL ist ein Zeichen.
- Wikipedia ist anderer Meinung: en.wikipedia.org/wiki/Null_character. NULL ist der name des Charakters. Es ist Häufig abgekürzt als NUL jedoch.
- Sie denken, dass meine Terminologie/Schreibweise falsch ist?" ja, in der Tat. "Wikipedia ist anderer Meinung" nicht: "Das null-Zeichen (auch null-terminator), kurz NUL," es ist null, ist nicht NULL.
- Ich werde zugeben, dass ich das falsch verstanden, die NULL ist ein Zeiger, und null Konzept. Aber lachen ist ein Zitat scheint (1) rude, (2) dumm, da du nicht zitieren überhaupt nichts.
- Sie teilen sollte mit sizeof(cbuffer[0]). Wer weiß, Wann jemand anderes (ein Betreuer mit einer Axt) wird switche der zugrunde liegende Typ wchar_t und std::wstring.
- NULL können Sie einen Namen für die ASCII-Zeichen, aber es ist auch eine standard-C-und C++ - makro, das expandiert zu einer null-Zeiger-Konstante. Ich habe bearbeitet die Antwort, das ändern der "NULL-terminiert", um die weniger verwirrend "null-terminiert".
- Seltsam, dein edit war mindestens 16 Minuten, nachdem ich den exakt gleichen Bearbeiten
- Ja, das ist seltsam. Die edit-Geschichte zeigt uns beide ändern NULL zu null. (Ich habe auch den Satz "string zeigte auf, indem Sie ein".)
InformationsquelleAutor Mooing Duck
2

char-arrays nicht alles tun,

Die C-string-Funktionen verwenden 0 zu markieren das Ende einer Zeichenkette.

std::cout überlastet ist für char-arrays zu drucken, die Sie als 'c' - Saiten, wenn Sie drucken möchten, die einzelnen Werte müssen Sie eine Schleife über die Werte, vielleicht wollen Sie auch ausgegeben werden als std::hex

In diesem Fall erstellen Sie einen std::String durch ein 'c' char-array, also der ctor von std::string wird davon ausgegangen, dass die 'c' - Saiten-Ende auf " 0 " stehen. Da es nur an eine Adresse im Speicher, wie sonst kann er wissen, wo der string zu Ende ist?

ps. Wenn Sie speichern möchten, die ein array von bytes ist, sollten Sie wahrscheinlich mit std::vector
- Das gleiche gilt verwalteten strings? System::String
- er nicht cout ein char-array, er couts a std::string Objekt, die nicht dieses Problem haben.
InformationsquelleAutor Martin Beckett

Versuchen:

#include <iostream>
#include <string>

int main()
{

    unsigned char cbuffer[]={0x61,0x62,0x00,0x63,0x0};

    //Here s1 is treating the cBuffer as a C-String
    //Thus it will only read upto the first '\0' character
    std::string s1(reinterpret_cast<const char*>(cbuffer));
    std::cout << s1 << "\n";

    //Here s2 is treating the cBuffer as an array.
    //It reads the specified length into the string.
    std::string s2(reinterpret_cast<const char*>(cbuffer), sizeof(cbuffer)/sizeof(cbuffer[0]));

    //Note: How std::cout prints the '\0' character may leave it empty. 
    std::cout << s2 << "\n";

}

InformationsquelleAutor Martin York

1

Dem 0x00-byte wird als sentinel zu markieren das Ende des Strings in C. Das gesamte array bleibt jedoch im Speicher. Sie können einen alternativen Konstruktor für std::string wenn Sie möchten, dass die Zeichenfolge, enthalten Sie die gesamte Zeichen-array. Aber den Druck, der string wäre immer noch geben Ihnen nur "ab". Diese Entscheidung zu vertreten, C-strings in dieser Weise ist einer dieser beliebige Entscheidungen, dass wir stecken geblieben sind, mit.

InformationsquelleAutor shibumi
0

0x00 ist eine non-print-Zeichen, 0..0x20, sind alle non-print chars obwohl einige dienen als Zeilenumbrüche. 0x00 dient zum beenden eine Zeichenkette.

InformationsquelleAutor John
0

Was willst du werden ersetzt (und gedruckt) für 0x00 im string?

Konstruktor ist verantwortlich für die Konvertierung von char[] in einen string.
Wie andere hingewiesen, die Sie verwenden müssen, verschiedene Konstruktor. Der code unten ist für mich zu arbeiten, aber es ist nicht sehr roboust. Der erste parameter muss ein Zeiger auf den array - (Sie sind frei zu verwenden, sicherer Gießen) und der zweite parameter ist die Länge des Arrays (sind Sie frei, um zu berechnen, dies in einer mehr
anspruchsvolle Art und Weise).
```
#include <iostream>
int main() {
  unsigned char cbuffer[]={0x61,0x00,0x62,0x63,0x00};
  std::string sbuffer((char *)cbuffer,5);
  std::cout << sbuffer << std::endl;
}
```
InformationsquelleAutor meolic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.