*, &, ... explain the relationships and naming of pointers, variables, and addresses, using the following code blocks:

Question

I was recently reviewing an excellent, highly praised article on pointers: What are the barriers to understanding pointers and what can be done to overcome them? As I read through it, I came to understand what pointers are. Unfortunately, I'm still unable to use them.

Here's why: I don't understand the naming! Or the applications, really, of pointers. After reading through several 'so-you-want-to-learn-c' books and articles, I've encountered similar code, time and again: "how to create and instantiate a pointer".

When answering, please use example code to demonstrate what, in practice, pointers output.

Here's the code:

char ch = 'c'; 
char *chptr = &ch;

Or, perhaps more confusing:

char ch = 'c';
char *chptr;
chptr = &ch;

Notice that chptr is differently named from the other two variables, which are named ch. Why not name all three variables ch? What problem does it solve to give the pointer a different name?

Also, in the first block of code we have ...*chptr = &ch;; in the second, chptr = &ch;. What is making it acceptable to drop the asterisk in the second block?

Next, I wonder what the applications of pointers are. Do I always need a pointer (when do I need one and when do I not need one)? After submitting my answer, I feel confident--believing that I will be able to comprehend more complex code that uses pointers--enough to continue adapting the language intuitively. I'm still riddled with curiosity, though.

Take this block of code, for example:

typdef struct person
{
  char *name;
  int age;
}

Why declare the name as a pointer to a name variable that doesn't exist, and why declare the age variable as an int without using pointers? That wouldn't make sense, due to this block:

int main()
{
/* below, the int is a pointer */
  int *p;
  void *up;
  return 0;
}

Or this block:

char *sp;
sp = "Hello";
printf("%s",sp);

I thought pointers pointed to an address. "Hello" isn't an address.

With the two prior blocks in mind, have a look at this final block:

int main()
{
  int i,j;
  int *p;
  i = 5;
  p = &i;
  j = *p; //j = i?
  &p = 7; //i = 7?
}

Shouldn't j be set to &i because *p = &i not i. And shouldn't &p = 7 set the address of p to 7, which may not be i?

Answer 1

Notice that chptr is differently named--at this point I added an answer--from the other two variables, which are named ch. Why not name all three variables ch?

• it is common practice for pointers to be prefixed by 'p' (or in this case suffixed by 'ptr') so that it is clear to the code reader that the variable is a pointer. As you now know, programming with pointers is initially tough, and while int *i = 1; and int i = 1 are both legal, unintentionally substituting one for the other may cause some serious debugging time.

Also, in the first block of code we have ...*chptr = &ch;; in the second, chptr = &ch;. What is making it acceptable to drop the asterisk in the second block?

• it is the syntax to use a '*' to declare a pointer variable, ex: int *pInt;

• to assign a value to the pointer variable (to make it point to something), you don't need the '*'. ex:

      int *pInt;
      pInt = &someInt;
  

• however, to assign a value to the address pointed to by the pointer variable or to get the value of the pointed to by the variable, you have to dereference it using the '*'

      int *pInt;
      int someInt = 100;
      pInt = &someInt;
      *pInt = 50;
      printf("%d - %d", *pInt, someInt); // prints "50 - 50"
  

Next, I wonder what the applications of pointers are.

• pointers are used for, among others :

  1. pass-by-value to a function
  2. dynamic memory allocations ...

Why declare the name as a pointer to a name variable that doesn't exist, and why declare the age variable as an int without using pointers?

• "Hello" is an array of 5 characters. using sp = "Hello", "Hello" is stored in a memory location, and it's address is assigned to sp.
• From your example, I assume that name may contain any number of characters so during the execution of the program, a dynamic allocation will be used to store the name.

I thought pointers pointed to an address. "Hello" isn't an address.

• "Hello" (character strings in C) are treated as an array of characters. in this case, sp points to a memory location (heap or stack) that contains an array of 5 characters, and when you use it in an assignment, it will return the address of the "Hello" string in memory.

  int main()
  {
    int i,j;
    int *p;
    i = 5;
    p = &i;
    j = *p; //j = i?
    &p = 7; //i = 7?
  }
  

  • j is not i, in the sense that changing j=100 will not affect the value of i (i still has value 5).

  • &p = 7 is not probably what you intended. it will probably cause an error since &p will yield a value, and it is illegal to assign a value to a value (example: it will evaluate to something like this: 0x0108 = 7;)

  • consider the following memory sample for the above vars

     address | var    | value
     0x0100  | i      | undefined
     0x0104  | j      | undefined
     0x0108  | p      | undefined
    

  • after j = *p,

     0x0100 | i      | 5
     0x0104 | j      | 5
     0x0108 | p      | 0x0100
    

after *p=7 (corrected from &p = 7;)

         0x0100 | i      | 7
         0x0104 | j      | 5
         0x0108 | p      | 0x0100

Answer 2

Example code:

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

int main()
{
    int i;
    long j;
    int *p;

    i = 5;
    p = &i;  ---> Assigning address of "i" to p, so that pointer p points to "i"
                  By dereferencing pointer "p" i.e. by *p, shall retrieve value "5". 

    j = *p; or j = i (alternative to assign value "5" to "j")

    printf("Value of j:%d \n", j); --> Output is "5".

    &p = 7; //i = 7? --> will not change the value of "i" to 7, but instead  
                         will try to change the address of "p", which cannot be 
                         modified.                              

    j = (long)&i;  ---> Assigns address of "i" i.e "100" to "j". 

    printf("Value of j:%p \n", j); --> Output is address of "i" i.e. "100"

    printf("Value of i:%d \n", i); --> Output is "5". Value assigned to "i".

    printf("Address of i:%p \n", &i); --> Output is "100" i.e. address of "i" in our
                                          case.

    printf("Value of *p:%d \n", *p); --> Output is "5". Since pointer p is pointing 
                                        to "i" i.e. "100" in our case. 
                                        *p -> by dereferencing, retrieves value 
                                        present at the address "100" 
                                        that would be "5".

    printf("Value of p:%p \n", p); --> Output is "100". Pointer p is pointing 
                                       to "i" i.e. "p = &i" it will be "100" in our 
                                       case.   

    printf("Address of p:%p \n", &p); --> Output would be the address of pointer "p".
                                          It will not be same as the address of "&i" 
                                          or value present in "p".

    return 0;       
}