When to use dereference operator for pointers C++

Question

I'm currently studying C++. Not in school. Using books, tutorials and practice.

One thing that confuses me and I haven't been able to track down an answer is when to use the dereference operator (*) for pointers. For example, from C++ primer which I'm currently reading:

char *cp = get_string();
if (cp) /* ... */    // true if the pointer cp is not zero 

while (*cp) /*    ... */    // true if *cp is not the null character

I don't understand why in the if statement it is just cp without dereference operator and then in the while statement it uses the dereference operator. There is other examples like a mix of uses in a for loop but this is the latest example in the book that confuses me. Thanks in advance for your help.

Summary: when do you just use variable name of pointer without the dereference and when do you use it with dereference. And how to tell difference.

Answer 1

A pointer is a variable whose value is the address of another variable or object. We say that the pointer "points to" that other object.

When writing an expression, cp means the pointer variable. *cp means the variable or object whose address the pointer variable holds.

Try to keep clear in your mind the distinction between "the pointer" and "the thing being pointed to". These are two distinct things, each with their own lifetimes and storage requirements.

So to address the code in your question, if (cp) is testing the pointer. It's short for if ( cp != nullptr ), i.e. has the pointer been set to point somewhere? (In other words, does the pointer currently hold the address of another object?)

if (*cp) means if (*cp != 0) , it is asking about the value of the object whose address is stored in the pointer (in other words, the value of the object being pointed to).

Answer 2

The difference is simple but takes practice to get used to. Essentially, the dereference operator is used when you want to deal with what the pointer is actually pointing to (i.e the thing that is actually at the end of the pointer).

So for example, if I have a char *cp = get_string();, then cp is a pointer that is pointing to the first character in an array of characters.

Checking something like if(cp) is checking whether the pointer is 0 (i.e. if the pointer is pointing to NULL). This is probably useful in this context in that get_string() returns a pointer to a string if it is successful, or a NULL if something went wrong.

In contrast, doing something like while(*cp) is saying, while the character currently pointed to by cp is not 0 (the null character \0), then continue looping. In this context, your while loop probably looks something like:

while(*cp) {
    // process letter currently pointed to by cp
    cp++; // advance cp to point to the next character.
}

This is a common idiom to iterate through a character array.

Answer 3

This image explains the concept.

A pointer variable always stores the address of another variable. In case of arrays, it stores the address of the first element in the array.

The dereference operator refers to the value in the address stored by the particular pointer variable. In the above example, the address stored in the pointer variable ptr is 1001. *(ptr) should give the value stored in address location 1001 which is the content of the variable var ie, 50.

In summary, When you want to check if the pointer variable is pointing to some address location, you use the variable without dereference operator and when you want to deal with the value stored in the address location stored in the pointer variable, use it with the dereference operator

In your example, First it checks if the pointer points to a string by the statement

if(cp)

Then it is checking if the content of the variable it the pointer is non null (May be to check the end of the string)by the statement

while(*cp)

Answer 4

I don't think writing these two tests like this is good practice. For clarity (and this is the very question you ask) they should be:

if(cp == nullptr) // or `cp == NULL`
    ...
if(*cp == '\0')
    ...