The C Programming Language - Pointers

The C Programming Language
Heimo Gaicher, born in 1969, has been a passionate tinkerer,
electronics enthusiast, and programmer since a young age.
While working, he completed the industrial electronics
master's school and later the Higher Technical Federal Institute
of Electronics and Technical Informatics (BULME) in Graz. He
has worked extensively in hardware and software
development for LED lighting, testing environments, all-wheeldrive
systems, laboratory measuring devices, and sensor
technology.
Preface
This book is aimed at programming beginners who want to learn the universal
programming language C. Since learning a programming language is not easy for
beginners, this book has been created step-by-step with many examples. A general
and lengthy introduction has been deliberately avoided, as the relevant examples are
precisely documented in the programming code, leading to a better understanding.
The book is not a comprehensive reference, but a step-by-step guide for the learner.
Work through the book carefully from the beginning and try to solve the program
examples independently or expand them according to your own ideas and needs. After
all, the best way to learn a programming language is by programming.
This book has been written with great care. If there are still errors, I welcome
corresponding feedback. Comments and critiques are always welcome at
c4programmers@gmail.com.
Have fun experimenting!
© 2023 Heimo Gaicher

Disclaimer:
This book is intended to serve as a guide for learning C programming, and while every
effort has been made to ensure the accuracy and completeness of the information
presented herein, the author and publisher make no warranties, expressed or implied,
as to the contents of this book.
The examples and code snippets provided in this book are for educational purposes
only and should not be used in any production environment without thorough testing
and review. The author and publisher are not responsible for any errors, omissions, or
damages that may arise from the use of the information presented in this book.
Furthermore, it is important to note that programming is a constantly evolving field
and new techniques, tools, and best practices may emerge after the publication of this
book. Readers are encouraged to stay up to date with the latest developments in C
programming by consulting other resources and online communities.
Finally, this book is not intended as a substitute for formal education or professional
training in computer programming. Readers should use this book as a supplement to
their own learning and seek out additional resources as necessary.
The trade names, common names, product designations, etc. reproduced in this work
may also be trademarks without special identification and, as such, are subject to
statutory provisions.
This work is protected by copyright. All rights, including those of translation, reprinting,
and reproduction of the book or parts thereof, are reserved. No part of the work may
be reproduced, processed, duplicated, or distributed in any form (photocopy,
microfilm, or any other method) without written permission from the publisher,
including for the purposes of educational design.
Bibliographic information of the German National Library:
The German National Library records this publication in the German National
Bibliography; detailed bibliographic data can be accessed via http://dnb.d-nb.de on
the internet.
© 2023 Heimo Gaicher

Contents
Introduction ____________________________________________________ 5
Representation of Code, Variable- and Function Names _________________ 5
1 Pointers ____________________________________________________ 6
1.1 Definition of a Pointer _________________________________________ 7
1.2 Examples with Pointers ________________________________________ 7
1.3 Address Assignment of Pointers ________________________________ 11
1.3.1 Direct Address Assignment __________________________________________ 12
1.4 Pointer of Pointers ___________________________________________ 14
1.5 Pointer Arithmetic ___________________________________________ 15
1.6 Pointer to Arrays ____________________________________________ 16
1.7 Array of Pointers ____________________________________________ 17
1.8 Programming Example Chessboard _____________________________ 18
1.9 Passing Pointers to Functions __________________________________ 19
1.10 Passing Arrays to Functions ____________________________________ 21
1.11 Return a Pointer from Functions ________________________________ 22

Introduction
Dear reader,
this is a free version of the chapter “Pointers” and part of the book “The C
Programming Language” ISBN Softcover: 978-3-347-96632-1 by Heimo Gaicher.
Representation of Code, Variable- and Function Names
In this book, variable and function names, such as myVariable or myFunction(), are
displayed in italics. For function names, two additional brackets are added, like the
function main() for example. Code examples and snippets are shown in a frame using
the Consolas font.
Example
#include
int counter = 100;
void write(void) {
printf(“Value of counter is %d\n”, counter);
}
Program outputs from the IDE's console are displayed with a black background.
Please enter a number: 7
You entered the number 7
Important information or summaries are shown in a grey frame.
This is important information!
Header files from the C Standard Library, such as or , are shown in
angle brackets

