Verständnis problem bei Pointer auf ein Pointer

[Johannes H. (Gast)]

Hallo liebe Forenbesucher,

wie im Betreff schon erwähnt habe ich da ein kleines Verständnis problem 
was POinter auf Pointer betrifft. Ich erkläre es mit einem Beispiel.

void test (int * abc){

   *abc+ = 1;
   return 0;
}


int main(){

   int a = 0;
   int * ptest = NULL;
   ptest =  &a;

   test(&ptest)  //Da ist mein Verständnisproblem
}

Das Beispiel ist ziemlich vereinfacht nur ich verstehe jetzt nicht wie 
ich ein POinter einem Argumentweiter gebe, welcher wiederrum ein POinter 
ist.

Gehört bei der übergabe das kaufmänische UND & dazu oder nicht, weil 
wenn ich es so übergebe bekomme ich die WArrnnung: expected 'int *' but 
argument is of type 'int **'.

Ich hoffe ihr könnt mir da weiterhelfen.

Lg Johannes

[Narf (Gast)]

Zunächst einmal ist ptest vom Typ int*. Verwendet man ein & als 
Operator, liefert dieses die Speicheradresse zurück, an dem die Variable 
die gespeichert wird (bei int ist der Typ für diese Speicheradresse 
int*). Beispiel:
a ist vom Typ int. &a liefert einen Pointer auf int also int* (dieser 
Typ speichert die Adresse, an dem ein int steht).
Das ganze musst du jetzt nur logisch fortführen: ptest ist vom Typ int*. 
D.h. &ptest liefert einen Pointer auf int* als int** (dieser Typ 
speichert die Adresse an dem ein Pointer steht, welcher die Adresse 
eines int speichert).

Für dein Beispiel bedeutet dass:

void test (int** abc){

   **abc+ = 1; //zweimal dereferenzieren, weil du a verändern willst, nicht den Pointer inkrementieren
   return 0;
}


int main(){

   int a = 0;
   int * ptest = NULL;
   ptest =  &a;

   test(&ptest)  //Da ist mein Verständnisproblem
}

[Johannes H. (Gast)]

Passt vielen dank so habe ich es mir eh auch gedacht aber was passiert 
jetzt, wenn ich in der test - Funktion z.B eine String funktion von 
string.h aufrufe, die als parameter ebenso einen Pointer erwartet:

void test (char * x){

      strcpy (?x?, "defg");  //WAs gehört da jetzt her
}


int main(){

   char buf [] = "abcd"

   test(buf);
}
[c]


Ich weiß jetzt nicht was ich da in den Fragezeichen setzen soll, weil wenn ich das so ausführe bekomme ich genau dieselbe Warnug nur diesmal mit char expected 'char *' but argument is of type 'char **'. 

Das Problem ist ja, dass strcpy als Prototyp so definier ist:

[c] char *strcpy(char *dest, const char *src)

.

Würde mir es gehen wenn es so definiert wäre:

char *strcpy(char *dest, const char **src)

und die  Übergabe an die Funktion müsste ich wahrscheinlich so machen

strcpy (&x, "defg");

 oder?

Da das nicht möglich ist, hoffe ich dass ihr mir da vielleicht 
weiterhelfen könnt, wie ich das lösen könnte oder ist das nicht lösbar?

Lg

[Carl D. (jcw2)]

Johannes H. schrieb:
> Passt vielen dank so habe ich es mir eh auch gedacht

Schau dir die erste Antwort besser noch mal an, denn

> aber was passiert jetzt, wenn ich in der test - Funktion z.B eine
> String funktion von string.h aufrufe, die als parameter ebenso
> einen Pointer erwartet:
>
>
>

> void test (char * x){
> 
>       strcpy (?x?, "defg");  //WAs gehört da jetzt her
> }
> 
> 
> int main(){
> 
>    char buf [] = "abcd"
> 
>    test(buf);
> }
> [c]
> 
.
> Ich weiß jetzt nicht was ich da in den Fragezeichen setzen soll, weil 
> wenn ich das so ausführe bekomme ich genau dieselbe Warnug nur diesmal 
> mit char expected 'char *' but argument is of type 'char **'.
> 
> Das Problem ist ja, dass strcpy als Prototyp so definier ist:
> 
> [c] char *strcpy(char *dest, const char *src)

.
>
> Würde mir es gehen wenn es so definiert wäre:
>
>

char *strcpy(char *dest, const char **src)

>
> und die  Übergabe an die Funktion müsste ich wahrscheinlich so machen
>

strcpy (&x, "defg");

 oder?


