Ich bin immer interessiert daran, was "wirklich" hinter den Dingen steht und im Fall von Pointern interessiert mich, was der Compiler schlussendlich wirklich mit dem Code macht.

Es geht um das Dereferenzieren von Pointer

Man deklariert einen Pointer ja in der Weise:
int a;
int* ptr = &a

Wenn der Compiler auf den Ausdruck "int*" stoesst, interpretiert er ihn als:

Compiler schrieb:

Ok, das ist eine Variable ptr, vom type "int*". D.h. der Wert(der binaere Code) der unter der Adresse ptr (also &ptr) gespeichert ist, repraesentiert eine "Adresse im Arbeitsspeicher".

(So wie er bei int a, sieht, dass unter der Adresse, die a repraesentiert (also &a) ein binaerer Code liegt, der eine Integer Zahl repraesentiert.)
Und das "int" im "int*" heisst, dass die Adresse, welche in ptr gespeichert ist, eine Variable enthaelt, die als int zu interpretieren ist.

Und so kann ich natuerlich auch einer Variablen ptr2 von typ int* einen Wert, der eine Adresse repraesentieren _kann_, direkt zuweisen:

int* ptr = 0x7fff765144e8;

Was nichts anderes sagt, als dass das eine Adresse ist und diese Adresse auf einen int zeigt.

Und wenn ich jetzt schreibe:

int** ptr3 = &ptr;
dann sagt dass dem compiler:

Compiler schrieb:

Ok, der Wert, der unter der adresse ptr3 (also &ptr) finde ich eine Adresse.
Und unter dieser Adresse ist eine Pointer gespeichert. (also *ptr3 = ptr)
Und wenn ich mit dann den Wert dieses Pointers angucke,dann ist dort eine Adresse gespeichert, unter welcher ein int zu finden ist (also *ptr = ptr = &a)

Hier kurz ein Code dazu:

#include <iostream>

int main() {

int a = 5;

int* ptr = &a;

int* ptr2 = (int*) 0x7fff765144e8;

std::cout << "&a : " << &a << std::endl;
std::cout << "ptr : " << ptr << std::endl; 
std::cout << "ptr2 : " << ptr2 << std::endl;

int** ptr3 = &ptr;
std::cout << "ptr3 : " << ptr3 << std::endl; 

std::cout << "&ptr : " << &ptr << std::endl;
std::cout << "*ptr3 : " << *ptr3 << std::endl;

return 0;
}

und die Ausgabe:

&a : 0x7fff0c2e17fc
ptr : 0x7fff0c2e17fc
ptr2 : 0x7fff765144e8
ptr3 : 0x7fff0c2e17f0
&ptr : 0x7fff0c2e17f0
*ptr3 : 0x7fff0c2e17fc

Soweit so gut.
Nur bin ich mir nicht ganz sicher, ob diese Erklaerung stimmt, die ich mir zusammengereimt habe.

Weil, dieser Code:

#include <iostream>

int main(){

char x = 'a';

char* ptrx = &x;

std::cout << "x: " << x << " at " << (char*) ptrx << std::endl;

return 0;
}

sollte nach meiner Erklaerung fur den Compiler bedeuten:

Ok, "char* ptrx = &x" bedeutet dass unter der Adresse von ptrx (also &ptrx) eine Adresse gespeicher ist. Und unter dieser Adresse liegt ein Char"

Aber die Ausgabe sieht so aus

x: a at a���o�

