Verständnisfrage char arrays

camper

Fellhuhn schrieb:

camper schrieb:

Fellhuhn schrieb:

Richtig.

Falsch. Arrays sind keine Zeiger. Und das ist auch trivial: schließlich kann ein einzelner Zeiger unmöglich eine beliebig große Anzahl beliebiger Objekte speichern.

Was ich schrieb bezog sich auf das einen davor.

Seinen Beitrag hatte ich gar nicht gelesen, musste ja dank "Sie können einen Beitrag nicht so schnell nach Ihrem letzten absenden, bitte warten Sie einen Augenblick." ewig warten...

Oh, übersehen. Ok, so wird wenigstens niemand anderes verwirrt.

rudpower

Hier wird also wiederum das Array zum Zeiger umgewandelt. Dass das nur für char - und nicht für int -Zeiger gilt, liegt daran, dass für int* keine Überladung existiert, sondern nur für void* , also typenlose Zeiger, oder eben char* . Wenn du jetzt einen int* mittels << in den Stream schiebst, kommt es zu einer (wieder impliziten) Umwandlung zu void* , die entsprechende Operatorüberladung wird aufgerufen und die Adresse des int ausgegeben.

dies versteh ich wiederum nicht

Fellhuhn

Ganz einfach, es gibt für Zeige im ostream nur zwei <<-Operatoren Definitionen:

einmal für void* bei denen der Wert des Zeigers, also die Speicheradresse, ausgegeben wird
einmal für char* bei denen der String ausgegeben wird, bis zur 0.

Wenn du nun cout << xxx; aufrufst, wird geschaut ob xxx vom Typ char* ist. Ist dies der Fall wird der zweite Operator oben ausgeführt, bei allen anderen Zeigern erfolgt die Umwandlung zum void* und somit der erste Operator.

rudpower

also steht dort ein char* wird die Zeichenkette bis zur 0 ausgegeben und steht dort ein anderer Zeiger wie int* wird die Adresse ausgegeben die in dem Zeiger steht.

Fellhuhn

Richtig.

Kannst ja testweise mal deinen char-Array für die Ausgabe zum int-Zeiger casten:

cout << (int*)meinArray;

Dann sollte er die Adresse ausgeben.

rudpower

cout << &meinArray;

müsste ja das gleiche Ausgeben, also die Adresse des erstes Feldes.
Wie komm ich eigentlich an die zweite Adresse? doch über

cout << (int*)meinArray+1;

Das kann aber nicht stimmen, denn wenn ich &meinArray+1 schreibe bekomm ich eine andere Adresse obwohl das ja eigentlich äquivalent ist oder?
als Bsp:

char teste[] = "mytest";
	char* ptr_test = teste;
	cout << (int*)ptr_test << " " << ptr_test << " " << &teste << endl;
	/*cout << (int*)ptr_test+1 << endl;*/ //Ausgabe: 0012FF40
	cout << &ptr_test+1 << endl;          //Ausgabe: 0012FF38

alles sehr merkwürdig. wollt so auch nachvollziehen was auf dem stack passiert aber jetzt versteh ich gar nix mehr
Normalerweise müsste doch zwischen den Adressen ein Byte liegen, da ja char 1 Byte speichern kann.

berniebutt

rudpower schrieb:

Operatorüberladung ist neu für mich, ich kenne nur Funktionsüberladung

Man kann auch Operatoren überladen, nur das brauchst du hier nicht. Character-Arrays sind ANSI-C - sie brauchen das abschliessende Nullzeichen. Wir haben hier immer wieder Verständnisprobleme, weil ANSI-C seit C++ (hier oft geäussert) auf den Schrott gehören soll.

Fellhuhn

Das liegt das wenn du einen Pointer inkrementierst er immer so weit vorspringt wie groß das Element ist. Und ein char ist kleiner als ein int.

rudpower

char teste[] = "mytest";
	char* ptr_test = teste;
	cout << (int*)ptr_test << " " << ptr_test << " " << &teste << endl; //Ausgabe: 0012FF58 mytest 0012FF58
	cout << (int*)ptr_test+1 << endl;     //Ausgabe: 0012FF5C
	cout << &ptr_test+1 << endl;          //Ausgabe: 0012FF50

dann müsste ja die nächste Adresse 0012FF59 sein, da ja ein char 1 Byte belegt.

Fellhuhn

In der letzten Zeile nimmst du ja auch die Adresse von ptr_test während du davor den Inhalt von ptr_test genommen hast.

camper

rudpower schrieb:

char teste[] = "mytest";
	char* ptr_test = teste;
	cout << (int*)ptr_test << " " << ptr_test << " " << &teste << endl; //Ausgabe: 0012FF58 mytest 0012FF58
	cout << (int*)ptr_test+1 << endl;     //Ausgabe: 0012FF5C
	cout << &ptr_test+1 << endl;          //Ausgabe: 0012FF50

dann müsste ja die nächste Adresse 0012FF59 sein, da ja ein char 1 Byte belegt.

Operatorpräzedenz beachten.