C++ | Zeiger Fragen

Aimbot. · 06/22/2011, 21:57

Ich hätte da einige Frage.

1: Was ist eine Speicheradresse?
2: Warum ändert sich immer die Adresse, wenn ich mir die Adresse anschauen möchte?

3: Wenn ich jetzt einen Zeiger erstelle

Code:

 int Var; 
int *Pointer = &Var;
cout << Pointer << endl;

von was bekomme ich dann die Speicheradresse? ich müsste doch dann sie Speieradresse von Var bekommen oder? (Also vom Namen bekomme ich die Adresse???)
-----
4: Wenn ich jetzt diesen Zeiger erstelle

Code:

 int Var = 5;
int *Pointer = &Var;
cout << Pointer << endl;

Von was bekomme ich da die Speicheradresse von Var oder von 5 ? Also: Bekomme ich (vom Namen die Adresse?) oder (vom Wert die Adresse?)

Oder sehe ich alles falsch, zum thema Adresse?

Obilee · 06/22/2011, 22:12

Speicheradresse ist halt die Adressierung der Werte die im RAM liegen. Damit du auf sie zugreifen kannst.

* = Pointer & = Referenz

Der Unterschied ist dass der Pointer auf die Adresse zeigt wo die Variable liegt. Die Referenz hingehen bekommt einen Wert bzw. Zeigt auf diesen.

Soweit ich es richtig in Erinnerung hab, ist schon ne Weile her dass ich was mit c++ gemacht hab.

Erstellt doch einfach 2 Pointer, 1x int *Pointer = &Var; und 1x int *Pointer2 = Var; Und lass sie Ausgeben.

xNopex · 06/22/2011, 22:33

Der RAM besteht grob gesagt aus vielen Millionen Bauelementen, die zwei Zustände annehmen können, nämlich an und aus (Bits). Nun ist es so, dass man nach dem Von-Neumann-Prinzip (nach dem die meisten Maschinen bis heute grundlegend funktionieren) nicht einzelne Bits anspricht, sondern Speicherzellen, die aus einer festgelegten Anzahl von Bits bestehen, z.B. acht (=1Byte). Um diese Speicherzellen nun anzusprechen, ist der Arbeitsspeicher fortlaufend nummeriert. Über die Nummer (Adresse) hat man also Zugriff auf die Speicherzellen des RAM's. Da dieser Zugriff willkürlich erfolgen kann, heißt der RAM auch RAM (=random access memory).
Das grob zu den Speicheradressen.

Quote:

2: Warum ändert sich immer die Adresse, wenn ich mir die Adresse anschauen möchte?

Das tut sie nicht.

Quote:

von was bekomme ich dann die Speicheradresse? ich müsste doch dann sie Speieradresse von Var bekommen oder? (Also vom Namen bekomme ich die Adresse???)

Nein. Der 'Name' existiert nicht mehr nachdem du den Quellcode kompiliert hast. Der Wert deiner Variable liegt irgendwo im Arbeitsspeicher und beansprucht wahrscheinlich 4Bytes, also 4Speicherzellen. Das kompilierte Programm arbeitet nichtmehr mit deinen Variablen, sondern nur noch mit dieser Speicheradresse. Es gibt also nur eine, nicht zwei getrennt für die Variable und der ihr zugeordneter Wert.

Quote:

Oder sehe ich alles falsch, zum thema Adresse?

Ja, das stimmt.

Aimbot. · 06/23/2011, 11:12

Quote:

Originally Posted by Obilee

Erstellt doch einfach 2 Pointer, 1x int *Pointer = &Var; und 1x int *Pointer2 = Var; Und lass sie Ausgeben.

Da bekomme ich die gleiche Adresse:

Code:

int Var;

 int *Pointer = &Var; 
 int *Pointer2 = &Var;

 cout << Pointer << endl;
 cout << Pointer2 << endl;

Die Adresse : 0029FA18
Die Adresse : 0029FA18

----------------------

Quote:

Originally Posted by xNopex

Nein. Der 'Name' existiert nicht mehr nachdem du den Quellcode kompiliert hast. Der Wert deiner Variable liegt irgendwo im Arbeitsspeicher und beansprucht wahrscheinlich 4Bytes, also 4Speicherzellen. Das kompilierte Programm arbeitet nichtmehr mit deinen Variablen, sondern nur noch mit dieser Speicheradresse. Es gibt also nur eine, nicht zwei getrennt für die Variable und der ihr zugeordneter Wert.

Aber wenn ich die Variable ( int Var; ) deklariert habe, und keinen wert gebe.
- Und du sagst der Name existiert nicht mehr, von was bekomme ich dann die Adresse?

Obilee · 06/23/2011, 11:24

Ja weil du 2x das gleiche Machst...
int *Pointer = &Var;
int *Pointer2 = Var;

hab ich geschrieben

black0utCpp · 06/23/2011, 11:30