(in wirklichkeit besteht die Darstellung nicht von (char*) ptrx nicht aus diesen Zeichen, sondern aus ein paar exotischen Sonderzeichen.

Wenn ich jetzt aber schreibe (int*) ptrx
dann kommt das raus:

(int*) ptrx : 0x7fffff2dab37

Und jetzt sozusagen die harte Pruefung:

#include <iostream>

int main(){

char x = 'a';

char* ptrx = &x;

std::cout << "&x : " << &x << std::endl;
std::cout << "x: " << x << " at " << (char*) ptrx << std::endl;

std::cout << "(int*) ptrx : " << (int*) ptrx << std::endl;
return 0;

}

Und das ergibt:

&x : a7�-��
x: a at a7�-��
(int*) ptrx : 0x7fffff2dab37

(Hier besteht die (char*) Darstellung wieder eigentlich aus exotischen Sonderzeiche, aber sie sind ebenfalls ident (wie hier auch die konvertierte Variante)

Um jetzt also zu meiner eigentlichen Frage zu kommen.

Bei den Datenypen "int*", "char*", "int**", etc.
sagt der der "" (asterix) dem Compiler wohl, dass es sich um eine Adresse handelt. Aber was sagt der "int", "char" etc Teil (von "int", "char*",...) dem Compiler ?

Tut mir leid, falls ich das etwas sehr ausfuehrlich dargestellt habe. Aber ich denke ich wuerde sonst leicht missverstanden werden.

Der int, char Teil sagt nur, welcher Datentyp an dieser Adresse gespeichert ist.
Das Problem bei der Ausgabe liegt lediglich daran, dass char* automatisch als Zeichenkette interpretiert wird. Die geht bis zum Zeichen '\0'. Wenn du das ausgibst, gibt der alle char's aus, die hinter der Startadresse im Speicher stehen, bis er ein '\0' findet. Deshalb der Zeichenmüll.
Wenn du die Adresse haben willst, musst du nach void* casten, dann kommt die richtige Ausgabe.

Aha ! Also "(char*) ptrx" bedeutet: Gehe and die Adresse ptrx und interpretiere den dort gespeicherten Wert als char.

Ok. Aber warum gibt er bei (int*) die Adresse dann in Hexadezimal aus, und nicht in Dezimal - wie es std::cout ja auch bei allen anderen int tut ?

#include <iostream>

int main(){

char x = 'a';

char* ptrx = &x;

std::cout << "&x : " << &x << std::endl;
std::cout << "x: " << x << " at " << (char*) ptrx << std::endl;

std::cout << "(int*) ptrx : " << (int*) ptrx << std::endl;
std::cout << "(void*) ptrx: " << (void*) ptrx << std::endl;
return 0;

}

Ausgabe:

&x : a�!�v�
x: a at a�!�v�
(int*) ptrx : 0x7fff76a221f7
(void*) ptrx: 0x7fff76a221f7

Du musst auch die anderen Adressen casten, also auch die mit &, damit du die richtige Adresse hast.

Schon klar.
Ich wollte nur zeigen, dass (void*) und (int*) das gleiche anzeigt.

Nathan schrieb:

Ja, int* geht auch.
Das hexadezimale liegt an einer Einstellung der Streams, denn ein int* ist kein int, weswegen da andere (Ausgabe-)regeln gelten.

Swordfish schrieb:

idrake schrieb:

Aber warum gibt er bei (int*) die Adresse dann in Hexadezimal aus, und nicht in Dezimal - wie es std::cout ja auch bei allen anderen int tut ?

Die Adresse eines int s ist ein anderer Typ als ein int . cout gibt jeden Pointertyp hexadezimal aus.

Natuerlich, dass ein int und int* zwei verschiedene Datentypen sind ist mir sonnenklar

Mir geht es jetzt darum, was der Compiler tut.

Also:

Wenn der Compiler bei "(char*) ptrx" alles an dieser Adresse (ptrx) als char behandelt, warum behandelt er dann nicht bei "(int*) ptrx" alles an dieser adresse als int ?

Siehe:

idrake schrieb:

Nathan schrieb:

Der int, char Teil sagt nur, welcher Datentyp an dieser Adresse gespeichert ist.
Das Problem bei der Ausgabe liegt lediglich daran, dass char* automatisch als Zeichenkette interpretiert wird. Die geht bis zum Zeichen '\0'. Wenn du das ausgibst, gibt der alle char's aus, die hinter der Startadresse im Speicher stehen, bis er ein '\0' findet. Deshalb der Zeichenmüll.
Wenn du die Adresse haben willst, musst du nach void* casten, dann kommt die richtige Ausgabe.

Aha ! Also "(char*) ptrx" bedeutet: Gehe and die Adresse ptrx und interpretiere den dort gespeicherten Wert als char.

Ok. Aber warum gibt er bei (int*) die Adresse dann in Hexadezimal aus, und nicht in Dezimal - wie es std::cout ja auch bei allen anderen int tut ?

Edit:

Um es anders zu formulieren:

Wenn es stimmt, dass bei
(char*) ptrx
der Compiler zur Adresse ptrx geht und alles dort als char behandelt,

dann muss analog, der Compiler bei
(int*) ptrx
zur Adresse ptrx gehen und dort alles als int behandeln.

Aber das ist offensichtlich nicht so, weil cout es als hexadezimal und nicht als dezimal wie alle anderen int ausgiebt.

Folgich stimmt entweder die Praemisse nicht, oder es handelt sich um eine Ausnahme.
Was ist der Fall ?

Wenn der Compiler bei "(char*) ptrx" alles an dieser Adresse (ptrx) als char behandelt, warum behandelt er dann nicht bei "(int*) ptrx" alles an dieser adresse als int ?

Er tut es.
Für den Compiler sind die nachfolgenden sizeof(char) Bytes an Adresse ptrx Bestandteile eines chars. Wenn man auf den Wert zugrefit werden die sizeof(char) * CHAR_BIT Bits als char interpretiert.
Das Gleiche gilt für int. Die nachfolgenden sizeof(int) * CHAR_BIT Bits werden als int interpretiert.
Der Stream (in deinem Fall cout) sieht jedoch, dass er einen int* ausgeben soll.
(Achtung Metaphern, nicht instant-flamen, bitt ;))
Der Stream schaut nach, wie er einen int* ausgeben soll. Der hat gespeichert: gebe einen int* als hexadezimale Zahl aus, die die Adresse angibt.
Bei char* schaut der ebenfalls nach und sieht: Ein char* ist eine Zeichenkette. Sie geht von der Startadresse bis zu '\0'. Interpretiere den Speicherbereich von char* bis zur ersten '\0' als char und gebe alles aus.
Aber für den Compiler werden beide gleich behandelt.

Edit:
Hättest du die Streams geschrieben, hättest du sagen können:
Wenn du einen int* siehst, gebe den Wert aus, auf den int* zeigt.

idrake schrieb:

Wenn der Compiler bei "(char*) ptrx" alles an dieser Adresse (ptrx) als char behandelt, warum behandelt er dann nicht bei "(int*) ptrx" alles an dieser adresse als int ?

Er tut es.
Für den Compiler sind die nachfolgenden sizeof(char) Bytes an Adresse ptrx Bestandteile eines chars. Wenn man auf den Wert zugrefit werden die sizeof(char) * CHAR_BIT Bits als char interpretiert.
Das Gleiche gilt für int. Die nachfolgenden sizeof(int) * CHAR_BIT Bits werden als int interpretiert.

Super beschrieben !

Der Stream (in deinem Fall cout) sieht jedoch, dass er einen int* ausgeben soll.
(Achtung Metaphern, nicht instant-flamen, bitt ;))
Der Stream schaut nach, wie er einen int* ausgeben soll. Der hat gespeichert: gebe einen int* als hexadezimale Zahl aus, die die Adresse angibt.
Bei char* schaut der ebenfalls nach und sieht: Ein char* ist eine Zeichenkette. Sie geht von der Startadresse bis zu '\0'. Interpretiere den Speicherbereich von char* bis zur ersten '\0' als char und gebe alles aus.
Aber für den Compiler werden beide gleich behandelt.