1 Pointers
Pointers are a very important tool in the C programming language. Basically, a pointer
is nothing more than a variable that stores the memory address of another variable.
So, pointers only store the address of a memory object of a certain data type.
If you've worked with functions, you may have thought that it would be handy if you
could return more than one value to the calling function.
This is easily done with a pointer. In this case, you need to pass the address, that is, a
pointer to a specific memory location, to the function. You can now use this address
to write a desired value to the memory location specified in the function. You have
now overwritten the variable at the corresponding memory location with a new value
and can also use this variable outside the function.
Another advantage of pointers is the saving of copying operations and the associated
saving of computing time. Suppose you have a function to which you pass ten integer
values. With a 16-bit system, you have to pass 10 x 2 bytes here. But if you use a pointer
here, you only pass a pointer to the beginning of an array of these ten integer values.
And for this pointer you need only 2 bytes of memory.
Also, memory areas can be dynamically manipulated with pointers. You can pass data
objects by reference to functions, and you can use pointers to implement complex data
structures like lists.
So, pointers contain a memory address of a certain expected data type, e.g. char, int,
float, etc. A pointer points directly to a specific address in memory. Pointers are
dereferenced with the * operator. The & operator returns the address of an element
to which the & operator is applied.
Let's first look at how a variable is stored in memory:
int a = 2;
Here the variable a of data type integer has been initialized with the value 2. In this
example, this variable was stored in RAM, e.g., at address 0x015A.
Name Address Value
a 0x015A 2
The C Programming Language by Heimo Gaicher – Chapter Pointers 6

1.1 Definition of a Pointer
A pointer is created like a normal variable. The only difference is that you prefix the
pointer name with a * (asterisk).
int *ptr;
char *p;
char *p, a;
// An int pointer. A pointer named ptr pointing to an int.
// A char pointer. A pointer named p which points to a char
// A char pointer named p and a char variable named a
As mentioned before, a pointer contains an address, and we have already worked with
addresses, for example with the scanf() function.
scanf(%d“, &var);
Here, the value entered by the user is stored at the address of var.
1.2 Examples with Pointers
In the following example, an int variable var is initialized with the value 1234567. The
compiler allocates a place in RAM for the variable var during the compilation process.
For example, on my system, an int value occupies 4 bytes of memory.
/* example 125 – pointers */
#include
int main()
{
int var = 1234567;
printf("The dec. value of var = %d\n", var);
printf("The hex value of var = %x\n", var);
/* using format element %p for pointer and & as address operator */
printf("The address of var = %p", &var);
}
return 0;
The dec. value of var = 123456
The hex value of var = 12d687
The address of var = 0061ff1c
You can easily check this by setting a breakpoint in the IDE before the last line of code
and starting the debugger. Open the debugging window "Memory dump" under Debug
/ Debugging windows and enter the variable name with an address operator in the
address window, in this case &var, and click the Go button.
The C Programming Language by Heimo Gaicher – Chapter Pointers 7

The address of var is now displayed on the far left. The content of var is represented
as a hexadecimal value in the first 4 bytes, with the first byte on the right at position
1. The decimal number 1234567 corresponds to the hexadecimal number 0x0012d687,
which is stored at address 0x61ff1c in this example.
In the next example, we declare a pointer variable of type int named ptr and assign it
the address var. In the next line of code, we use the dereference operator * to access
the variable pointed to by ptr, and store its contents in x. We then output the
corresponding values.
/* example 126 – pointers */
#include
int main()
{
int var = 1234567, x;
int *ptr; // ptr is an int pointer
ptr = &var;
x = *ptr;
// ptr = address of var
// x = value of element pointed to by ptr
printf("The value of x = %d\n", x); // x holds the value of var
printf("The address of var = %p\n", ptr);
printf("The address of x = %p\n", &x);
printf("The address of ptr = %p", &ptr);
}
return 0;
The value of x = 1234567
The address of var = 0061ff1c
The address of x = 0061ff18
The address of ptr = 0061ff14
The pointer variable ptr itself must of course also have a place in memory and was
created here at address 0x0061ff14.
The C Programming Language by Heimo Gaicher – Chapter Pointers 8