Quote:
Originally Posted by Aimbot.
Da bekomme ich die gleiche Adresse:
Code:
int Var;

 int *Pointer = &Var; 
 int *Pointer2 = &Var;

 cout << Pointer << endl;
 cout << Pointer2 << endl;

Die Adresse : 0029FA18
Die Adresse : 0029FA18
----------------------

Ist ja irgendwie auch logisch , da beide Zeiger auf den selben Bereich (oder die selbe Speicheradresse) zeigen. Wenn du jetzt das machst:

Code:

int var =3;
int *iptr1;
int *iptr2;

//Adresse übergeben
iptr1=&var;
iptr2=&var;

std::cout<<*iptr1<<"-"<<*iptr2<<"\n";// gibt den Wert aus

Du könntest auch andere interessante Sachen probieren wie :

Code:

#include <iostream>

using namespace std;



int main(void)
{

int x=1;
int y=2;
int z=3;

int *xptr,*yptr,*zptr;

//Den Pointern über den & Operator die Adresse im Speicher übermitteln
xptr=&x;
yptr=&y;
zptr=&z;

//one two und three wird indirekt über x y z ein Wert zugewießen
int one,two,three;

//Übergebe mit dem Asterix * Operator den Wert der Adressen
one=*xptr;
two=*yptr;
three=*zptr;

cout<<"X:"<<x<<"One:"<<one<<"\n";//etc..

//Noch etwas zur Gleichheit von Variablen und Pointern

int a=0;
int *aptr;

//Gleiche Adresse
aptr=&a;

cout<<"Adresse von a"<<&a<<"\n";
cout<<"Adresse von ptra"<<aptr<<"\n";

//Gleicher Wert
cout<<"Wert von a "<<a<<"\n";
cout<<"Wert von aptr"<<*aptr<<"\n";




return 0;
}

//Aber auch bei Klassen zb nehmen wir an wir hätten ein Objekt der Klasse Mensch 
Mensch Adam;
Mensch *Adamptr;

Adamptr=&Adam;
//Jetzt können wir über den Pointer indirekt auf Funktionen der Klasse zugreifen mit dem //"->" Operator

//Indirekter Funktionsaufruf ! 
Adamptr->reden();

//Außerdem kannst du über new noch zur Laufzeit speicher im Heap reservieren über new du brauchst aber einen Pointer darauf
//also

int *iptr=new(int);
if(*iptr==0)
{
std::cerr<<"Fehler bei der Speicherreservierung";
}
else
{
//Hier mit dem freien speicher hantieren
//am ende mit delete wieder freigeben
delete(iptr);
}
//Nur zur Demonstration der verschiedenen sehr nützlichen Aktionen , die du mit Zeigern machen kannst !

Aimbot. · 06/23/2011, 11:42

Quote:

Originally Posted by Obilee

Ja weil du 2x das gleiche Machst...
int *Pointer = &Var;
int *Pointer2 = Var;

hab ich geschrieben

Code:

 int Var = 3;
 
 int Pointer = Var;
 int *Pointer2 = &Var; 

 cout << Pointer << endl;
 cout << Pointer2 << endl;

Also so?

black0utCpp · 06/23/2011, 11:53

Quote:

Originally Posted by Aimbot.

Code:

 int Var = 3;
 
 int Pointer = Var;
 int *Pointer2 = &Var; 

 cout << Pointer << endl;
 cout << Pointer2 << endl;

Also so?

bei Pointer fehlt ein * du deklarierst lediglich einen normalen integer !
Außerdem motzt bei mir der Compiler wenn ich schreibe :
int x;
int *iptr=x; //Compiler möchte ,das ich x zu einem Pointer caste ?

Aimbot. · 06/23/2011, 12:11

Andere Frage also wenn ich z.B

Quote:

int Var;
cout << "Bitte gebe eine Zahl ein : ";
cin >> Var;
cout << Var << endl;
cout << &Var << endl;

und gebe bei cin >> Var die Zahl 5 ein, dann bekomme ich von 5 die Speicheradresse oder???
So würde ich mir das vorstellen, dass es so funktioniert oder doch nicht?

xNopex · 06/23/2011, 14:26

Quote:

und gebe bei cin >> Var die Zahl 5 ein, dann bekomme ich von 5 die Speicheradresse oder???
So würde ich mir das vorstellen, dass es so funktioniert oder doch nicht?

Du erhälst die Speicheradresse, an der der Wert 5 gespeichert ist:
RAM (Man verzeihe mir evtl. den falschen Endian):

Code:

0x....
0x00A00000: 0x00
0x00A00001: 0x00
0x00A00002: 0x00
0x00A00003: 0x05
0x....

Du würdest nun die Adresse 0x00A00000 erhalten. Hier ist dein Wert (5) gespeichert.

.BritainAndy · 06/23/2011, 15:04

