C++ | Zeiger Fragen

Quote:

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

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???)

Quote:

Oder sehe ich alles falsch, zum thema Adresse?

Quote:

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

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.

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 ----------------------

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

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

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

#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 !

Quote:

Originally Posted by Obilee Ja weil du 2x das gleiche Machst... int *Pointer = &Var; int *Pointer2 = Var; hab ich geschrieben

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

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

Quote:

Originally Posted by Aimbot. Code: int Var = 3; int Pointer = Var; int *Pointer2 = &Var; cout << Pointer << endl; cout << Pointer2 << endl; Also so?

Quote:

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

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?

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

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 }

Quote:

Originally Posted by xNopex Du erhälst die Speicheradresse, an der der Wert 5 gespeichert ist.

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

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?