C Pointers

Pointers are powerful features of C and C++ programming. Before we learn

pointers, let's learn about addresses in C programming.

Address in C

If you have a variable var in your program, &var will give its address in
the memory.

We have used address numerous times while using the scanf() function.

scanf("%d", &var);

Here, the value entered by the user is stored in the address of var
variable.

Let's take a working example.

#include <stdio.h>
int main()
{
intvar = 5;
printf("value: %d\n", var);

// Notice the use of & before var

printf("address of var: %p", &var);
return 0;
}

Pointers in C

A pointer is a variable that stores the address of another variable. Unlike

other variables that hold values of a certain type, pointer holds the
address of a variable. For example, an integer variable holds (stores) an
integer value, however an integer pointer holds the address of a integer
variable.

Declaring a pointer.

int* p;

Here, we have declared a pointer p of int type.

You can also declare pointers in these ways.

int *p1;
int * p2;

Assigning addresses to Pointers

Let's take an example.

int* pc;
int c;
c = 5;
pc = &c;

Here, 5 is assigned to the variable c. And, the address of c is assigned to

the pc pointer.

Get Value of Thing Pointed by Pointers

To get the value of the thing pointed by the pointers, we use the *
operator. For example:

int* pc, c;
c = 5;
pc = &c;
printf("%d", *pc); // Output: 5

Here, the address of c is assigned to the pc pointer. To get the value

stored in that address, we used *pc.

Note: In the above example, pc is a pointer, not *pc. You cannot and should
not do something like *pc = &c;

The operator * is called the dereference operator (when working with

pointers). It operates on a pointer and gives the value stored in that
pointer.

Changing Value Pointed by Pointers

Example.

int* pc, c;
c = 5;
pc = &c;
c = 1;
printf("%d", c); // Output: 1
printf("%d", *pc); // Ouptut: 1

We have assigned the address of c to the pc pointer.

Then, we changed the value of c to 1. Since pc and the address of c is the

same, *pc gives us 1.

Another example.

int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc); // Ouptut: 1
printf("%d", c); // Output: 1

We have assigned the address of c to the pc pointer.

Then, we changed *pc to 1 using *pc = 1;. Since pc and the address of c is
the same, c will be equal to 1.

One more example.

int* pc, c, d;
c = 5;
d = -15;

pc = &c; printf("%d", *pc); // Output: 5

pc = &d; printf("%d", *pc); // Ouptut: -15

Initially, the address of c is assigned to the pc pointer using pc = &c;.

Since c is 5, *pc gives us 5.

Then, the address of d is assigned to the pc pointer using pc = &d;. Since

d is -15, *pc gives us -15.

Pointer operators

The “Address of” Operator (&)

The & operator is used to display the address of a variable using ampersand
sign.

printf("Address of var is: %p",&num);

%p is a format specifier which is used for displaying the address in hex

format.

The indirection or dereference (“Value at Address”) Operator (*)

The * operator can be used to access the value of a variable through a

pointer.
For example:

double a =10;
double*p;
p =&a;

*p would give us the value of the variable a. The following statement would
display 10 as output.

printf("%d",*p);

Similarly if we assign a value to *pointer like this:

*p =200;

It would change the value of variable a. The statement above will change
the value of a from 10 to 200.

Example: Working of Pointers

Let's take a working example.

#include <stdio.h>
int main()
{
int* pc, c;

c = 22;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 22

pc = &c;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 22

c = 11;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 11

*pc = 2;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 2
return 0;
}

Output

Address of c: 2686784
Value of c: 22

Address of pointer pc: 2686784

Content of pointer pc: 22

Address of pointer pc: 2686784

Content of pointer pc: 11

Address of c: 2686784
Value of c: 2

Explanation of the program

int* pc, c;
Here, a pointer pc and a normal variable c, both of type int, is created.
Since pc and c are not initialized at initially, pointer pc points to
either no address or a random address. And, variable c has an address but
contains random garbage value.

c = 22;

This assigns 22 to the variable c. That is, 22 is stored in the memory

location of variable c.

pc = &c;
This assigns the address of variable c to the pointer pc.

c = 11;

This assigns 11 to variable c.

*pc = 2;

This change the value at the memory location pointed by the pointer pc to
2.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,

int c, *pc;

// pc is address but c is not

pc = c; // Error

// &c is address but *pc is not

*pc = &c; // Error

// both &c and pc are addresses

pc = &c;

// both c and *pc are values

*pc = c;

Here's an example of pointer syntax beginners often find confusing.

