Confuses single-pointer and double-pointer pointers in function calls

You can pass an argument in different ways in C (Captain Obvious, yes).

• By value. Then it is copied onto the stack. Thus, the function has a local copy of the variable in the function frame. Any changes to the argument do not change the passed value. This is similar to read-only mode

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

• Follow the signpost. Then the address of that variable is copied (so yes, it is still passed by value, but you are passing the value of the address, not the integer argument). Thus, it is similar to read / write mode. Since you can access the passed variable through your address, you can change the value of that variable outside of the function.

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

  But! You still cannot change the pointer.

• So, if you want to change a pointer, you should pass a pointer to pointer. This is similar to read-write mode:

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

  If it was just a pointer, then there was a memory leak:

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

  because here you are assigning a new address to the local copy of the address, and that argument will be destroyed after the function completes.

  UPD. For example, we have

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

  internal function memory is allocated, and the pointer is assigned to a local variable. Caller still retains the old value. After calling the function, we lose the memory address so that it cannot be freed.

  Short conclusion: there is a simple rule - if you need to change an argument, pass a pointer to it. So, if you want to change the pointer, go pointer to pointer. If you want to change the double pointer, pass pointer to pointer to pointer.

• Passing an argument by a pointer is also much faster because you don't have to copy all the values ​​on the stack (of course, if the value is greater than the pointer to that value, otherwise passing by a read-only pointer doesn't make sense). But this is dangerous because it can be changed inside the function. This way you can protect the argument defining it with the const keyword

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

  This is really useful when working with third party libraries: a function signature tells you if a function can change your argument or not. Although const is optional, it makes sense to write the const keyword whenever possible.

• Passing an array. Typically, the size of the array (hence size_t) is also sent as an argument. You are passing the array as a pointer.

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

  Sometimes you can find code where the developer sends a pointer to an object instead of an array, like

  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 this case, an array of one element and a pointer to an element behave the same (although they are not the same).