In memory, the assignment looks like this:
The pointer ptr stored the address of var. We say that the pointer ptr points to var.
Using the dereference operator *, we indirectly access the value of the variable it
points to via the pointer.
We can declare pointers in several ways, such as:
int *ptr;
int* ptr;
int * ptr;
Where you put the * is up to you, but usually the operator is put right before the
variable name.
In the next example, the pointer ptr first gets the address of var and then gets the
address of x. Thus we access the contents of var first and then the contents of x.
/* example 127 – pointers */
#include
int main()
{
int *ptr, var = 10, x = 20;
ptr = &var; // ptr = address of var
printf("Pointer points to %p and the value is %d\n", ptr, *ptr);
ptr = &x; // ptr = address of x
printf("Pointer points to %p and the value is %d\n", ptr, *ptr);
}
return 0;
Pointer points to 0061ff18 and the value is 10
Pointer points to 0061ff14 and the value is 20
The C Programming Language by Heimo Gaicher – Chapter Pointers 9

Pointers, or rather pointer variables, are also stored under an address in memory.
Depending on the system, pointer variables are at least large enough to store an
address, in this case 4 bytes.
In the following example we access two variables a and b with a char pointer ptr_a
and an int pointer ptr_b and output the addresses and their contents.
/* example 128 – pointers */
#include
int main(void)
{
char a='A', *ptr_a = &a;
int b=1000, *ptr_b = &b;
printf("a = %c = dec %d\n",a,a);
printf("b = %d\n",b);
printf("Address of a = %p\n",ptr_a);
printf("Value of a = %c = %d\n",*ptr_a, *ptr_a);
printf("Address of b = %p\n",ptr_b);
printf("Value of b = %d\n",*ptr_b);
printf("Address of ptr_a = %p\n",&ptr_a);
printf("Address of ptr_b = %p\n",&ptr_b);
printf("Size of ptr_a = %d\n",sizeof(ptr_a));
printf("Size of ptr_b = %d\n",sizeof(ptr_b));
}
return 0;
a = A = dec 65
b = 1000
Address of a = 0060FEFF
Value of a = A = 65
Address of b = 0060FEF4
Value of b = 1000
Address of ptr_a = 0060FEF8
Address of ptr_b = 0060FEF0
Size of ptr_a = 4
Size of ptr_b = 4
The C Programming Language by Heimo Gaicher – Chapter Pointers 10

The following figure shows the addressing in the memory area:
1.3 Address Assignment of Pointers
Where does a pointer point to after it has been declared but not yet used?
int *ptr;
// undefined pointer
The pointer points to an undefined memory location! An undefined pointer can be
dangerous because it is not known to which address it points! For this reason pointers
should always be initialized. This means that you have to assign a value, i.e. a memory
address, to the pointer.
int *ptr = &var;
// defined pointer
This is a defined pointer. The pointer ptr has been initialized with the address of var.
The C Programming Language by Heimo Gaicher – Chapter Pointers 11

To prevent a pointer from pointing to an unknown, undefined memory address, it
should be assigned an address immediately, or if the address is not yet known, the
value 0 or NULL. When a pointer is assigned the value 0 or NULL, it is called a null
pointer. This prevents a valid memory address from being determined by chance when
the pointer is used, thus causing errors that are difficult to find.
int *ptr1 = NULL;
int *ptr2 = 0;
// NULL pointer
// NULL pointer
To keep track when dealing with pointers, you should always use a meaningful name
for a pointer.
int *ptr_var = &var;
As in this example, _var has been appended to the name of the pointer to make it clear
that this pointer points to the address of var. You can also assign an address to a
pointer after it has been declared.
int *ptr_var; // undefined pointer
…
ptr_var = &var; // defined pointer - ptr_var points to var
1.3.1 Direct Address Assignment
A pointer can also be assigned a direct address in memory during initialization. The
following example shows a direct address assignment:
/* example 129 – pointers */
#include
int main()
{
int *ptr = (int *)0x0061ff14; // typecast to an int* - ptr points to 0x0061ff14
printf("ptr points to: %p\n", ptr);
}
return 0;
ptr points to: 0061ff14
To assign a desired address to a pointer, a number (the desired address) must first be
typed into a pointer, in this case an int pointer. This tells the compiler that it is a pointer
to the constant address 0x0061ff14.
The C Programming Language by Heimo Gaicher – Chapter Pointers 12

