Can someone explain how pointer to pointer works?

Question

I don't really understand how the pointer to pointer works. Any way to do the same work without using pointer to pointer?

struct customer
{
    char name[20];
    char surname[20];
    int code;
    float money;
};
typedef struct customer customer;
void inserts(customer **tmp)
{
    *tmp = (customer *)malloc(sizeof(customer));
    puts("Give me a customer name, surname code and money");
    scanf("%s %s %d %f", (*tmp)->name, (*tmp)->surname, &(*tmp)->code, &(*tmp)->money);
}

Answer 1

Pointers to Pointers 101

Lets say you have an int variable x: int x;.

• A portion of memory will be assigned to x large enough to hold an int.
• The memory assigned to x has an address in the process memory map.
• To see the address where x is located in memory, use:
  printf("x's memory address = %p\n", (void*)&x);
• &x means address of x.
• To see the integer value stored in x, use:
  printf("x=%d\n", x);
• x can only be manipulated directly within it's scope of existence. For example, it can be manipulated within the function in which it is declared:
  x = 42;
• Outside its scope of definition, the value of x can be manipulated if its memory address is known.
• If the value of x (ie: 42) is passed to a function(x), that function cannot manipulate the value of x.
• If the address of x is passed to a function(&x), that function can manipulate the value of x.

Now, lets say that you have a pointer variable p that assumes it points to an int: int *p;

• A portion of memory will be assigned to p large enough to hold a memory address.
• The memory assigned to p has an address in the process memory map.
• &p means address of p.
• To see the address where p is located in memory, use:
  printf("p's memory addr = %p\n", &p);
• To see the address where p is pointing, use:
  printf("Address where p is pointing: %p\n", p);
• To see the alleged integer being pointed to, use:
  printf("int = %d\n", *p);
• The value of p is an address in memory; and p can be set to point to any address, whether or not that address actually exists in the process memory map.
• The address of an object is a pointer to that object. Hence, To cause p to point to x:
  p = &x
• Whatever p is pointing at can be referred to by the pointer type (type int for p).
• The amount of memory assigned to p will vary, depending on the architecture of the machine; and how it represents an address.
• p can only be manipulated directly within it's scope of existence. For example, it can be manipulated within the function in which it is declared:
  p = &x; or p = NULL
• Outside its scope of existence, the value of p can be manipulated if its' memory address is known.
• If the value of p (an address) is passed to a function(p), that function cannot manipulate 'p' to change where it points.
• If the address of p is passed to a function(&p), that function can manipulate what p points to.

Now, lets say that you have a pointer to a pointer variable pp that assumes it points to a pointer to an 'int': int **pp; ...or: void inserts(customer **tmp) :

• The address of a pointer is a pointer to a pointer.
• ...

Back to the question

Q: Any way to do the same work without using pointer to pointer?

No. Assume the following:

void inserts(customer **tmp);

