Wenn du das so hintereinander ausführst, hast du undefiniertes Verhalten, sher wahrscheinlich sogar einen Absturz.
Grund:
mit char* string definierst du nur einen zeiger, der auf nix zeigt.

du hast folgende möglichkeite;

// 1:
char string[100];  // speicher vom stack, gilt nur im aktuellen scope
                   // hier hast du platz für 99 Zeichem, da das letzte immer ein \0 sein muss.
                   // hier kann der string maximal die größe des stacks annehmen, ansosnten gibts nen linker fehler

// 2:
char string* = (char*) malloc(100); // dynamischer speicher, kann außerhalb des aktuellen scopes verwendet werden
                                    // muss per hand wieder freigegeben werden
                                    // größe kann bis zu 2GB sein, 
                                    // muss überprüft werden, ob speicher alloziert werden konnte

// 3:
std::string string;       // da wir im c++ forum sind, ist das die zu bevorzugende lösung, 
                          // da hier die speicherverwaltung automatisch passiert und die Klasse an sich auch sehr 
                          // komfortabel ist.
                          // für kompatibiltätszwecke mit c funktionen bekommst du mit string.c_str() einen char*

// 1:
char string[100];  // speicher vom stack, gilt nur im aktuellen scope
                   // hier hast du platz für 99 Zeichem, da das letzte immer ein \0 sein muss.
                   // hier kann der string maximal die größe des stacks annehmen, ansosnten gibts nen linker fehler

Nein, du hast Platz für 100 Zeichen. Niemand hindert einem daran, das NULL-Zeichen am Ende des Strings nicht zu speichern!

vlad_tepesch schrieb:

// 2:
char string* = (char*) malloc(100); // dynamischer speicher, kann außerhalb des aktuellen scopes verwendet werden
                                    // muss per hand wieder freigegeben werden
                                    // größe kann bis zu 2GB sein, 
                                    // muss überprüft werden, ob speicher alloziert werden konnte

Heiliger Informatiker. Wir sind hier im C++ Bereich, verwende also bitte new !

char string* = new char[100];

// ...

delete[] string;

Zudem kann auch mehr als 2GB angefordert werden. Das kommt ganz darauf an, wieviel Arbeitspeicher frei ist und wieviel das Betriebsystem einem gibt.

vlad_tepesch schrieb:

// 3:
std::string string;       // da wir im c++ forum sind, ist das die zu bevorzugende lösung, 
                          // da hier die speicherverwaltung automatisch passiert und die Klasse an sich auch sehr 
                          // komfortabel ist.
                          // für kompatibiltätszwecke mit c funktionen bekommst du mit string.c_str() einen char*

Tut mir leid, aber auch hier hast du einen Fehler. Bei der Methode c_str bekommt man einen char const* .
Referenz zu std::string , bzw. std::basic_string :
http://www.cplusplus.com/reference/string/

@neoexpert,
Man sollte übrigens keine literale über char* zugreifen. Also immer so etwas machen:
char const* string = "Test!";

Grüssli

char string[100];
sind doch 100 zeichen + \0 oder?
denn wenn man alle elmente aufzählt von 0 bis 100 sind es ja 101

Nein. Die Nullterminierung ist in den 100 Zeichen eingeschlossen. Faktisch hast du also nur für 99 Zeichen Platz.

Bei einem Array mit der Dimension n sind gültige Indizes in [0, n-1] .

neoexpert schrieb:

char string[100];
sind doch 100 zeichen + \0 oder?
denn wenn man alle elmente aufzählt von 0 bis 100 sind es ja 101

Nein. Die Nullterminierung ist in den 100 Zeichen eingeschlossen. Faktisch hast du also nur für 99 Zeichen Platz.

Ich kann mich nur nochmals wiederholen, nein!

char const* test = "Test!"; // 5 Zeichen + '\0'

char array[5];
std::copy(test, test + 5, array);

Das ist absolut gültig! Man muss die Nullterminierung nicht abspeichern.

Grüssli

Das ist absolut gültig! Man muss die Nullterminierung nicht abspeichern.

Nur kriegt man dann Probleme, wenn man mit den C-Funktionen strcpy() , strlen() und Co. hantiert. Aber nicht nur dann.