In the following program, the contents of two variables are swapped using pointers:
/* example 130 – pointers */
#include
int main(void)
{
int a = 2, b = 4, temp;
int *ptr_a = &a, *ptr_b = &b;
printf("a = %d, b = %d\n", a, b);
temp = *ptr_a; // temp gets the value pointed to by *ptr_a. temp = value of a
*ptr_a = *ptr_b; // The value pointed to by *ptr_a is overwritten with the value
// pointed to by *ptr_b, a now gets the value of b
*ptr_b = temp; // The value pointed to by *ptr_b is overwritten with the value
// of temp and that is the value of a
printf("a = %d, b = %d\n", a, b);
}
return 0;
a = 2, b = 4
a = 4, b = 2
In the next example, the values are added with a float pointer:
/* example 131 – pointers */
#include
int main(void)
{
float a=0, b=0, *ptr_a=NULL;
ptr_a = &a;
*ptr_a = 12;
// Pointer ptr_a stores the address of a
// Writes 12 in a
printf("a = %.2f\n",a);
*ptr_a += 5.5; // Adds 5.5 to the existing value of a
printf("a = %.2f\n",a);
b = *ptr_a + 5; // Adds 5 to the existing value of a and stores the result in b
}
printf("b = %.2f\n",b);
a = 12.00
a = 17.50
b = 22.50
The C Programming Language by Heimo Gaicher – Chapter Pointers 13

As you can see, working with pointers can be a bit confusing. Therefore, here is a brief
summary of how pointers are used:
char ch = 'A';
int a = 0, y = 10;
float z = 0.0, x = 3.14;
int *iptr1 = (int *)0x0061ff14; // typecast to an int* - iptr1 points to 0x0061ff14
int *iptr_a;
// undefined int pointer
int *iptr_y = NULL;
// int pointer initialized to NULL
float *fptr_x;
// undefined float pointer
fptr_x = &x;
char cptr_ch = &ch;
// defined float pointer - fptr_x points to x
// defined float pointer - fptr_x points to x
iptr_y = &y;
// iptr_y stores the address of y
*iptr_y = 1000; // iptr_y points to y -> now y = 1000;
a = *iptr_y; // a stores the value pointed to by iptr_y -> a = 1000
*iptr_y = a + 500; // y = 1000 + 500 -> now y = 1500
iptr_a = &a;
// iptr_a stores the address of a
printf("%d\n" , *iptr_a);
printf("%p\n" , iptr_a);
// displays the value a
// displays the Address of a
1.4 Pointer of Pointers
A pointer to a pointer contains the address of a pointer to which it points. A simple
pointer contains the address of a variable. However, when a pointer points to another
pointer, the first pointer contains the address of the second pointer, which in turn
points to the variable that contains a value.
In the following figure, the pointer pptr points to another pointer ptr, which in turn
points to the variable b. With double dereferencing, you can use the pointer ptr to
access the variable b directly.
Figure 1: Pointer to pointer
The C Programming Language by Heimo Gaicher – Chapter Pointers 14

A pointer-to-pointer variable must also be declared as such with **. Here is an
example:
/* example 132 – pointer to pointer */
#include
int main(void)
{
int b = 1000;
int *ptr, **pptr;
ptr = &b;
pptr = &ptr;
// ptr takes the address of b
// pptr takes the address of ptr
printf("Value of b = %d\n",b);
printf("Value of b via *ptr = %d\n",*ptr);
printf("Value of b via **pptr = %d\n",**pptr);
}
return 0;
Value of b = 1000
Value of b via *ptr = 1000
Value of b via **pptr = 1000
1.5 Pointer Arithmetic
You already know that a pointer stores an address, and this address is nothing but an
integer numeric value. And of course you can also change this value by adding or
subtracting a certain value. This means that the four operators +, -, ++ and -- are
available for pointer arithmetic.
Suppose we have an integer pointer iptr pointing to a variable ivar1 with address
0x0060FF00. And suppose that an int value on the system to be used is 4 bytes in size.
This means that the compiler has reserved a memory space of 4 bytes from address
0x0060FF00 to address 0x0060FF03 for variable ivar1. For example, the memory for
the second integer variable ivar2 starts at address 0x0060FF04.
What would happen if we incremented the int pointer with iptr++? In this case, the
pointer would point to address 0x0060FF04, and we could access the value of ivar2 via
the pointer.
The C Programming Language by Heimo Gaicher – Chapter Pointers 15

