problem mit zeigern

also ich hab jetzt schon fast alles in sachen c++ grundlagen durch, bis auf zeiger!
ich versteh nicht so ganz warum sie überhaupt existieren! aber egal

#include <iostream.h>
void main()
{
   int a=5;// int a ist 5
   cout<<a<<endl;// Ausgabe: 5
   int *pa=&a;// int Zeiger pa ist Adresse von a
   *pa=6;// Inhalt von pa ist 6
   cout<<a<<endl;// Ausgabe: 6
   a=7;// a ist 7
   cout<<*pa<<endl;// Ausgabe: 7
   int b=8;// int b ist 8
   int *pb=pa;// int Zeiger pb ist pa, pb zeigt jetzt auch auf a
   cout<<*pb<<endl;// Ausgabe: 7
   int **ppa=&pa;// int Zeiger Zeiger ppa=Adresse von pa;
   cout<<**ppa<<endl;// Ausgabe: 7
   ppa=&pb;// Inhalt von ppa ist Adresse von pb;
   cout<<**ppa<<endl;// Ausgabe: 7
   pb=&b;// pb ist Adresse von b
   cout<<**ppa<<endl;// Ausgabe: 8
};

Meine frage ist was es mit diese zeiger-zeigern auf sich hat, kann das vielleicht jemand möglichst einfach erklären

mfg schonmal!!!

FireFlow

Steht doch alles da, was willst du noch wissen?
Ein Zieger auf einen Zeiger ist relativ einfach wenn man mal das Prinzip versteht. Stell dir mal den Speicher als eine Art Tabelle vor mit den Spalten Adresse und Inhalt (die Adressen hab ich willkürlich gewählt):

#####################################
# Adresse         #  Inhalt         #
#####################################
# 0x0AB0          #  123            #  ==> int a = 123;
#####################################
# 0x0AB4          #  0x0AB0         #  ==> int *p = &a;
#####################################
# 0x0aB8          #  0x0AB4         #  ==> int **pp = &p;
#####################################

Mit dem Adressoperator & bekommst du nicht den Inhalt sondern die Adresse. Mit dem Dereferenzierungsoperator * bekommst du den Inhalt des Speicherblocks mit der Adresse des Inhalts des Pointers... *lol* hört sich lustig an...

Bei einem Doppelpointer musst du eben zwei mal dereferenzieren dass du zur eigentlichen Variable kommst.

danke erstmal,
also wenn ich die adresse eines zeigers einem anderen zuweisen will muss dieser ein doppelzeiger sein?!

Caipi

frage_mann schrieb:

danke erstmal,
also wenn ich die adresse eines zeigers einem anderen zuweisen will muss dieser ein doppelzeiger sein?!

jup.

Und wenn du die Adresse eines Doppelzeigers einem anderen zuweisen willst, so muss dieser ein Dreifach-Zeiger sein... usw.

int x = 9;
int* px = &x;
int** ppx = &px;

// Dreimal die gleiche Adresse:
cout << "\n Adresse von x: " << *ppx << " oder: " << px << " oder: " << &x;

// Dreimal der gleiche Wert:
cout << "\n Wert von x: " << **ppx << " oder: " << *px << " oder: " << x;

Caipi

groovemaster

frage_mann schrieb:

also ich hab jetzt schon fast alles in sachen c++ grundlagen durch

Wäre vielleicht besser, wenn du dir ein aktuelles Tutorial oder Buch zulegst. Dein Programm weist typische Anfängerfehler auf.

ich hab mir das teil zur veranschaulichung nur schnell aus dem alten volkard tut kopiert.
aber was ist denn an den paar deklarationen falsch
eigentlich das doch noch gar nichts!?

shapeless

void main // int main
iostream.h // <iostream>

zB,..
aber dazu gibt unzählige beiträge hier

achso, jah.. hab nicht drauf geachtet. sowas mach ich auch nicht.
eine funktion sollte ja schließlich IMMEr etwas zurück lifern.
ich glaub, das machen aber trotzdem alle borlander...

FireFlow

frage_mann schrieb:

achso, jah.. hab nicht drauf geachtet. sowas mach ich auch nicht.
eine funktion sollte ja schließlich IMMEr etwas zurück lifern.
ich glaub, das machen aber trotzdem alle borlander...

Was redest du da? Es gibt viele Funktionen die nichts zurückgeben sollen. Auch die main-Funktion muss nichts explicit zurückgeben. Wenn du kein return statement in der main()-Funktion hast gibt deine Anwendung trotzdem 0 zurück. Nach dem c++ Standard gibts nur int main() und int main(int argc, char* argv[])

frage_mann schrieb:

eine funktion sollte ja schließlich IMMEr etwas zurück lifern.

nö, es gibt auch void funktionen.

audacia

frage_mann schrieb:

ich glaub, das machen aber trotzdem alle borlander...

Mit Sicherheit nicht. Das ist ein Relikt aus der Prä-Standardisierungs-Zeit und nicht bei Borland-Usern, sondern generell bei Anfängern, die mit veralteter Lektüre gelernt haben, üblich.

Moritz

a)ich hatte von der main-fkt. geredet! ... und dass die nicht unbedingt was zurückgeben muss, sehen wir am veralteten bsp.

b)"es gibt auch void..."
jah genau! dass stand auch im beispiel; aus diesem grund hatte ich den letzten beitrag geschrieben.
soweit waren wir schon. (SARKASMUS: ende) :p

mal ehrlich, ich hab einen nachrichtentechniker als freund und der muss sich auch mit borland "herumärgern", ich dachte nur das es borland bis heute nicht verändert hatte "sich nicht an den standart zu halten" da er namespaces, usw. in den sourcen völlig ignorierte, und reden wir erst gar nicht von den libs...
ich pers. benutze meist gcc und der gibt glaube ne warnung?!

Es gibt viele Funktionen die nichts zurückgeben sollen. Auch die main-Funktion muss nichts explicit zurückgeben. Wenn du kein return statement in der main()-Funktion hast gibt deine Anwendung trotzdem 0 zurück.

das sieht ja fast wie ein paradoxum aus.
nur void liefert nischt zurück da s theoretisch ein unbest. datentyp ist! ich hab das mal mit zeigern probiert:
//nur pseudo!!!
void * zeiger = (int) ...........