Verwirrt durch die einzelnen Zeiger und Doppel-pointer-Argumente in Funktionsaufrufen

Können Sie pass-argument in unterschiedlicher Weise in C (Captain Obvious, ja).

1. Wert. Dann ist es kopiert zu stapeln. Also die Funktion hat lokale Kopie der variable in der Funktion frame. Änderungen argument nicht ändern übergebenen Wert. Es ist wie "nur Lesen" - Modus

   void fooByValue(myStructure_t arg) {
       printf("passed by value %d %d\n", arg.a, arg.b);
       arg.a = 0;
   }

2. Übergeben, indem Zeiger. Kopieren der Adresse der Variablen übergeben wird (also ja, es ist noch immer durch Wert übergeben, sondern übergeben Sie den Wert der Adresse, nicht der ganze argument). Also das ist wie "Lesen und schreiben" - Modus. Wie Sie kann der Zugriff auf die übergebene variable durch seine-Adresse, Sie kann verändern Sie den Wert für diese variable außerhalb der Funktion.

   void fooByPtr(myStructure_t *arg) {
       printf("passed by pointer %d %d\n", arg->a, arg->b);
       arg->a = 0;
   }

   Aber! Sie kann immer noch nicht ändern Zeiger.

3. Also, wenn Sie ändern möchten Zeiger, dann sollten Sie pass Zeiger auf Zeiger. Das ist wie "Lesen-schreiben ändern" - Modus:

   void fooByDblPtr(myStructure_t **arg) {
       *arg = (myStructure_t*) malloc(sizeof(myStructure_t));
       (*arg)->a = 10;
       (*arg)->b = 20;
   }

   Wenn das war nur Zeiger dann wäre es ja ein memory leak:

   void fooByDblPtr(myStructure_t *arg) {
       arg = (myStructure_t*) malloc(sizeof(myStructure_t));
       (arg)->a = 10;
       (arg)->b = 20;
   }

   weil hier ordnen Sie die neue Adresse der lokalen Kopie der Adresse aus, und dieses argument zerstört werden würde nach der Funktion Abschluss.

   UPD. Zum Beispiel haben wir

   void fooByPtr(myStructure_t *arg) {
       printf("addr inside foo before %p\n", arg);
       arg = (myStructure_t*) malloc(sizeof(myStructure_t));
       (arg)->a = 10;
       (arg)->b = 20;
       printf("addr inside foo after %p\n", arg);
   }
   
   void main() {
       myStructure_t *x = NULL;
       x = malloc(sizeof(myStructure_t));
       x->a = 10;
       x->b = 20;
       printf("x addr before = %p\n", x);
       fooByPtr(x);
       printf("x addr after = %p\n", x);
       free(x);
   }

   innerhalb der Funktion Speicherplatz reserviert und der Zeiger zugeordnet ist, die lokale variable. Anrufer hält immer noch den alten Wert. Nach dem Funktionsaufruf verlieren wir die Adresse von dem Speicher, so kann es nicht veröffentlicht werden.

   Kurzes Fazit: es gibt eine einfache Regel - wenn nötig-zu ändern argument, pass Zeiger darauf. Also, wenn Sie möchten, zu ändern, Zeiger, übergeben Zeiger auf Zeiger. Wenn Sie wollen, Doppel-Wechsel-Zeiger übergeben Zeiger auf Zeiger auf Zeiger.

4. Passing argument von pointer ist auch viel schneller, weil Sie nicht brauchen, um kopieren Sie alle Wert auf dem stack (natürlich, wenn der Wert größer ist als Zeiger auf diesen Wert, ansonsten übergeben, indem Zeiger für die read-only ist sinnlos). Aber es ist gefährlich, weil es könnte geändert werden, innerhalb der Funktion. So können Sie sicher argument definieren Sie mit dem Schlüsselwort const

   void constFoo(const myStructure_t *arg) {
       arg->a = 10;    //compilation error
       arg->b = 20;    //compilation error
   }

   Dies ist wirklich hilfreich, wenn Sie die Arbeit mit 3rd-party-Bibliotheken: Funktion Unterschrift erfahren Sie, ob die Funktion ändern kann, ist dein argument oder nicht. Obwohl const ist optional, ist es angebracht zu schreiben Schlüsselwort const jeder Zeit ist es möglich

5. Array übergeben. In der Regel sendet auch array-Größe (daher, size_t) als argument. Array als Zeiger.

   void foo (int *buf, size_t nbuf) {
       ....
   }

   Manchmal findet man code, in dem Entwickler sendet Zeiger auf Objekt statt array, zum Beispiel

   void foo (int *buf, size_t size) {
       size_t i;
       for (i = 0; i < size; i++) {
           printf("%d ", buf[i]);
       }
   }
   
   int main(int argc, char **argv) {
       int a = 10;
       int buf[1] = { 10 };
       foo(buf, 1);
       foo(&a, 1);
   }

   In diesem Fall array mit einem element und Zeiger-auf-element Verhalten sich ähnlich (obwohl, Sie sind nicht das gleiche).

Fügen Sie eine weitere Funktion:

void modifyMe0(struct myStructure param1)
{
    param1.a = 7;
}

Dieser geht die Struktur durch einen Wert. Die änderung in der Funktion ist, spiegelt sich nicht in dem argument übergeben modifyMe0().

Hinzufügen aufrufende code wie dieser:

printf("Before 0: a = %d, b = %d\n", test1->a, test1->b);

modifyMe0(*test1);

printf("After  0: a = %d, b = %d\n", test1->a, test1->b);

Beachten Sie, dass die vorher-und nachher-Werte im aufrufenden code sind die gleichen. Man könnte auch hinzufügen, drucken auf Ihrem modifyMeN() Funktionen, um zu demonstrieren, dass in Ihnen der Wert geändert wird.

Wenn Sie übergeben einen Zeiger auf die Struktur, die an die aufgerufene Funktion den Wert der Struktur, in der aufrufenden Funktion geändert werden kann. Wenn Sie übergeben Sie die Struktur der aufgerufenen Funktion als Wert, der Wert der Struktur, in der aufrufenden Funktion nicht verändert wird.

Können Sie eine andere Funktion:

void modifyMe3(struct myStructure **p1)
{
    free(*p1);
    *p1 = malloc(sizeof(*p1));
    (*p1)->a = -3;
    (*p1)->b = -6;
}

Hinzufügen aufrufende code wie dieser:

printf("Before 3: address = %p, a = %d, b = %d\n", (void *)test1, test1->a, test1->b);

modifyMe0(*test1);

printf("After  3: address = %p, a = %d, b = %d\n", (void *)test1, test1->a, test1->b);

Beachten Sie, dass die Adresse der Struktur hat sich verändert nach dem Aufruf modifyMe3().