es sieht nicht so aus, als ob das schon sitzt. Zumindest der Transfer zu 
Strings, die durch einen Zeiger auf ihr erstes Zeichen repräsentiert 
werden (sowie ein '\0'-Zeichen am Ende, was bei String-Literalen 
implizit immer dabei ist)

[Sebastian V. (sebi_s)]

In deinen Beispielen ist es überhaupt gar nicht nötig Pointer auf 
Pointer zu nutzen. Das macht man nur wenn die Funktion den Wert des 
Pointers verändern soll (also wohin er zeigt) oder man Arrays von 
Pointern hat. Die Daten wohin der Pointer zeigt lassen sich auch so 
verändern. Bezogen auf dein String Beispiel würde man den Code so 
schreiben:

void test (char * x){
      strcpy (x, "defg");
}

int main(){
   char buf [] = "abcd"
   test(buf);
}

[Peter D. (peda)]

Sebastian V. schrieb:
> In deinen Beispielen ist es überhaupt gar nicht nötig Pointer auf
> Pointer zu nutzen.

Stimmt, um den Inhalt der Variable zu ändern, reicht ein einfacher 
Pointer.
Auch wenn man den Pointer selber ändert, ist das oftmals nicht nötig. 
Man gibt einfach den neuen Pointer zurück, wie es z.B. in der <string.h> 
sehr gerne gemacht wird.

[Mampf unterwegs (Gast)]

Mit pointerpointern hat man in der Regel wenig bis garnichts zu tun ... 
Wenn du sowas hast, ist die Chamce groß, dass du einen Denkrehler hast.

Ausnahmen sind 2-Dimensionale Arrays, da geht es quasi nicht anders :)

[Johannes H. (Gast)]

Zunächst mal vielen dank für die vielen Antworten. Mir ist schon klar, 
dass das Beispiel auch ohne einem Pointer geht, ich wollte eigentlich 
nur wissen wie man sowas löst weil es ist nicht so, dass sowas selten 
vorkommt...

Also gibt es dafür keine Lösung?

[Mampf F. (mampf)]

Johannes H. schrieb:
> Also gibt es dafür keine Lösung?

Stand doch da:

Beitrag "Re: Verständnis problem bei Pointer auf ein Pointer"


Oder meinst du etwas anderes?

[Dirk B. (dirkb2)]

Johannes H. schrieb:

> void test (int * abc){
> 
>    *abc+ = 1;
>    return 0;
> }
> 
> int main(){
> 
>    int a = 0;
>    int * ptest = NULL;
>    ptest =  &a;
> 
>    test(&ptest)  //Da ist mein Verständnisproblem
> }

ptest ist vom Typ int*

test erwartet einen Paramter vom Typ int*

Es sind dieselben Typen, also muss da gar nichts gemacht werden.

    test(ptest)  // kein Adressoperator

[Johannes H. (Gast)]

Ich habs endlich verstanden :)

Also solchen Funktionen wie strcpy kann ich einfache POinter, wie im 
obigen Beispiel angegeben, zuweisen, aber sobald ich einen Pointer auf 
POinter zuweise (sprich **pTtest) bekomme ich die WArnnung:

char expected 'char *' but argument is of type 'char **['/c]

ist ja klar jetzt habe ich ein **ptest und die FUnktion erwartet sich aber nur ein *ptest. 

Jetzt nur noch zum Verstehen: 

[c]

int main (){

char Buf[10];

char *pTest = Buf;

char *pTest1 = pTest;      //ab hier zeigen beide POinter auf das erste Element von Buf oder?

[Dirk B. (dirkb2)]

Johannes H. schrieb:
> //ab hier zeigen beide POinter auf das erste Element von Buf oder?

Ja.

[Mampf F. (mampf)]

Johannes H. schrieb:
> ist ja klar jetzt habe ich ein **ptest und die FUnktion erwartet sich
> aber nur ein *ptest.

Jau genau ... Deshalb meinte ich vorher, mit ** wird man so gut wie nie 
arbeiten müssen.

Außer es sind 2D-Arrays, aber da würde man dann eher sowas machen:

void foo(char myarray[64][])

dann kann man innerhalb foo auch mit myarray[y][x] arbeiten.

Im Grunde ist aber char myarray[64][] nichts anderes wie ein char**

[Dirk B. (dirkb2)]

Mampf F. schrieb:
> Im Grunde ist aber char myarray[64][] nichts anderes wie ein char**

Doch, ist es.

Und bei Arrays kann man beim ersten Index die Größe weglassen, nicht 
beim letzten.

[Mampf F. (mampf)]

> Und bei Arrays kann man beim ersten Index die Größe weglassen, nicht
> beim letzten.

Ups ja stimmt, sorry^^