If a parameter is a pointer type, is the parameter a pointer allocated in local memory

Question

I'm just learning C, and I have a question about pointer parameters. My code is the following:

int Length(node *head)
{
  int length = 0;

  while (head) {
    length++;
    head = head->next;
  }

  return length;
}

The code in the book I'm reading says to do this though:

int Length(struct node* head)
{
    struct node* current = head;
    int count = 0;

    while (current != NULL) {
        count++;
        current = current->next;
    }

    return count;
}

Is there really a difference? The way I'm reading my code is that I get a pointer to a node struct as a parameter. The pointer itself however, is a local variable that I am free to mutate as long as I don't dereference it first. Therefore, I can change the value of the pointer to point to a different node (the next node as it may be).

Will this cause a memory leak or is there some other difference I'm not seeing?

This code is for a linked list implementation. The node struct is defined as:

// Define our linked list node type
typedef struct node {
  int data;
  struct node *next;
} node;

Answer 1

Yes, they are both doing the same. But in the second example, it is more clear what the author is trying to do because of the code. In your first example, you're using the pointer head to reference nodes other than the head. That can be confusing.

You could write your function like this and your intend would be clear:

int GetLength(node* current)
{
  int length = 0;

  while (current != NULL)
  {
    length += 1;
    current = current->next;
  }

  return length;
}

Answer 2

Your solution and reasoning is correct. The node argument is a local variable: a copy of the pointer passed to your function, allocated on the stack. That's why you can modify it from within the function.

There is no difference between the two solutions, at least not in functionality, modern compilers are most likely to optimize away the extra variable in the book's solution. The only slight difference is in style, many tend to take arguments as unmodifiable values just in case to avoid mistakes.

Answer 3

Your understanding of the argument-passing mechanics is correct. Some people simply prefer not to modify argument values, the reasoning being that modifying an argument tends to be bug-prone. There's a strong expectation that at any point in the function, if you want to get the value the caller passed as head , you can just write head . If you modify the argument and then don't pay attention, or if you're maintaining the code 6 months later, you might write head expecting the original value and get some other thing. This is true regardless of the type of the argument.