...
   {
   customer cust;
   custPtr  custPtr = &cust;

   inserts(&custPtr);
   ... 

The inserts() function requires the address of a pointer in order to manipulate where custPtr points.

If instead:

void inserts2(customer *tmp);

...
   {
   customer cust;
   custPtr  custPtr = &cust;

   inserts2(custPtr);
   ... 

The insert2() would get a copy of the value of custPtr, which is the address of cust. Hence, insert2() could modify the value(s) of cust, but could not change where custPtr is pointing.

Answer 2

For any parameter of type T, if you want to modify the value of the parameter and have that change reflected in the caller, you must pass a pointer:

void foo( T *ptr ) 
{
  *ptr = new_value();
}

void bar( void )
{
  T var;
  foo( &var ); // writes to var
}

If T is a pointer type Q *, then you wind up with a pointer to a pointer:

void foo( Q **ptr )
{
  *ptr = new_value();
}

void bar( void )
{
  Q *var;
  foo( &var ); // writes to var
}

You can use typedefs to hide the pointerness of the variable, but in my experience hiding pointers behind typedefs is bad juju.

You could change your function to return the pointer value instead of writing to the parameter, as @Namfuak suggests:

Q *foo( void )
{
  Q *val = new_value();
  return val;
}

void bar( void )
{
  Q *var;
  var = foo();
}

Answer 3

Multiple levels of indirection can cause confusion. A good strategy is to reduce the confusion, by reducing the levels of indirection.

Legitimate concerns with using scanf() aside, the following would be a way to achieve this:

void inserts(customer **tmp)
{
    customer *new_cust = malloc(sizeof *new_cust);
    if ( !new_cust ) {
        fprintf(stderr, "Couldn't allocate memory.\n");
        exit(EXIT_FAILURE);
    }

    puts("Give me a customer name, surname code and money");
    scanf("%s %s %d %f", new_cust->name, new_cust->surname,
                         new_cust->code, new_cust->money);

    /*  We delay using multiple levels of indirection
        until we get to the very last line, here.      */

    *tmp = new_cust;
}

As others have mentioned, in this particular case just returning the pointer would likely be easier.

Answer 4

If a pointer is your phonebook entry, a pointer to that pointer can be thought of telling you the phonebook in which that entry exists.

Looking at your code:

struct customer {
    char name[20];
    char surname[20];
    int code;
    float money;
};

First, you should not use a float type for money.

Your question is related to C FAQ 4.8. Basically, you have a function to insert a customer record. Where do you want to insert the record? Something that holds the record obviously, a phonebook, a database etc. So, what you need is a pointer to something that holds pointers pointers to the objects you want to insert.

Now, as for the rest of your code, first, note that you should not cast the return value of malloc. Second, using scanf is a serious security risk. Third, you are allocating a new customer record in the inserts function, but you have no way to communicate any failure to the code that calls your function.

Arguably, the name of the function should be something like create_customer_interactive to convey that it does more than just insert a record in a list of records.

Here is how one might structure your code:

#include <stdio.h>
#include <stdlib.h>

struct customer {
    char *name;
    char *surname;
    int code;
    int money; /* in cents */
};

typedef struct customer *PCustomer;

int read_customer_record(FILE *fp, PCustomer customer) {
    /* dummy implementation */
    customer->name = "A. Tester";
    customer->surname = "McDonald";
    customer->code = 123;
    customer->money = 100 * 100;
    return 1;
}

PCustomer insert_record_interactive(PCustomer *db, FILE *fp) {
    PCustomer tmp = malloc(sizeof(*tmp));
    if (!tmp) {
        return NULL;
    }
    if (!read_customer_record(fp, tmp)) {
        free(tmp);
        return NULL;
    }
    *db = tmp;
    return tmp;
}

int main(void) {
    PCustomer new_customer;
    PCustomer *db = malloc(3 * sizeof(*db));
    if (!db) {
        perror("Failed to allocate room for customer records");
        exit(EXIT_FAILURE);
    }

    /* insert a record in the second slot */
    new_customer = insert_record_interactive(&db[1], stdin);
    if (!new_customer) {
        perror("Failed to read customer record");
        exit(EXIT_FAILURE);
    }

    printf(
            "%s %s (%d) : $%.2f\n",
            new_customer->name,
            new_customer->surname,
            new_customer->code,
            ((double)new_customer->money) / 100.0
            );
    return 0;
}

Answer 5

void inserts(customer *tmp[])
{
    *tmp = malloc(sizeof(customer));
    puts("Give me a customer name, surname code and money");
    scanf("%s %s %d %f", (*tmp)->name, (*tmp)->surname, &(*tmp)->code, &(*tmp)->money);
}

That is equivalent. A pointer to a pointer can also be expressed as a pointer to an unknown-sized array.

What happens is that *tmp gets assigned to an array of 1 elements of type "customer". tmp itself refers in both ways (**tmp and *tmp[]) to the pointer of an unknown-sized array of "customer" elements.