#include <stdio.h>
int main() {
int c = 5;
int *p = &c;
printf("%d", *p); // 5
return 0;
}
Why didn't we get an error when using int *p = &c;?
It's because
int *p = &c;
is equivalent to
int *p:
p = &c;

In both cases, we are creating a pointer p (not *p) and assigning &c to it.

To avoid this confusion, we can use the statement like this:

int* p = &c;

Relationship between Arrays and Pointers

An array is a block of sequential data.

Consider a program to print addresses of array elements.

#include <stdio.h>
int main() {
int x[4];
inti;

for(i = 0; i< 4; ++i) {

printf("&x[%d] = %p\n", i, &x[i]);
}

printf("Address of array x: %p", x);

return 0;
}
Output
&x[0] = 1450734448
&x[1] = 1450734452
&x[2] = 1450734456
&x[3] = 1450734460
Address of array x: 1450734448

There is a difference of 4 bytes between two consecutive elements of array

x. It is because the size of int is 4 bytes (on our compiler).

Notice that, the address of &x[0] and x is the same. It's because the
variable name x points to the first element of the array.
From the above example, it is clear that &x[0] is equivalent to x. And,
x[0] is equivalent to *x.

Similarly,

 &x[1] is equivalent to x+1 and x[1] is equivalent to *(x+1).

 &x[2] is equivalent to x+2 and x[2] is equivalent to *(x+2).
 ...
 Basically, &x[i] is equivalent to x+i and x[i] is equivalent to
*(x+i).

Example 1: Pointers and Arrays

#include <stdio.h>
int main() {
inti, x[6], sum = 0;
printf("Enter 6 numbers: \n");
for(i = 0; i< 6; ++i) {
// Equivalent to scanf("%d", &x[i]);
scanf("%d", x+i);

// Equivalent to sum += x[i] wichi equivalent to sum =sum +x[i]

sum += *(x+i);
}
printf("Sum = %d", sum);
return 0;
}

Here, we have declared an array x of 6 elements. To access elements of the

array, we have used pointers.

In most contexts, array names are converted to pointers. That's the reason
why you can use pointers to access elements of arrays. However, pointers
and arrays are not the same.

Example 2: Arrays and Pointers

#include <stdio.h>
int main() {
int x[5] = {1, 2, 3, 4, 5};
int* ptr;

// ptr is assigned the address of the third element

ptr = &x[2];

printf("*ptr = %d \n", *ptr); // 3

printf("*(ptr+1) = %d \n", *(ptr+1)); // 4
printf("*(ptr-1) = %d", *(ptr-1)); // 2

return 0;
}

In this example, &x[2], the address of the third element, is assigned to

the ptr pointer. Hence, 3 is displayed when we printed *ptr.

And, printing *(ptr+1) gives us the fourth element. Similarly, printing

*(ptr-1) gives us the second element.

Call by Reference: Using pointers

In C programming, it is also possible to pass addresses as arguments to

functions.

To accept these addresses in the function definition, we can use pointers.

It's because pointers are used to store addresses.

For example:

Example: Call by reference

#include <stdio.h>
void swap(int *n1, int *n2);

int main()
{
int num1 = 5, num2 = 10;

// address of num1 and num2 is passed

swap( &num1, &num2);

printf("num1 = %d\n", num1);

printf("num2 = %d", num2);
return 0;
}

void swap(int* n1, int* n2)

{
inttemp;
temp = *n1;
*n1 = *n2;
*n2 = temp;
}

The address of num1 and num2 are passed to the swap() function using
swap(&num1, &num2);.
Pointers n1 and n2 accept these arguments in the function definition.

void swap(int* n1, int* n2) {

... ..
}

When *n1 and *n2 are changed inside the swap() function, num1 and num2
inside the main() function are also changed.

Inside the swap() function, *n1 and *n2 swapped. Hence, num1 and num2 are
also swapped.

Notice that, swap() is not returning anything; its return type is void.

This technique is known as call by reference in C programming.

Example 2: Passing Pointers to Functions

#include <stdio.h>

void addOne(int* ptr) {

(*ptr)++; // adding 1 to *ptr
}

int main()
{
int* p, i = 10;
p = &i;
addOne(p);

printf("%d", *p); // 11
return 0;
}

Here, the value stored at p, *p, is 10 initially.

We then passed the pointer p to the addOne() function. The ptr pointer gets
this address in the addOne() function.

Inside the function, we increased the value stored at ptr by 1 using (*ptr)
++;. Since ptr and p pointers both have the same address, *p inside main()
is also 11.