Pointer auf Pointer Adresse anzeigen?

[asdrubael]

Hab mal ein Stück Beispielcode aus dem Forum hier genommen:

//2. Beispiel:
#include <iostream>
using namespace std;

int main ()
{
   int x = 10, y = 20; //Zwei neue ints auf dem Stack erzeugen
   int * zeiger; //Erklärung: siehe oben
   int * * doppel_zeiger;//Erzeuge einen Zeiger, der nur auf Zeiger zeigen kann,
                         //die auf ints zeigen

   zeiger = &x; //zeiger zeigt auf x
   doppel_zeiger = &zeiger; //doppel_zeiger zeigt auf zeiger

   (*doppel_zeiger) = &y; //lässt den zeiger, auf den doppelzeiger zeigt, auf y zeigen

   cout << *zeiger << endl; //beweis: zeiger zeigt auf y

   cout << **doppel_zeiger << endl; //Doppelte Zeiger müssen auch doppelt
                                    //dereferenziert werden, um den richtigen
                                    //wert zu erhalten

}

Nun würde mich interessieren wie ich über den doppel_zeiger auf die Speicheradresse von y komme. Also nicht den Wert 20, sondern die Adresse wo die Variable gespeichert ist. Hintergrund ist das ich eine Funktion habe (extern) die mir nur einen Zeiger auf einen Zeiger zurückliefert. Ich benötige aber die Speicheradresse wo der zweite Pointer hinzeigt.

cout << &y << endl;
cout << zeiger << endl;
cout << doppel_zeiger << endl; // liefert nur Adresse auf zeiger nicht auf y

PS: Die Suche geht grad nicht

[eXitus]

[cpp]//2. Beispiel:
#include <iostream>
using namespace std;

int main ()
{
int x = 10, y = 20; //Zwei neue ints auf dem Stack erzeugen
int * zeiger; //Erklärung: siehe oben
int * * doppel_zeiger;//Erzeuge einen Zeiger, der nur auf Zeiger zeigen kann,
//die auf ints zeigen

zeiger = &x; //zeiger zeigt auf x
doppel_zeiger = &zeiger; //doppel_zeiger zeigt auf zeiger

(*doppel_zeiger) = &y; //lässt den zeiger, auf den doppelzeiger zeigt, auf y zeigen

cout << *zeiger << endl; //beweis: zeiger zeigt auf y

cout << **doppel_zeiger << endl; //Doppelte Zeiger müssen auch doppelt
//dereferenziert werden, um den richtigen
//wert zu erhalten

**cout << &(doppel_zeiger) << endl; //...
} [/cpp]

*edit: Gruß eXitus :edit*

[asdrubael]

Supi danke

[eXitus]

bitte, bitte, bin aber selbst noch Anfänger, zwar nicht so blutig, aber trotzdem...
Gruß eXitus

[Phoemuex]

So wie exitus es sagt, geht es zwar, ist aber doppelt gemoppelt. Man kann nämlich einfach den

doppel_zeiger

dereferenzieren, also

*doppel_zeiger;

Das liefert nämlich natürlich auch die Adresse von y zurück.

Felix

[eXitus]

Stimmt, wusste das gar net, dachte es geht nur über
&(**var);
Aber gut, dass man das weis, thX
Gruß eXitus

[asdrubael]

Dann frag ich gleich nochwas ^^ Was erwartet eine Funktion ala

GetMem (void** pMem)

Die Adresse auf einen Doppel-Pointer? Heißt das ich muss noch einen dritten Pointer machen der auf den doppelten zeigt?

Das mag sich alles sehr blöd anhören, aber ich hab hier nur ein Datenblatt ohne SDK und steh grad voll aufm Schlauch was das Teil überhaupt von mir will und was es damit anstellen könnte.

[eXitus]

Weis net sicher, aber ich glaub einen doppelpointer, nicht einen pointer auf einen doppelpointer...

int funktion(int *blalba);

braucht ja auch einen Pointer und keinen Pointer auf einen Pointer (,also keinen doppelpointer..)

Gruß eXitus :xmas1:

*edit: Rechtschreibfehler entfernt :edit*

[groovemaster]

asdrubael schrieb:

Dann frag ich gleich nochwas ^^ Was erwartet eine Funktion ala

GetMem (void** pMem)

Die Adresse auf einen Doppel-Pointer? Heißt das ich muss noch einen dritten Pointer machen der auf den doppelten zeigt?

Sowas wird meist in C APIs vewendet, um innerhalb der Funktion einen übergebenen Zeiger zu ändern. Da es in C++ Referenzen gibt, wirst du sowas hier relativ selten antreffen. ZB gibt es sowas in DirectX.
Letztendlich reicht für sowas ein ganz normaler Zeiger

void* p; // zeigt jetzt "irgendwo" hin (also undefiniert)
GetMem(&p); // 'p' wird in der Funktion ein gueltiger Wert zugewiesen (ab jetzt also definiert)

edit:
wenn die xmas Smileys schon da sind, muss ich die auch einfach mal verwenden
:xmas1: :xmas2:

[asdrubael]

Jo in C werden viele mir suspekte Sachen gemacht

Soll das bewirken, das ich nicht direkt auf den Speicherbereich von weißnichwas zugreifen kann, sondern nur auf den Wert? Kann eigentlich nicht sein, weil oben steht ja das es trotzdem geht.

[SirLant]

Das hat in C andere Gründe, aber in C++ reicht es einfach einen einfachen Zeiger mit einem (void**) für die Übergabe zu casten, wenn man mal mit ner C API arbeitet.

[groovemaster]

asdrubael schrieb:

Soll das bewirken, das ich nicht direkt auf den Speicherbereich von weißnichwas zugreifen kann, sondern nur auf den Wert? Kann eigentlich nicht sein, weil oben steht ja das es trotzdem geht.

Wie du schon sagst, du kannst dank Indirektion trotzdem auf den Speicher zugreifen.
Wie ich bereits sagte, macht man sowas hauptsächlich in C um den Wert (Adresse) eines Zeigers zu ändern. Nehmen wir mal folgendes Beispiel

void GetMem(void* p)
{
    p = foo;
}
//...
    void* a = bar; // a enthaelt nun den Wert von bar
    GetMem(a); // a enthaelt jetzt immer noch den Wert von bar
               // warum? nun, auch Zeiger werden by-value uebergeben
               // dh, dass GetMem eine lokale Kopie von a bekommt, der foo zugewiesen wird
               // beim Beenden von GetMem wird diese lokale Kopie zerstoert, ohne dass dies den urspruenglichen Zeiger (a) beeinflusst
//...

und vergleichen das hiermit

void GetMem(void** p)
{
    *p = foo;
}
//...
    void* a = bar; // a enthaelt nun den Wert von bar
    GetMem(&a); // a enthaelt jetzt den Wert von foo
               // warum? nun, diesmal wird die Adresse von a by-value uebergeben
               // per Indirektion (*p) bekomme ich somit Zugriff auf a (bzw auf den Speicher, der a entspricht)
//...

Schauen wir uns als letztes noch die C++ Version an

void GetMem(void*& p)
{
    p = foo;
}
//...
    void* a = bar; // a enthaelt nun den Wert von bar
    GetMem(a); // a enthaelt jetzt den Wert von foo
               // warum? nun, diesmal wird a by-reference uebergeben
               // dh, ich greife auf den Parameter in GetMem (p) zu, als wenn es a selbst waere
//...

Ich hoffe, dass ich es nicht zu wirr erklärt hab und die ganze Sache jetzt etwas klarer wird.