Edit:
Hättest du die Streams geschrieben, hättest du sagen können:
Wenn du einen int* siehst, gebe den Wert aus, auf den int* zeigt.

Also ist das so richtig:

(char*) ptrx 
--> Compiler erzeugt bestimmten Binaercode Y anhand des Interpretationsalgorithmus gehoerend zu: Gehe zu Adresse ptrx, interpretiere als char 
--> dieser Binaercode Y wird dann an std::cout uebergeben
--> std::cout sieht nach wie es Datentypen char* ausgeben soll und interpretiert dann Binaercode Y anhand der Interpretationsalgorithmen fuer "char*"

ostream& operator<<(ostream& o, const char* p)
{
    // Gib alle Zeichen aus bis ein Nullbyte kommt.
    while(*p)
        o.put(*(p++));
    return o;
}

ostream& operator<<(ostream& o, const void* p)
{
    // Betrachte den Zeiger als int und gebe den Zahlenwert (=die Speicheraddresse) aus.
    return o << (uintptr_t)p;
}

Schreibst du jetzt zb

int* foo;
cout << foo;

Sucht der Compiler einen passenden Operator. Und das ist eben #2, da er int* nach void* konvertieren kann, hingegen nicht int* in char*.

Der erste Operator existiert nur, damit du Stringliterale bequem ausgeben kannst:

cout << "Hallo Welt !";

Ruft #1 auf, da es die Funktion ist, die am Besten passt.

ostream& operator<<(ostream& o, const void* p)
{[b]
    // Betrachte den Zeiger als int und gebe den Zahlenwert (=die Speicheraddresse) aus.[/b]
    return o << (uintptr_t)p;
}

Aber wenn er den Zeiger als int betrachtet, warum wird es dann in Hexadezimal ausgegeben und nicht in Dezimal wie es cout bei int fuer gewoehnlich tut ?

Ich denke jetzt hab ich es endlich halbwegs durchschaut.

Noch kurz zur Ueberpruefung, ob ich es wirklich richtig verstanden habe:

idrake schrieb:

Also ist das so richtig:

(char*) ptrx 
--> Compiler erzeugt bestimmten Binaercode Y anhand des Interpretationsalgorithmus gehoerend zu: Gehe zu Adresse ptrx, interpretiere als char 
--> dieser Binaercode Y wird dann an std::cout uebergeben
--> std::cout sieht nach wie es Datentypen char* ausgeben soll und interpretiert dann Binaercode Y anhand der Interpretationsalgorithmen fuer "char*"

Ethon schrieb:

ostream& operator<<(ostream& o, const void* p)
{[b]
    // Betrachte den Zeiger als int und gebe den Zahlenwert (=die Speicheraddresse) aus.[/b]
    return o << (uintptr_t)p;
}

Aber wenn er den Zeiger als int betrachtet, warum wird es dann in Hexadezimal ausgegeben und nicht in Dezimal wie es cout bei int fuer gewoehnlich tut ?

Weil ich zu faul war eine korrekte Implementierung zu tippen.
Der Operator enthält natürlich noch Magie, um den Stream auf hex zu stellen und danach auf das, was er davor war.