bin heute über folgendes Phänomen gestolpert: Ich wollte ein C-Char-Array in einen String konvertieren und anschließend wieder zurück. Dabei ist mir dann irgend wann mal aufgefallen, dass die Char-Array-Größe nach der Rückkonvertierung erheblich kleiner ist als zu Beginn.

Wenn ich es per

std::string ret;
	for (int i = 0; i != Length+1; i++)
		ret.push_back(arr[i]);

(und per strcpy wieder zurück) konvertiere, bleibt die Größe erhalten, nicht jedoch, wenn ich es per std::string ret(arr); oder std::string ret = arr; mache.

Was genau machen die String-Konstruktoren mit einem Char-Array? Schmeißen die einfach Daten weg? Kann ja fast nicht sein ... Oder ist das ne Dateneinheitssache, also die Größe eines String-Elements entspricht nicht der Größe eines Elements eines Char-Arrays?

Hallo alle,

bin heute über folgendes Phänomen gestolpert: Ich wollte ein C-Char-Array in einen String konvertieren und anschließend wieder zurück. Dabei ist mir dann irgend wann mal aufgefallen, dass die Char-Array-Größe nach der Rückkonvertierung erheblich kleiner ist als zu Beginn.

Wie hast du das gemacht? Code?

Wie prüfst du die "Char-Array-Größe" ?

char array[] = "Hallo Welt";
string s = array;

string s = "lol";
char *c;
strcpy(s.c_str(), c);

und zurück gehts so:

string s = "lol";
char *c;
strcpy(s.c_str(), c);

Naja, Hauptsache 'c' zeigt auch auf einen genügend großen Speicherbereich.

Und bei den C-Funktionen kommt das Ziel zuerst

Aua!
Ich sag' ja, die sollten verboten werden.

std::string MyString = "MyString";
char const* pcMyString = MyString.c_str();

Vor allem, wenn du nur irgendwelche längen des zurückgegebenen C-Strings überprüfen willst

Grüssli

int main() 
{
	char const* pcMyString;
	{
		std::string MyString = "MyString"; 
		pcMyString = MyString.c_str();
	}
	std::cout << pcMyString << std::endl; // Zeiger ungültig, undefiniertes Verhalten
}

Für einen kleinen Test geht das zwar schon, ...

Und genau darum geht es doch hier, oder?
Aber gut, dass du es noch ergänzt hast, falls dies jemandem nicht bewusst war, so ist es nun, hoffentlich.
Bei Nicht-Tests sollte man allerdings wenn möglich sowieso auf den C-String verzichten. Erst recht, wenn man zum Beispiel eine Kopie irgendwohin weitergeben möchte, dann gleich den std::string weitergeben!

Grüssli

Im Grund tritt das Problem bei mir in folgendem Zusammenhang auf:

Ich verwende eine Funktion, die als Argument ein Char-Array verwendet und in dieses das Ergebnis hineinschreibt.

Die exakt benötigte Größe kann ich mir vorher von der Funktion zurückgeben lassen, indem ich sie mit leerem Argument anstelle des Char-Arrays aufrufe (damit weiß ich auch, wie viel Speicher ich reservieren muss).

Sagen wir mal, das Char-Array hatte vorher eine Größe von 300 Byte. Wenn ich nun dieses Char-Array wie oben beschrieben in einen String umwandle, so ist dieser nur noch sagen wir mal 35 Byte groß. Wenn ic hden String dann per strcpy wieder in ein Char-Array umwandle enthält dieses auch nur noch die 35 Byte.

Wenn ich die einzelnen Elemente des Char-Arrays "per Hand" in den String kopiere, funktioniert alles wunderbar.

Ein Char Array hat immer eine feste Größe!

Vielleicht ist das Element am Index 36 eine '0'?

Genau und deshalb kann man einen String auch mit Iteratoren bauen, bzw. mit Zeigern:

char* pArray; // Das Array
int iSize; // Die Grösse des Arrays

std::string MyString(pArray, pArray + iSize); // kopiert auch 0-Elemente.

Grüssli

TheBrain schrieb:

Wenn ic hden String dann per strcpy wieder in ein Char-Array umwandle enthält dieses auch nur noch die 35 Byte.

Das ist eben keine Umwandlung. Du musst die Grösse des Char-Arrays schon vorher festlegen, damit du auch keine Speicherverletzungen hast. Wenn du dann ein Char-Array mit einer genug grossen Länge hast, kannst du per strcpy() die ersten x Zeichen füllen. Die restlichen (hinter dem '\0') bleiben eben unbeschrieben, aber wären immer noch für die Benutzung vorhanden.

David_pb schrieb:

Vielleicht ist das Element am Index 36 eine '0'?

Wenn schon, eine '\0'

David_pb schrieb:

Vielleicht ist das Element am Index 36 eine '0'?

Wenn schon, eine '\0'

Jaja!

@David_pb && Dravere: Verdammt, ja, das kann gut sein. Finde ich ehrlich gesagt aber ganz schön tückisch ... das müsste doch dann ziemlich oft passieren.

@Nexus: Größe mitschleppen is nich, da es über mehrere Funktionsaufrufe hinweg geht (will nicht für jede Funktion nen extra Größenparameter).

@David_pb && Dravere: Verdammt, ja, das kann gut sein. Finde ich ehrlich gesagt aber ganz schön tückisch ... das müsste doch dann ziemlich oft passieren.

Naja, strlen und co sind halt wirklich für C-Strings gedacht und die enden immer mit einem '\0'. Wenn man diese Funktionen dann nicht für C-Strings sondern für Byte-Arrays verwendet, dann verwendet man die Sache halt falsch und es treten Fehler auf.
Für Byte-Arrays in C musst du irgendwie die Länge mitgeben. Und wenn möglich dann über memcpy oder ähnliches kopieren, in C auf C.

Um von C auf C++ zu kopieren, geht es am besten mit dem oben genannten Weg. Das geht bei allen Containern.

Ich sehe daher keinen Weg, wie du um das durchreichen der Array-Grösse drumherum kommst. Das ist halt ein Problem bei C-Arrays.

Grüssli