Wieso Zeiger Variable wenn auch int i = &var;

[Kraus (Gast)]

Wieso brauche ich eigentlich eigene zeigervariablen wenn ich die Adresse 
auch in einer normalen Variablen speichern kann und ausgaben kann?
Somit würde sich der Aufruf von Unterprogrammen genauso gut verbessern 
lassen?

[Peter II (Gast)]

Kraus schrieb:
> Wieso brauche ich eigentlich eigene zeigervariablen wenn ich die Adresse
> auch in einer normalen Variablen speichern kann und ausgaben kann?

weil bei 64bit ein zeiger nicht mehr in ein int passt.

[NurEinGast (Gast)]

Weil Du mit dem Zeiger noch was machen willst.

Ein Zeiger "zeigt" auf irgendeine Speicherstelle, mit der Du später 
irgendwas machen willst (schreiben/lesen) .

int i = &var;

Wenn Du nun in Deiner Variable i die Addresse von "var" stehen hättest, 
wie würdest Du dann auf den Inhalt der Variabel "var" zugreiben ?

[Kraus (Gast)]

NurEinGast schrieb:
> Wenn Du nun in Deiner Variable i die Addresse von "var" stehen hättest,
> wie würdest Du dann auf den Inhalt der Variabel "var" zugreiben ?

Stimmt auch wieder, danke!

[Fabian O. (xfr)]

NurEinGast schrieb:
> Wenn Du nun in Deiner Variable i die Addresse von "var" stehen hättest,
> wie würdest Du dann auf den Inhalt der Variabel "var" zugreiben ?

Das würde prinzipiell schon gehen:

int var = 42;
int i = &var;
int x = *((int*) i);
printf("%i", x);

Allerdings warnt der Compiler davor zu Recht. Denn wenn man einen Zeiger 
in eine int-Variable speichert (vorausgesetzt, er passt überhaupt rein), 
geht für den Compiler die Information verloren, auf was für einen 
Datentyp der Zeiger zeigt. Also ob es ein int*, char*, oder vielleicht 
mein_struct_t* ist.

Bevor man den Wert in i dereferenziert, muss man ihn deshalb erst wieder 
in einen Zeiger mit dem richtigen Typ umwandeln. Sonst weiß der Compiler 
nicht, wie viele Bytes er von der Adresse lesen/schreiben soll. Bei 
einem char* wär es nur ein Byte, bei einem int dagegen zwei oder vier 
Bytes.

Wenn man dabei einen Fehler macht und den Integer in den falschen 
Zeiger-Typ umwandelt, kann alles mögliche passieren. Wenn man einen 
Zeiger speichert, nimmt man deshalb gleich eine Zeigervariable. Erstens 
ist dann sicher, dass da auch ein Zeiger reinpasst und zweitens weiß der 
Compiler dann automatisch, wie er ihn richtig dereferenziert.

Mal ganz abgesehen davon, dass es auch für den Benutzer einer Funktion 
wesentlich klarer ist, wie er sie zu benutzen hat, wenn sie einen Zeiger 
eines bestimmten Typs erwartet:

puts(char* string, int len)

Hier ist klar: Die Funktion will einen Zeiger auf ein char.

puts(int string, int len);

Hier käme kein Mensch drauf, dass string eigentlich ein char-Pointer 
sein soll ...

Der entstehende Maschinencode wäre letztlich der gleiche (wie gesagt, 
sofern die int-Variable groß genug für einen Zeiger ist). Warum sollte 
man also solche Umwege gehen? Außer Verwirrung und Fehlerquellen bringt 
das nichts.

[Karl H. (kbuchegg)]

Wozu überhaupt Datentypen?
Im Computer ist schliesslich alles nur eine Zahl!

Ob das jetzt Befehle, Zeichen, Integer, Floating-Point Werte oder auch 
irgendwie gespeicherte Adressen sind - letzten Endes sind alles nur 
Bytes mit Binärmustern von 00000000 bis 11111111


Hmmm ......

Könnte es eventuell sein, dass man sich mit der Einführung von 
spezifischen Datentypen einen gewissen Abstraktionslevel schafft, der es 
dem Compiler ermöglicht zumindest rudimentäre Prüfungen durchzuführen, 
damit ich nicht wie wild Äpfel mit Birnen verrechne?