schau dir das mal an, hier wirds mit Töpfen erklärt was dich evtl. ein wenig besser in die materie einführt.

Hier hab ich auf meinem PC als ich Zeiger gelernt habe eine kleine Zusammenfassung des Themas gefunden, vll hilft sie dir (ist aus mehrern Quellen zusammen kopiert):

Quote:

Zusammenfassung
Zeiger bieten eine leistungsfähige Möglichkeit für den indirekten Zugriff auf Daten.
Jede Variable hat eine Adresse, die sich über den Adressoperator (&) ermitteln
lässt. Die Adresse kann man in einem Zeiger speichern.
Die Deklaration eines Zeigers besteht aus dem Typ des Objekts, auf das der Zeiger
verweist, gefolgt vom Indirektionsoperator (*) und dem Namen des Zeigers.
Es empfiehlt sich, Zeiger zu initialisieren, so dass sie auf ein Objekt oder NULL (0)
zeigen.
Auf den Wert, der an der in einem Zeiger gespeicherten Adresse abgelegt ist,
greift man mit dem Indirektionsoperator (*) zu. Durch die Deklaration von konstanten
Zeigern lassen sich erneute Zuweisungen des Zeigers auf ein anderes Objekt
verhindern. Zeiger auf konstante Objekte gestatten keine Änderung der Objekte,
auf die sie verweisen.

Mit dem Schlüsselwort new erzeugt man neue Objekte auf dem Heap(Frei zur verfügung
gestellter Speicherbereich vom PC). Die von new
zurückgegebene Adresse legt man in einem Zeiger ab
{
int *pointer = new int
*pointer = 100;
delete pointer;

}.
Durch Aufruf von delete auf
dem Zeiger gibt man den Speicher frei. Der betreffende Zeiger wird dabei aber
nicht zerstört. Aus diesem Grund muss man den Zeiger nach Freigabe des Speichers
erneut zuweisen.

int main()
{
cat yannik;
cat *fritz = &yannik;
cout<< "Alter beträgt" << fritz->getAlter();
//oder
cout << "Alter beträgt" << (*fritz).getAlter();
//ist das selbe
}

Aimbot. · 06/23/2011, 17:20

Quote:

Originally Posted by xNopex

Du erhälst die Speicheradresse, an der der Wert 5 gespeichert ist.

Okay, also jetzt kann ich dir so ein bissel folgen:
1: Also hat der Wert 5 gar keine Adresse, wir bekommen sozusagen einfach nur die Speicheradresse wo der wert gespeichert ist?

Habe ich mir das jetzt richtig eingeprägt oder falsch?

.BritainAndy · 06/23/2011, 18:11

int i = 5;

Du kannst die 5 über zwei "wege" ansprechen .

Einmal, an der Stelle wo sie im RAM gespeichert ist (die adresse, also &i), oder über die variabel i.

Mit pointer kannst du auf den wert (also 5) UND auf die adresse( 00576EB0 <- als beispiel) zugreifen.

Wenn du den wert anzeigen lassen möchtest:

*ptri und die adresse einfach nur ptri.

Secredo · 06/23/2011, 21:21

Das einzige was ich an Pointern nicht verstehe ist, das man auf einen Pointers auch einen Pointer zeigen lassen kann.
Wenn jeder Pointer auch einen Speicherplatz im RAM hat, in dem die Adresse gespeichert wird auf die der eigentliche Pointer zeigt, wäre das ja eine unendlich Schleife oder? oO

Code:

int x = 1234;
int* ptr1;
int** ptr2;
int*** ptr3;

ptr1 = &x;
ptr2 = &ptr1;
ptr3 = &ptr2;

xNopex · 06/23/2011, 21:48

Quote:

Das einzige was ich an Pointern nicht verstehe ist, das man auf einen Pointers auch einen Pointer zeigen lassen kann.
Wenn jeder Pointer auch einen Speicherplatz im RAM hat, in dem die Adresse gespeichert wird auf die der eigentliche Pointer zeigt, wäre das ja eine unendlich Schleife oder? oO

Nein das ganze ist ein endliches System. Ein Pointer ist letztendlich auch nichts anderes als eine Variable, die ihren Platz im Speicher hat. Als Wert speichert sie speziell die Adresse einer anderen Variable, was nichts anderes ist als ein ganzzahliger 16/32/64bit (je nachdem auf welcher Maschine man sich befindet) unsigned-Wert.

Quote:

Okay, also jetzt kann ich dir so ein bissel folgen:
1: Also hat der Wert 5 gar keine Adresse, wir bekommen sozusagen einfach nur die Speicheradresse wo der wert gespeichert ist?

Habe ich mir das jetzt richtig eingeprägt oder falsch?

Ja, du erhälst die Speicheradresse, an der der Wert 5 gespeichert ist. Der Wert ist dabei bei gleicher Adresse variabel. D.h. du kannst die Adresse jederzeit mit einem anderen Wert überschreiben.