1.6 Pointer to Arrays
A pointer always increments or decrements by the number of bytes of the data type
to which it points. For a char this would be one byte, for a double it would be 4 or 8
bytes depending on the system.
To illustrate this, in the following example we create an int array and store four values
in it. Instead of the "usual" access to the elements of the array, we now use a pointer
to access the first element in the array, and then increment the pointer three times in
the for loop. This moves the pointer to the next position in the array.
/* example 133 – pointer to arrays */
#include
int main (void)
{
int ivar[] = {2, 8, 5, 9};
int *iptr;
iptr = ivar; // ivar is an array, therefore we need no address operator &
for (int i = 0; i < 4; i++) {
printf("Address of ivar[%d] = %p\n", i, iptr );
printf("Value of ivar[%d] = %d\n", i, *iptr );
}
iptr ++; // move to the next position
}
return 0;
Address of ivar[0] = 0060FEE8
Value of ivar[0] = 2
Address of ivar[1] = 0060FEEC
Value of ivar[1] = 8
Address of ivar[2] = 0060FEF0
Value of ivar[2] = 5
Address of ivar[3] = 0060FEF4
Value of ivar[3] = 9
As you can see, the array ivar[] was stored at address 0x0060FEE8. This is also the
address of the first element with the content 2. The value of the pointer was then
increased by 4 bytes. So the next address in the array for the 2nd element is
0x0060FEEC, whose content is the value 8. This allows access to the individual
elements of an array. It is noticeable here that the & operator for an address
assignment is missing. This is because according to the ANSI-C standard, an array name
represents a pointer to the 1st element of the array. Another notation would be e.g.
ptr_a = &a[0]; The address of the 1st element of array a is also passed to the pointer
ptr_a with this command.
The C Programming Language by Heimo Gaicher – Chapter Pointers 16

1.7 Array of Pointers
If we want to store an array of pointers, we need to declare it as follows:
int *ptr[4];
// Pointer as an array of 4 int pointers
Each element of the array contains a pointer of type int. Let's make an example:
/* example 134 – array of pointers */
#include
int main (void)
{
int ivar[] = {2, 8, 5, 9};
int *iptr[4];
// declare an array of 4 pointers
for (int i = 0; i < 4; i++) {
iptr[i] = &ivar[i]; // assign the address of each array element
}
printf("Value of ivar[%d] = %d\n", i, *iptr[i]);
}
return 0;
Value of ivar[0] = 2
Value of ivar[1] = 8
Value of ivar[2] = 5
Value of ivar[3] = 9
Let’s do the same with a char array!
/* example 135 – array of pointers */
#include
int main (void)
{
char *cptr[] = {"Hi", "i am", "a pointer", "array"};
for (int i = 0; i < 4; i++) {
printf("Value of cptr[%d] = %s\n", i, cptr[i]);
}
}
return 0;
Value of cptr[0] = Hi
Value of cptr[1] = i am
Value of cptr[2] = a pointer
Value of cptr[3] = array
The C Programming Language by Heimo Gaicher – Chapter Pointers 17

1.8 Programming Example Chessboard
A game is to be developed in which a piece can be moved on a chess board by keyboard
input. A chessboard consists of 8x8 squares (8x8 matrix). The starting position of the
piece is in the field [0][0] and the piece (the number 1) is to be moved with the keys w,
a, s, d (w = up, a = left, s = down, d = right). If the edge of the playing field is crossed,
the character positions itself on the opposite side. The program should end with x.
1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
moving [w = up, a = left, s = down, d = right] (exit with x):
/* example 136 – chessboard */
#include
#include
// Prototypes
void fieldOutput(int *field);
void move(int *field, int *posX, int *posY, char moving);
int main(void)
{
int field[8][8] = { 0 }, posX=0, posY=0;
char moving;
field[posY][posX] = 1;
// set game piece
do {
fieldOutput(&field[0][0]);
printf("\nmoving [w = up, a = left, s = down, d = right] (exit with x): ");
scanf("%c", &moving);
move(&field[0][0], &posX, &posY, moving);
fflush(stdin);
system("Cls");
}while(moving != 'x');
// clear keyboard buffer
// clear screen
}
return 0;
The C Programming Language by Heimo Gaicher – Chapter Pointers 18

