Путает аргументы одиночного указателя и двойного указателя в вызовах функций

Вы можете передавать аргумент различными способами В C (капитан очевидный, да).

1. По значению. Затем он копируется в стек. Таким образом, функция имеет локальную копию переменной в фрейме функции. Любые изменения аргумента не изменяют переданное значение. Это похоже на режим "Только чтение"

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

2. Пройти по указателю. Затем передается копия адреса этой переменной (так что да, она по-прежнему передается по значению, но вы передаете значение адреса, а не всего аргумента). Так что это как " читать и писать" режим. Поскольку вы можете получить доступ к передаваемой переменной через ее адрес, вы можете изменить значение этой переменной вне функции.

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

   Но! Вы все еще не можете изменить указатель.

3. Так что если вы хотите изменить указатель, то вы должны передать указатель на указатель. Это похоже на режим "read-write modify":

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

   Если бы это был просто указатель, то произошла бы утечка памяти:

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

   Потому что здесь вы назначаете новый адрес локальной копии адреса, и этот аргумент будет быть уничтоженным после завершения функции.

   UPD. Например, у нас есть

   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);
   }
   

   Внутри функции выделяется память и указатель присваивается локальной переменной. Вызывающий все еще сохраняет старое значение. После вызова функции мы теряем адрес памяти, поэтому он не может быть освобожден.

   Краткий вывод: есть простое правило-если нужно изменить аргумент, передайте на него указатель. Итак, если вы хотите изменить указатель, передайте указатель на указатель. Если вы хотите изменить двойной указатель, передайте указатель на указатель на указатель.

4. Передача аргумента по указателю также намного быстрее, потому что вам не нужно копировать все значения в стеке (конечно, если значение больше, чем указатель на это значение, в противном случае передача указателя только для чтения бессмысленна). Но это опасно, потому что это может быть изменено внутри функции. Таким образом, вы можете защитить аргумент, определяя его с помощью ключевого слова const

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

   Это действительно полезно при работе с библиотеками сторонних разработчиков: сигнатура функции сообщает вам, является ли функция может изменить ваш аргумент или нет. Хотя const является необязательным, рекомендуется писать ключевое слово const каждый раз, когда это возможно

5. Передающий массив. Обычно в качестве аргумента также передается размер массива (следовательно, size_t). Вы передаете массив как указатель.

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

   Иногда можно найти код, в котором разработчик отправляет указатель на объект вместо массива, например

   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);
   }
   

   В этом случае массив одного элемента и указатель на элемент ведут себя одинаково (хотя они и не являются одинаковый).