Probier mal Folgendes:

char Str[5] = {'H', 'a', 'l', 'l', 'o'};
std::cout << Str << std::endl;

Dravere schrieb:

Das ist absolut gültig! Man muss die Nullterminierung nicht abspeichern.

Nur kriegt man dann Probleme, wenn man mit den C-Funktionen strcpy() , strlen() und Co. hantiert. Aber nicht nur dann.

Probier mal Folgendes:

char Str[5] = {'H', 'a', 'l', 'l', 'o'};
std::cout << Str << std::endl;

Wer sagt, dass du das Teil so anwenden möchtest? Vielleicht nimmt jemand einfach auch die Grösse als Zahl mit. Dann gibt es nämlich auch strncpy und strlen ist unnötig. Desweiteren sind die zwei Funktionen auch noch C. Und wer sagt, das man nur Strings darin speichern möchte?

Es geht hier nämlich um was grundsätzliches, man sollte nicht den Eindruck vermitteln, dass man bei einem Array immer nur Platz für n-1 hat. Was ihr eigentlich sagen wollt, ist das folgende:

char string[6] = "Test!"; // hier muss man 6 verwenden, weil das '\0' mit gespeichert wird.

Aber das heisst nicht, dass man ein array immer so verwenden muss.

Grüssli

Man muss die Nullterminierung nicht abspeichern.

Wenn man die Größenangaben selbst macht, dann muss man daran denken.

Natürlich kommts drauf an, ob man nur ein char-Array will oder einen C-String. Beim ersteren braucht man natürlich keine Nullterminierung.

Natürlich kommts drauf an, ob man nur ein char-Array will oder einen C-String. Beim ersteren braucht man natürlich keine Nullterminierung.

Bei ersterem weist man aber auch selten String-Literale zu...

Wenn man in C++ noch ernsthaft mit char -Arrays arbeiten will und diese auch zur Textspeicherung benutzt, wird man wahrscheinlich auch mit den C-Funktionen darauf arbeiten. Und es ist dann immer noch komfortabler, ein Byte mehr auszugeben, um einen gültigen C-String zu haben.

Aber klar, für char-Arrays im Sinne der Speicherung einzelner Zeichen braucht es natürlich kein '\0'.

neoexpert schrieb:

char string[100];
sind doch 100 zeichen + \0 oder?
denn wenn man alle elmente aufzählt von 0 bis 100 sind es ja 101

Nein. Die Nullterminierung ist in den 100 Zeichen eingeschlossen. Faktisch hast du also nur für 99 Zeichen Platz.

Bei einem Array mit der Dimension n sind gültige Indizes in [0, n-1] .

char string[100];
string[0]='A';      //das erste Element
string[100]='B';    //das letzte Element oder?

also müsste doch 101 sein oder?

Wenn man in C++ noch ernsthaft mit char -Arrays arbeiten will und diese auch zur Textspeicherung benutzt, wird man wahrscheinlich auch mit den C-Funktionen darauf arbeiten. Und es ist dann immer noch komfortabler, ein Byte mehr auszugeben, um einen gültigen C-String zu haben.

Also ich persönlich nicht. Ich verwende immer die Standardbibliothek C++ Algorithmen und führe selber auch meistens die Grösse mit, wenn ich ein C-Array verwende. Um mit Stringliteralen zu arbeiten, verwende ich allerdings meistens char const* . Und auch dort verwende ich oft die Algorithmen. Man bleibt irgendwie einheitlicher, hat mehr Möglichkeiten und wenn man einmal die Grösse braucht, hat man sie in O(1) und nicht in O(N).
Aber naja, es passiert bei mir sowieso extrem selten, dass ich C-Strings oder C-Arrays verwende. Meistens nehme ich std::string für C-Strings oder std::vector für C-Arrays, auch wenn die Grössen konstant bleiben.

Grüssli

Nexus schrieb:

Wenn man in C++ noch ernsthaft mit char-Arrays arbeiten will [...]

Aber wenn man sehr schnell mit char -Arrays arbeiten muss, kommt man natürlich nicht drum herum, die Grösse separat zu speichern.