void fieldOutput(int *field) {
printf("\n");
int i, j;
// output playing field
for(i=0; i 7)
*posY = 0;
}
*(field + *posY * 8 + *posX) = 1; // set new position
1.9 Passing Pointers to Functions
Pointers can also be passed as parameters to functions. We have already explained
this point in detail in the chapter "Call by Reference". The address of a variable was
passed to a function and addressed with pointers within the function. Here is another
small example for the output of the Unix time.
The Unix time is a system for describing a point in time. It is the number of seconds
that have elapsed since January 1, 1970, 00:00:00 (UTC), minus leap seconds. In this
calculation, each day has exactly 86400 seconds.
The C Programming Language by Heimo Gaicher – Chapter Pointers 19

For this we need the function time(), which is defined in the header file . This
function returns the UTC time in seconds.
Syntax:
time_t time(time_t *second)
/* example 137 - get UTC time in seconds */
#include
#include
void getSecondsUTC(unsigned long *ptr_time) {
// get the current number of secondsonds since 1970.01.01 00:00:00 UTC
*ptr_time = time(NULL);
}
int main (void)
{
unsigned long seconds;
getSecondsUTC(&seconds);
// pass the address of seconds
printf("Number of seconds since 1970.01.01: %ld\n", seconds);
printf("Number of minutes since 1970.01.01: %ld\n", seconds/60);
printf("Number of hours since 1970.01.01: %ld\n", seconds/3600);
printf("Number of days since 1970.01.01: %ld\n", seconds/(3600*24));
}
return 0;
Number of seconds since 1970.01.01: 1674053452
Number of minutes since 1970.01.01: 27900890
Number of hours since 1970.01.01: 465014
Number of days since 1970.01.01: 19375
The C Programming Language by Heimo Gaicher – Chapter Pointers 20

1.10 Passing Arrays to Functions
Of course, we can also pass an array as a pointer to a function. In the next example,
myArray[] is initialized with four int values and passed as the first parameter as a
pointer to the getSum() function. The second parameter is the constant value 4, which
passes the array size to the function.
/* example 138 - pass an array to a function */
#include
int getSum(int *arr, int size) {
int sum = 0;
}
for (int i = 0; i < size; i++) {
sum += arr[i];
}
return sum;
int main (void)
{
int myArray[] = {16, 12, 7, 21};
int sumOfMyArray;
sumOfMyArray = getSum(myArray, 4); // pass array as pointer + size
printf("The sum of all elements is: %d\n", sumOfMyArray);
}
return 0;
The sum of all elements is: 56
The C Programming Language by Heimo Gaicher – Chapter Pointers 21

1.11 Return a Pointer from Functions
You already know how to declare functions with return values. If the return value is a
pointer, a * is appended to the return type as usual.
int* func() {
…
}
In the following example, the address of ivar is returned as the return value:
/* example 139 - return a pointer from functions */
#include
int* myFunction(void) {
static int ivar = 100; // declare here a static variable
}
return (&ivar); // return the address of ivar
int main (void)
{
int *iptr;
iptr = myFunction();
// function call, iptr get the address of ivar
printf("Address of ivar: %p\n", iptr);
printf("Value of ivar: %d\n", *iptr);
*iptr = 50; // change the value of ivar to 50
printf("Value of ivar: %d\n", *iptr);
}
return 0;
Address of ivar: 0040a004
Value of ivar: 100
Value of ivar: 50
It is important that the variable within the function is defined as a static variable,
otherwise it will be destroyed when the function is exited and access to this address is
no longer possible.
The C Programming Language by Heimo Gaicher – Chapter Pointers 22

The C Programming Language by Heimo Gaicher – Chapter Pointers 23