DEV Community: Srijan

Structure in C - Storage, Pointers, Functions and Self-Referential Structure

Srijan — Thu, 27 Aug 2020 09:03:53 +0000

We have variables of different data types such as ints, chars, floats, etc to store data. We have arrays to group together a collection of data of the same data type.

But in reality, we will not always have the luxury of having data of one type. That's where a structure comes into the picture.

Topics-

0. Memory Allocation of a Structure
1. Pointers
2. Functions
3. Self-Referential Structure

0. Memory Allocation of a Structure

When a structure variable of some type is declared, structure members are allocated contiguous (adjacent) memory locations.

struct student
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    } stu1;

Here, the memory will be allocated to name[20], followed by roll, gender and marks[5]. This implies that the size of the st1 or struct student will be the sum of the size of its members. Isn't it? Let's check.

void main()
{
    printf("Sum of the size of members = %I64d bytes\n", sizeof(stu1.name) + sizeof(stu1.roll) + sizeof(stu1.gender) + sizeof(stu1.marks));
    printf("Using sizeof() operator = %I64d bytes\n",sizeof(stu1));
}

 /* Output */
Sum of the size of members = 45 bytes
Using sizeof() operator = 48 bytes

Using the sizeof() operator gives 3 more bytes than the sum of the size of members. Why? Where are those 3 bytes in the memory? Let's answer the second question first. We can print the addresses of the members to find the addresses of those 3 bytes.

void main()
{
    printf("Address of member name = %d\n", &stu1.name);
    printf("Address of member roll = %d\n", &stu1.roll);
    printf("Address of member gender = %d\n", &stu1.gender);
    printf("Address of member marks = %d\n", &stu1.marks);
}

 /* Output */
Address of member name = 4225408
Address of member roll = 4225428
Address of member gender = 4225432
Address of member marks = 4225436

We observe that array marks[5] instead of being allocated from 4225433 has been allocated from 4224536. But why?

Data Aligment

Before looking at data alignment, it is important to know how the processor reads data from the memory.

A processor reads one word in one cycle. This word is 4 bytes for a 32- bit processor and 8 bytes for a 64-bit processor. Lower the number of cycles, better is the performance of the CPU.

One way to achieve this is by aligning the data. Aligning means that a variable of any primitive data type of size t will always (by default) have an address that is a multiple of t. This essentially is data alignment. This takes place every time.

Aligned addresses for some data types

data type	size ( in bytes)	address
`char`	1	multiple of 1
`short`	2	multiple of 2
`int`, `float`	4	multiple of 4
`double`, `long`, `*` ( pointers)	8	multiple of 8
`long double`	16	multiple of 16

Structure Padding

It may be required to insert some extra bytes between the members of the structure to align the data. These extra bytes are known as padding.

In our above example, the 3 bytes acted as padding. Without them, marks[0] which is of type int (address multiple of 4) would have its base address as 4225433 (not a multiple of 4).

You can now probably see why structures can't be compared directly.

Structure Member Alignment

To explain this, we will take another example (you'll understand why).

struct example
    {
        int i1;
        double d1;
        char c1;

    } example1;

void main()
{
    printf("size = %I64d bytes\n",sizeof(example1));
}

What would be the output? Let's apply what we know.

i1 is of 4 bytes. It will be followed by padding of 4 bytes because the address of d1 should be divisible by 8. This will be followed by 8 and 1 byte respectively for d1 and c1. Thus, the output should be 4 + 4 + 8 + 1 = 17 bytes.

 /* Output */
size = 24 bytes

What? Wrong again! How? Through an array of struct example, we can understand better. We will also print the address of the members of example2[0].

void main()
{
    struct example example2[2];
    printf("Address of example2[0].i1 = %d\n", &example2[0].i1);
    printf("Address of example2[0].d1 = %d\n", &example2[0].d1);
    printf("Address of example2[0].c1 = %d\n", &example2[0].c1);

}

 /* Output */
Address of example2[0].i1 = 4225408
Address of example2[0].d1 = 4225416
Address of example2[0].c1 = 4225424

Let's suppose the size of example2[0] is 17 bytes. This implies that the address of example2[1].i1 will be 4225425. This isn't possible since the address of int should be a multiple of 4. Logically, the possible address for example2[1].i1 seems to be 4225428, a multiple of 4.

This is wrong as well. Did you find out? The address of example2[1].d1 now will be (28 + 4 ( i1) + 3 ( padding)) 4225436 which is not a multiple of 8.

To avoid such misalignment, the compiler introduces alignment to every structure. This is done by adding extra bytes after the last member, known as structure member alignment.

In the example discussed at the start of this section, it wasn't required ( hence, another example).

A simple way to remember is through this rule - Address of structure & structure length must be multiples of t_max. Here, t_max is the maximum size taken by a member in the structure.

For struct example, 8 bytes is the maximum size of d1. Therefore, there is a padding of 7 bytes to the end of the structure, making its size 24 bytes.

These two points will help you find the size of any structure -

Any data type stores its value at an address that is multiple of its size.
Any structure takes the size which is multiple of maximum bytes taken by a member.

Though we can lower the CPU cycles, there is a significant amount of memory going waste. One way to decrease the amount of padding to a possible minimum is by declaring the member variables in decreasing order of their size.

If we follow this in struct example, the size of the structure reduces to 16 bytes. The padding gets reduced from 7 to 3 bytes.

struct example
    {
        double d1; 
        int i1;
        char c1;

    } example3;

void main()
{
    printf("size = %I64d bytes\n",sizeof(example3));
}

 /* Output */
size = 16 bytes

Strcture Packing

Packing is the opposite of padding. It prevents the compiler from padding and removes the unallocated memory. In the case of Windows, we use the #pragma pack directive, which specifies the packing alignment for structure members.

#pragma pack(1)

struct example
    {
        double d1; 
        int i1;
        char c1;

    } example4;

void main()
{
    printf("size = %I64d bytes\n",sizeof(example4));
}

 /* Output */
size = 13 bytes

This ensures that the members are aligned on a 1-byte boundary. In other words, the address of any data type has to be as multiple of 1 byte or their size (whichever is lower).

1. Pointers

Pointer as a Member

A structure can have pointers as members as well.

struct student
    {
        char *name;
        int *roll;
        char gender;
        int marks[5];
    };

void main()
{   int alexRoll = 44;
   struct student stu1 = { "Alex", &alexRoll, 'M', { 76, 78, 56, 98, 92 }};
}

Using . (dot operator), we can again access the members. Since roll now has the address of alexRoll, we will have to dereference stu1.roll to get the value ( and not stu1.(*roll) ).

   printf("Name: %s\n", stu1.name);
   printf("Roll: %d\n", *(stu1.roll));
   printf("Gender: %c\n", stu1.gender);

   for( int i = 0; i < 5; i++)
    printf("Marks in %dth subject: %d\n", i, stu1.marks[i]);

 /* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 76
Marks in 1th subject: 78
Marks in 2th subject: 56
Marks in 3th subject: 98
Marks in 4th subject: 92

Pointer to Structure

Like integer pointers, array pointers and function pointers, we have pointer to structures or structure pointers as well.

struct student {
    char name[20];
    int roll;
    char gender;
    int marks[5];
};

struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};

struct student *ptrStu1 = &stu1;

Here, we have declared a pointer ptrStu1 of type struct student. We have assigned the address of stu1 to ptrStu1.

ptrStu1 stores the base address of stu1, which is the base address of the first member of the structure. Increment by 1 would increase the address by sizeof(stu1) bytes.

printf("Address of structure = %d\n", ptrStu1);
printf("Adress of member `name` = %d\n", &stu1.name);
printf("Increment by 1 results in %d\n", ptrStu1 + 1);

/* Output */
Address of structure = 6421968
Adress of member 'name' = 6421968
Increment by 1 results in 6422016

We can access the members of stu1 using ptrStu1 in two ways. Using * (indirection operator) or using -> (infix or arrow operator).

With *, we will continue to use the .(dot operator) whereas with -> we won't need dot operator.

printf("Name w.o using ptrStu1 : %s\n", stu1.name);
printf("Name using ptrStu1 and * : %s\n", (*ptrStu1).name);
printf("Name using ptrStu1 and -> : %s\n", ptrStu1->name);

/* Output */
Name without using ptrStu1: Alex
Name using ptrStu1 and *: Alex
Name using ptrStu1 and ->: Alex

Similarly, we can access and modify other members as well. Note that the brackets are necessary while using * since the dot operator(.) has higher precedence over *.

Array Of Structure

We can create an array of type struct student and use a pointer to access the elements and their members.

struct student stu[10];

 /* Pointer to the first element (structure) of the array */
struct student *ptrStu_type1 = stu;

 /* Pointer to an array of 10 struct student */
struct student (*ptrStu_type2)[10] = &stu;

Note that ptrStu_type1 is a pointer to stu[0] whereas ptrStu_type2 is a pointer to the whole array of 10 struct student. Adding 1 to ptrStu_type1 would point to stu[1].

We can use ptrStu_type1 with a loop to traverse through the elements and their members.

for( int i = 0; i <  10; i++)
printf("%s, %d\n", ( ptrStu_type1 + i)->name, ( ptrStu_type1 + i)->roll);

2. Functions

Function as a Member

Functions can not be a member of a structure. However, using function pointers, we can call functions using . (dot operator). However, it is not recommended.

 struct example
    {
        int i;
        void (*ptrMessage)(int i);


    };

void message(int);

void message(int i)
{
    printf("Hello, I'm a member of a structure. This structure also has an integer with value %d", i);
}

void main()
{
    struct example eg1 = {6, message};
    eg1.ptrMessage(eg1.i);
}

We have declared two members, an integer i and a function pointer ptrMessage inside struct example. The function pointer points to a function that takes an integer and returns void.

message is one such function. We initialized eg1 with 6 and message. Then we use . to call the function using ptrMessage and pass eg1.i.

Structure as a Function Argument

Like variables, we can pass individual structure members as arguments.

#include <stdio.h>

struct student {
    char name[20];
    int roll;
    char gender;
    int marks[5];
};

void display(char a[], int b, char c, int marks[])
{
    printf("Name: %s\n", a);
    printf("Roll: %d\n", b);
    printf("Gender: %c\n", c);

    for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,marks[i]);
}
void main()
{
    struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    display(stu1.name, stu1.roll, stu1.gender, stu1.marks);
}

 /* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 76
Marks in 1th subject: 98
Marks in 2th subject: 68
Marks in 3th subject: 87
Marks in 4th subject: 93

Note that the structure struct student is declared outside main(), at the very top. This is to ensure that it is available globally and display() can use it.

If the structure is defined inside main(), its scope will be limited to main().

Passing structure members are not efficient when they are in large no. Then structure variables can be passed to a function.

void display(struct student a)
{
    printf("Name: %s\n", a.name);
    printf("Roll: %d\n", a.roll);
    printf("Gender: %c\n", a.gender);

    for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,a.marks[i]);
}
void main()
{
    struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    display(stu1);
}

If the size of the structure is large, then passing a copy of it won't be very efficient. We could pass a structure pointer to a function. In this case, the address of the structure is passed as an actual argument.

void display(struct student *p)
{
    printf("Name: %s\n", p->name);
    printf("Roll: %d\n", p->roll);
    printf("Gender: %c\n", p->gender);

    for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,p->marks[i]);
}
void main()
{
    struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    struct student *ptrStu1 = &stu1;
    display(ptrStu1);
}

Passing an array of structure to a function is similar to passing an array of any type to a function. The name of the array, which is the base address of the array of the structure is passed to the function.

void display(struct student *p)
{   
    for( int j = 0; j < 10; j++)
   {
       printf("Name: %s\n", (p+j)->name);
        printf("Roll: %d\n", (p+j)->roll);
        printf("Gender: %c\n", (p+j)->gender);

        for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,(p+j)->marks[i]);
   }
}

void main()
{
    struct student stu1[10];
    display(stu1);
}

Structure as a Function Return

We can return a structure variable, just like any other variable.

#include <stdio.h>

struct student {
    char name[20];
    int roll;
    char gender;
    int marks[5];
};


struct student increaseBy5(struct student p)
{
    for( int i =0; i < 5; i++)
        if(p.marks[i] + 5 <= 100)
           {
               p.marks[i]+=5;
           }
    return p;
}

void main()
{
    struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    stu1 = increaseBy5(stu1);

    printf("Name: %s\n", stu1.name);
    printf("Roll: %d\n", stu1.roll);
    printf("Gender: %c\n", stu1.gender);

    for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,stu1.marks[i]);
}

 /* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 81
Marks in 1th subject: 98
Marks in 2th subject: 73
Marks in 3th subject: 92
Marks in 4th subject: 98

The function increaseBy5() increase the marks by 5 for subjects in which after increasing marks is less than or equal to 100. Note that the return type is a structure variable of type struct student.

While returning a structure member the return type has to be that of the member.

A structure pointer can also be returned by a function.

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

struct rectangle {
    int length;
    int breadth;
};

struct rectangle* function(int length, int breadth)
{
    struct rectangle *p  = (struct rectangle *)malloc(sizeof(struct rectangle));
     p->length = length;
     p->breadth = breadth;
    return p;
}

void main()
{
    struct rectangle *rectangle1 = function(5,4);
    printf("Length of rectangle = %d units\n", rectangle1->length);
    printf("Breadth of rectangle = %d units\n", rectangle1->breadth);
    printf("Area of rectangle = %d square units\n", rectangle1->length * rectangle1->breadth);
}

 /* Output */
Length of rectangle = 5 units
Breadth of rectangle = 4 units
Area of rectangle = 20 square units

Notice we have allocated the memory of size struct rectangle dynamically using malloc(). Since it returns a void pointer, we have to typecast it to a struct rectangle pointer.

3. Self-Referential Structure

We discussed that pointers can be a member of a structure too. What if the pointer is a structure pointer? The structure pointer can either be of same type as the structure or different.

Self-referential structures are those which have structure pointer(s) of the same type as their member(s).

struct student {
    char name[20];
    int roll;
    char gender;
    int marks[5];
    struct student *next;
};

This is a self-referential structure where next is a struct student type structure pointer. We will now create two structure variables stu1 and stu2 and initialize them with values. We will then store the address of stu2 in next member of stu1.

void main()
{
    struct student stu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}, NULL};
    struct student stu2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}, NULL};
    stu1.next = &stu2;
}

We can now access the members of stu2 using stu1 and next.

void main()
{
    printf("Name: %s\n", stu1.next->name);
    printf("Roll: %d\n", stu1.next->roll);
    printf("Gender: %c\n", stu1.next->gender);

    for(int i = 0; i < 5; i++)
        printf("Marks in %dth subject: %d\n",i,stu1.next->marks[i]);
}

 /* Output */
Name: Max
Roll: 33
Gender: M
Marks in 0th subject: 87
Marks in 1th subject: 84
Marks in 2th subject: 82
Marks in 3th subject: 96
Marks in 4th subject: 78

Suppose we want a different structure variable after stu1, that is insert another structure variable between stu1 and stu2. This can be done easily.

void main()
{
    struct student stu3 = { "Gasly", 23, 'M', {83, 64, 88, 79, 91}, NULL};
    st1.next = &stu3;
    stu3.next = &stu2;
}

Now stu1.next stores the address of stu3. And stu3.next has the address of stu2. We can now access all three structures using stu1.

    printf("Roll Of %s: %d\n", stu1.next->name, stu1.next->roll);
    printf("Gender Of %s: %c\n", stu1.next->next->name, stu1.next->next->gender);

 /* Output */
Roll Of Gasly: 23
Gender Of Max: M

Notice how we have formed a link between stu1, stu3 and stu2 using structure pointers. What we have discussed here forms the starting point of Linked List.

Self-Referential Structures are very useful in creating data structures such as linked list, stacks, queues, graphs etc.

The next step could be to learn more about the linked list and other data structures named above.

Structure In C - Fundamentals

Srijan — Thu, 20 Aug 2020 13:40:47 +0000

📸 by Robby McCullough on Unsplash

We have variables of different data types such as ints, chars, floats, etc to store data. We have arrays to group together a collection of data of the same data type.

But in reality, we will not always have the luxury of having data of one type. That's where a structure comes into the picture.

Topics-

0. Definition and Declaration
1. Initialization and Accessing the Members of a Structure
2. Operating with Structure Variable
3. Array Of Structure
4. Nested Structure

0. Definition and Declaration

A structure is a collection of one or more variables, possibly of different types, grouped under a single name. It is a user-defined data type. They help to organize complicated data in large programs, as they allow a group of logically related variables to be treated as one.

For example, a student can have properties name, age, gender and marks. We could create a character array for name, an integer variable for roll, a character variable for gender and an integer array for marks. But if there are 20 or 100 students, it will be difficult to handle those variables.

We can declare a structure using struct keyword following the syntax as below:

struct structureName
        {
            dataType memberVariable1;
            datatype memberVariable2;
            ...
        };

 /* Example */
struct student
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    };

The above statement defines a new data type struct student. Each variable of this data type will consist of name[20], roll, gender and marks[5]. These are known as members of the structure.

Once a structure is declared as a new data type, then the variables of that data type can be created.


 /* Variable declaration */
struct structureName structureVariable;

 /* Example /*
struct student stu1;
struct student stu2,stu3,stu4;

Each variable of struct student has its copies of the members.

Few important nuggets-

The members of the structure do not occupy memory until a structure variable is created.
You might have noticed we are using struct while variable declaration as well. Isn't that tedious?

Using the typedef keyword in the structure declaration we can prevent writing struct again.

typedef struct students
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    } STUDENT; 

/* or */
typedef struct
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    } STUDENT; 


STUDENT stu1,stu2,stu3,stu4;

By convention, uppercase letters are used for type definitions ( such as STUDENT).

3.The structure definition and variable declaration can be combined as below.

struct student
    {
        char name[20];
        int roll;
        chat gender;
        int marks[5];
    }stu1, stu2, stu3, stu4;

4.The use of structureName is optional. The code below is completely valid.

struct
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    }stu1, stu2, stu3, stu4;

5.Structures are generally declared at the top of the source code file, even before defining functions.

6.C doesn't allow variable initialization inside a structure declaration.

1. Initialization and Accessing the Members of a Structure

Like any other variable, a structure variable can also be initialized where they are declared. There is a one-to-one relationship between the members and their initializing values.

 /* Variable Initialization */
struct structureName = { value1, value2,...};

 /* Example */
typedef struct
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
    }STUDENT;

void main(){
STUDENT stu1 = { "Alex", 43, 'M', {76, 78, 56, 98, 92}};
STUDENT stu2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}};
}

To access the members, we have to use . ( dot operator).

 /* Accessing Memebers of a Structure */
structureVariable.memberVariable

/* Example */
 printf("Name: %s\n", stu1.name);
 printf("Roll: %d\n", stu1.roll);
 printf("Gender: %c\n", stu1.gender);
 for( int i = 0; i < 5; i++)
   printf("Marks in %dth subject: %d\n", i, stu1.marks[i]);

/* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 76
Marks in 1th subject: 78
Marks in 2th subject: 56
Marks in 3th subject: 98
Marks in 4th subject: 92

The members can be initialized in the variable declaration in any order using ..

STUDENT stu3 = { .gender = 'M', .roll = 23, .name = "Gasly", .marks = { 99, 45, 67, 78, 94}};

We can also initialize the first few members and leave the remaining blank. However, the uninitialized members should be only at the end of the list.

Uninitialized integers and floating-point numbers have a default value 0. It is \0( NULL) for characters and strings.

STUDENT stu4 = { "Kviyat", 65};
 /* same as { "Kviyat", 65, '\0', { 0, 0, 0, 0, 0} } */

2. Operating with Structure Variable

Like variables of primitive data types, we cannot perform arithmetic operations such as +, -, *, /, etc. Likewise, relational and equality operators cannot be used with structure variables. But, we can copy one structure variable to another, provided they belong to the same structure.

 /* Invalid Operations */
stu1 + stu2
stu1 - stu2
stu1 == stu2
stu1 != stu2 etc.

 /* Valid Operation */
stu1 = stu2

We will have to compare the structure members individually to compare structure variables.

#include <stdio.h>
#include <string.h>

 struct student
    {
        char name[20];
        double roll;
        char gender;
        int marks[5];
    }stu1,stu2;


void main()
{
    struct student stu1= { "Alex", 43, 'M', {76, 78, 56, 98, 92}};
    struct student stu2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}};

    if( strcmp(stu1.name,stu2.name) == 0 && stu1.roll == stu2.roll)
        printf("Both are the records of the same student.\n");
    else printf("Different records, different students.\n");

     /* Copiying the structure variable */
    st2 = st1;

    if( strcmp(stu1.name,stu2.name) == 0 && stu1.roll == stu2.roll)
        printf("\nBoth are the records of the same student.\n");
    else printf("\nDifferent records, different students.\n");
}

 /* Output */
Different records, different students.

Both are the records of the same student.

3. Array of Structure

You have already seen how we had to create 4 different struct student type variables to store the records of 4 students. A better way would be to create an array of struct student ( just like array of ints).

struct student
    {
        char name[20];
        double roll;
        char gender;
        int marks[5];
    };

struct student stu[4];

To access the elements of the array stu and the members of each element, loops can be used.

 /* Taking values for the user */

for(int i = 0; i < 4; i++)
    {
        printf("Enter name:\n");
        scanf("%s",&stu[i].name);
        printf("Enter roll:\n");
        scanf("%d",&stu[i].roll);
        printf("Enter gender:\n");
        scanf(" %c",&stu[i].gender);

        for( int j = 0; j < 5; j++)
        {
            printf("Enter marks of %dth subject:\n",j);
            scanf("%d",&stu[i].marks[j]);
        }

        printf("\n-------------------\n\n");
    }

 /* Finding the average marks and printing it */

for(int i = 0; i < 4; i++)
    {
        float sum = 0;
        for( int j = 0; j < 5; j++)
        {
            sum += stu[i].marks[j];
        }

        printf("Name: %s\nAverage Marks = %.2f\n\n", stu[i].name,sum/5);
    }

4. Nested Structure

Nesting of structure means having one or more structure variables inside another structure. Like we declare an int member or char member, we can also declare a structure variable as a member.

struct date
    {
       int date;
       int month;
       int year;
    };

struct student
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
        struct birth birthday;
    };

void main(){
 struct student stu1;

The structure variable birthday of type struct birth is nested inside struct student. It is quite apparent you cannot nest a structure variable of type struct student inside struct student.

Note that the structure to be nested has to be declared first. Using ., we can access the members contained within the inner structure as well as other members.

 /* Example */
stu1.birthday.date
stu1.birthday.month
stu1.birthday.year
stu1.name

Structure variables of different types can be nested as well.

struct birth
    {
       int date;
       int month;
       int year;
    };

struct relation
    {
        char fathersName[20];
        char mothersName[20];
    };

struct student
    {
        char name[20];
        int roll;
        char gender;
        int marks[5];
        struct birth birthday;
        struct relation parents; 
    };

In the second one, we will discuss the memory allocation of structure and their relationship with pointers and functions.

Pointers In C - Structure and Pointer to Pointer

Srijan — Thu, 13 Aug 2020 06:34:42 +0000

Pointers are arguably the most difficult feature of C to understand. But, it is one of the features which make C an excellent language.

Topics-

0. Pointer to Structure
1. Array Of Structure
2. Pointer to Structure as an Argument
3. Pointer to Pointer

0. Pointer to Structure

Like integer pointers, array pointers and function pointers, we have pointer to structures or structure pointers as well.

struct records {
    char name[20];
    int roll;
    int marks[5];
    char gender;
};

struct records student = {"Alex", 43, {76, 98, 68, 87, 93}, 'M'};

struct records *ptrStudent = &student;

Here, we have declared a pointer ptrStudent of type struct records. We have assigned the address of student to ptrStudent.

ptrStudent stores the base address of student, which is the base address of the first member of the structure. Increment by 1 would increase the address by sizeof(student) bytes.

printf("Address of structure = %d\n", ptrStudent);
printf("Adress of member `name` = %d\n", &student.name);
printf("Increment by 1 results in %d\n", ptrStudent + 1);

/* Output */
Address of structure = 6421984
Adress of member `name` = 6421984
Increment by 1 results in 6422032

We can access the members of student using ptrStudent in two ways. Using our old friend * or using -> ( infix or arrow operator).

With *, we will continue to use the .( dot operator) whereas with -> we won't need dot operator.

printf("Name w.o using ptrStudent : %s\n", student.name);
printf("Name using ptrStudent and * : %s\n", ( *ptrStudent).name);
printf("Name using ptrStudent and -> : %s\n", ptrStudent->name);

/* Output */
Name without using ptrStudent: Alex
Name using ptrStudent and *: Alex
Name using ptrStudent and ->: Alex

Similarly, we can access and modify other members as well. Note that the brackets are necessary while using * since the dot operator(.) has higher precedence over *.

1. Array Of Structure

We can create an array of type struct records and use a pointer to access the elements and their members.

struct records students[10];

 /* Pointer to the first element ( structure) of the array */
struct records *ptrStudents1 = &students;

 /* Pointer to an array of 10 struct records */
struct records (*ptrStudents2)[10] = &students;

Note that ptrStudent1 is a pointer to student[0] whereas ptrStudent2 is a pointer to the whole array of 10 struct records. Adding 1 to ptrStudent1 would point to student[1].

We can use ptrStudent1 with a loop to traverse through the elements and their members.


for( int i = 0; i <  10; i++)
printf("%s, %d\n", ( ptrStudents1 + i)->name, ( ptrStudents1 + i)->roll);

2. Pointer to Structure as an Argument

We can also pass the address of a structure variable to a function.

#include <stdio.h>

struct records {
    char name[20];
    int roll;
    int marks[5];
    char gender;
};

main(){
 struct records students = {"Alex", 43, {76, 98, 68, 87, 93}, 
'M'};
 printRecords(&students);
}

void printRecords( struct records *ptr){
  printf("Name: %s\n", ptr->name);
  printf("Roll: %d\n", ptr->roll);
  printf("Gender: %c\n", ptr->gender);
  for( int i = 0; i < 5; i++)
   printf("Marks in %dth subject: %d\n", i, ptr->marks[i]);
}

 /* Output */
Name: Alex
Roll: 43
Gender: M
Marks in 0th subject: 76
Marks in 1th subject: 98
Marks in 2th subject: 68
Marks in 3th subject: 87
Marks in 4th subject: 93

Note that the structure struct records is declared outside main(). This is to ensure that it is available globally and printRecords() can use it.

If the structure is defined inside main(), its scope will be limited to main(). Also structure must be declared before the function declaration as well.

Like structures, we can have pointers to unions and can access members using the arrow operator (->).

3. Pointer to Pointer

So far we have looked at pointer to various primitive data types, arrays, strings, functions, structures and unions.

The automatic question that comes to the mind is - what about pointer to pointer?

Well, good news for you! They too exist.

int var = 6;
int *ptr_var = &var;

printf("Address of var = %d\n", ptr_var);
printf("Address of ptr_var = %d\n", &ptr_var);

/* Output */
Address of var = 6422036
Address of ptr_var = 6422024

To store the address of int variable var, we have the pointer to int ptr_var. We would need another pointer to store the address of ptr_var.

Since ptr_var is of type int *, to store its address, we would have to create a pointer to int *. The code below shows how this can be done.

int * *ptr_ptrvar = &ptr_var; /* or int* *ppvar or int **ppvar */

We can use ptr_ptrvar to access the address of ptr_var and use double dereferencing to access var.

printf("Address of ptr_var = %d\n", ptr_ptrvar);
printf("Address of var = %d\n", *ptr_ptrvar);
printf("Value at var = %d\n", *(*ptr_ptrvar));

/* Output */
Address of ptr_var = 6422024
Address of var = 6422036
Value at var = 6

It is not required to use brackets when dereferencing ptr_ptrvar. But it is a good practice to use them. We can create another pointer ptr_ptrptrvar, which will store the address of ptr_ptrvar.

Since ptr_ptrvar is of type int**, the declaration for ptr_ptrptrvar will be

int** *ptr_ptrptrvar = &ptr_ptrvar;

We can again access ptr_ptrvar, ptr_var and var using ptr_ptrptrvar.

printf("Address of ptr_ptrvar = %d\n", ptr_ptrptrvar);
printf("Value at ptr_ptrvar = %d\n",*ptr_ptrptrvar);
printf("Address of ptr_var = %d\n", *ptr_ptrptrvar);
printf("Value at ptr_var = %d\n", *(*ptr_ptrptrvar));
printf("Address of var = %d\n", *(*ptr_ptrptrvar));
printf("Value at var = %d\n", *(*(*ptr_ptrptrvar)));

/* Output */
Address of ptr_ptrvar = 6422016
Value at ptr_ptrvar = 6422024
Address of ptr_var = 6422024
Value at ptr_var = 6422036
Address of var = 6422036
Value at var = 6

If we change the value at any of the pointer(s) using ptr_ptrptrvar or ptr_ptrvar, the pointer(s) will stop pointing to the variable.

In this series of 4 articles, I tried to cover as much as possible about pointers. We covered pointer notation, definition, types and arithmetic. That was followed by its uses with arrays, strings and functions. Finally, we talked about structures and pointers itself! A full circle, isn't it?

But, pointers aren't something that can be encapsulated in just 4 articles. One can further look into dynamic memory allocation and other such topics, to learn more about pointers and its use cases.

Stay home and stay safe!!!

Pointers In C - Functions

Srijan — Thu, 06 Aug 2020 10:07:13 +0000

Pointers are arguably the most difficult feature of C to understand. But, it is one of the features which make C an excellent language. This is the third article in the series. You can read the second one here.

Topics -

0. Call by Value v/s Call by Reference
1. Pointers as Function Arguments
2. Pointers as Function Return
3. Pointer to Function
4. Array Of Pointers to Functions
5. Pointer to Function as an Argument

0. Call by Value v/s Call by Reference

Have a look at the program below.

#include <stdio.h>

int multiply(int x, int y){
  int z;
  z = x * y;
  return z;
}

main(){
int x = 3, y = 5; 
int product = multiply(x,y);
printf("Product = %d\n", product);
 /* prints "Product = 15" */
}

The function multiply() takes two int arguments and returns their product as int. In the function call multiply(x,y), we passed the value of x and y ( of main()), which are actual arguments, to multiply().

The values of the actual arguments are passed or copied to the formal arguments x and y ( of multiply()). The x and y of multiply() are different from those of main(). This can be verified by printing their addresses.

#include <stdio.h>

int multiply(int x, int y){
  printf("Address of x in multiply() = %d\n", &x);
  printf("Address of y in multiply() = %d\n", &y);
  int z;
  z = x * y;
  return z;
}

main(){
int x = 3, y = 5;
printf("Address of x in main() = %d\n", &x);
printf("Address of y in main() = %d\n", &y);
int product = multiply(x,y);
printf("Product = %d\n", product);
}

/* Output */
Address of x in main() = 6422040
Address of y in main() = 6422036
Address of x in multiply() = 6422000
Address of y in multiply() = 6422008
Product = 15

Since we created stored values in a new location, it costs us memory. Wouldn't it be better if we could perform the same task without wasting space?

Call by reference helps us achieve this. We pass the address of or the reference of the variables to the function which does not create a copy. Using the dereferencing operator *, we can access the value stored at those addresses.

We can rewrite the above program using call by reference as well.

#include <stdio.h>

int multiply(int *x, int *y){
  int z;
  z = (*x) * (*y);
  return z;
}

main(){
int x = 3, y = 5; 
int product = multiply(&x,&y);
printf("Product = %d\n", product);
 /* prints "Product = 15" */
}

1. Pointers as Function Arguments

In this section, we will look at various programs where we give int, char, arrays and strings as arguments using pointers.

#include <stdio.h>

void add(float *a, float *b){
 float c = *a + *b;
 printf("Addition gives %.2f\n",c);
}

void subtract(float *a, float *b){
 float c = *a - *b;
 printf("Subtraction gives %.2f\n",c);
}

void multiply(float *a, float *b){
 float c = *a * *b;
 printf("Multiplication gives %.2f\n",c);
}

void divide(float *a, float *b){
 float c = *a / *b;
 printf("Division gives %.2f\n",c);
}

main(){
    printf("Enter two numbers :\n");
    float a,b;
    scanf("%f %f",&a,&b);
    printf("What do you want to do with the numbers?\nAdd : a\nSubtract : s\nMultiply : m\nDivide : d\n");
    char operation = '0';
    scanf(" %c",&operation);
    printf("\nOperating...\n\n");
    switch (operation) {
    case 'a':
        add(&a,&b);
        break;
    case 's':
        subtract(&a,&b);
        break;
    case 'm':
        multiply(&a,&b);
        break;
    case 'd':
        divide(&a,&b);
        break;
    default:
        printf("Invalid input!!!\n");

  }

}

We created four functions, add(), subtract(), multiply() and divide() to perform arithmetic operations on the two numbers a and b. The address of a and b was passed to the functions. Inside the function using * we accessed the values and printed the result.

Similarly, we can give arrays as arguments using pointer to its first element.

#include <stdio.h>

void greatestOfAll( int *p){
 int max = *p;
 for(int i=0; i < 5; i++){
    if(*(p+i) > max)
        max = *(p+i);
 }
 printf("The largest element is %d\n",max);
 }
main(){
  int myNumbers[5] = { 34, 65, -456, 0, 3455};
  greatestOfAll(myNumbers);
   /* Prints :The largest element is 3455" */
}

Since the name of an array itself is a pointer to the first element, we send that as an argument to the function greatestOfAll(). In the function, we traverse through the array using loop and pointer.

#include <stdio.h>
#include <string.h>

void wish(char *p){
 printf("Have a nice day, %s",p);
}

main(){
 printf("Enter your name : \n");
 char name[20];
 gets(name);
 wish(name);
}

Here, we pass in the string name to wish() using a pointer and print the message.

2. Pointers as Function Return

#include <stdio.h>

int* multiply(int *a, int *b){
 int c = *a * *b;
 return &c;
}

main(){
int a= 3, b = 5;
int *c = multiply (&a,&b);
printf("Product = %d",*c);
}

The function multiply() takes two pointers to int. It returns a pointer to int as well which stores the address where the product is stored.

It is very easy to think that the output would be 15. But it is not!!!

When multiply() is called, the execution of main() pauses and memory is now allocated for execution of multiply(). After its execution is completed, the memory allocated to multiply() is deallocated.

Therefore, though c ( local to main()) stores the address of the product. The data there is not guaranteed since that memory has been deallocated.

So does that mean pointers cannot be returned by a function? No!!!

We can do two things. Either store the address in the heap or global section or declare the variable to be static so that their values persist.

Static variables can simply be created by using keyword static before data type while declaring the variable.

To store addresses in heap, we can use library functions malloc() and calloc() which allocate memory dynamically. The following programs will explain both the methods.

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

/* Using malloc() */

int* multiply(int *a, int *b){
 int *c = malloc(sizeof(int));
 *c = *a * *b;
 return c;
}

main(){
int a= 3, b = 5;
int *c = multiply (&a,&b);
printf("Product = %d",*c);
}

/* Using static keyword */
#include <stdio.h>

int* multiply(int *a, int *b){
 static int c;
 c = *a * *b;
 return &c;
}

main(){
int a= 3, b = 5;
int *c = multiply (&a,&b);
printf("Product = %d",*c);
}

Both methods return the output as 15.

3. Pointer to Function

Like pointer to different data types, we also have a pointer to function as well. A pointer to function or function pointer stores the address of the function. Though it doesn't point to any data. It points to the first instruction in the function.

The syntax for declaring a pointer to function is -

 /* Declaring a function */
returnType functionName(parameterType1, pparameterType2, ...);

 /* Declaring a pointer to function */
returnType (*pointerName)(parameterType1, parameterType2, ...);
pointerName = &functionName; /* or pointerName = functionName; */

The below example will show how you can use it.

int* multiply(int *a, int *b)
{
    int *c = malloc(sizeof(int));
    *c = *a * *b;
    return c;
}

main()
{ 
    int a=3,b=5;
    int* (*p)(int*, int*) = &multiply; /* or int* (*p)(int*, int*) = multiply; */
    int *c = (*p)(&a,&b); /* or int *c = p(&a,&b); */
    printf("Product = %d",*c);
}

The declaration for the pointer p to function multiply() can be read as ( following operator precedence) - p is a pointer to function with two integer pointers ( or two pointers to int) as parameters and returning a pointer to int.

Since the name of the function is also a pointer to the function, the use of & is not necessary. Also removing * from the function call doesn't affect the program.

4. Array of Pointers to Functions

We have already seen how to create an array of pointers to int, char etc. Similarly, we can create an array of pointers to function.

In this array, every element will store an address of a function, where all the functions are of the same type. That is, they have the same type and no. of parameters and return types.

We will modify the program discussed here. We will store the addresses of add(), subtract(), multiply() and divide() in an array make a function call through subscipts.

#include <stdio.h>

void add(float *a, float *b){
 float c = *a + *b;
 printf("Addition gives %.2f\n",c);
}

void subtract(float *a, float *b){
 float c = *a - *b;
 printf("Subtraction gives %.2f\n",c);
}

void multiply(float *a, float *b){
 float c = *a * *b;
 printf("Multiplication gives %.2f\n",c);
}

void divide(float *a, float *b){
 float c = *a / *b;
 printf("Division gives %.2f\n",c);
}

main(){
    printf("Enter two numbers :\n");
    float a,b;
    scanf("%f %f",&a,&b);
    printf("What do you want to do with the numbers?\nAdd : a\nSubtract : s\nMultiply : m\nDivide : d\n");
    char operation = '0';
    scanf(" %c",&operation);
    void (*p[])(float* , float*) = {add,subtract,multiply,divide};
    printf("\nOperating...\n\n");
    switch (operation) {
    case 'a':
        p[0](&a,&b);
        break;
    case 's':
        p[1](&a,&b);
        break;
    case 'm':
        p[2](&a,&b);
        break;
    case 'd':
        p[3](&a,&b);
        break;
    default:
        printf("Invalid input!!!\n");

  }

}

The declaration here can be read as - p is an array of pointer to functions with two float pointers as parameters and returning void.

5. Pointer to Function as an Argument

Like any other pointer, function pointers can also be passed to another function, therefore known as callback function or called function. The function to which it is passed is known as calling function.

A better way to understand would be to look at qsort(), which is an inbuilt function in C. It is used to sort an array of integers, strings, structures, etc. The declaration for qsort() is -

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *));

qsort() takes four arguments -

a void pointer to the start of an array
no. of elements
size of each element
a function pointer that takes in two void pointers as arguments and returns an int

The function pointer points to a comparison function that returns an integer that is greater than, equal to or less than zero, if the first argument is respectively greater than, equal to or less than the second argument.

The following program showcases its usage.

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

int compareIntegers(const void *a, const void *b)
{
  const int *x = a;
  const int *y = b;
  return *x - *y;
}

main(){

  int myArray[] = {97,59,2,83,19,97};
  int numberOfElements = sizeof(myArray) / sizeof(int);

  printf("Before sorting - \n");
  for(int i = 0; i < numberOfElements; i++)
   printf("%d ", *(myArray + i));

  qsort(myArray, numberOfElements, sizeof(int), compareIntegers);

  printf("\n\nAfter sorting - \n");
  for(int i = 0; i < numberOfElements; i++)
   printf("%d ", *(myArray + i));
 }

/* Output */

Before sorting -
97 59 2 83 19 97

After sorting -
2 19 59 83 97 97

Since a function name is itself a pointer, we can write compareIntegers as the fourth argument.

In this article, we saw the various use cases of pointers with functions. How pointers can be both arguments as well as return, albeit with a bit of caution in latter. We also extended our idea about pointers being used with functions to function pointers and how they are used in C.

The edits suggested by @pentacular have been included. Thanks to him/her.

Pointers In C - Arrays and Strings

Srijan — Thu, 30 Jul 2020 09:49:08 +0000

Pointers are arguably the most difficult feature of C to understand. But, it is one of the features which make C an excellent language. This is the second article in the series. You can read the first one here.

Topics -

0. Why pointers and arrays?
1. 1-D Arrays
2. 2-D Arrays
3. Strings
4. Array of Pointers
5. Pointer to Array

0. Why pointers and arrays?

In C, pointers and arrays have quite a strong relationship. The reason they should be discussed together is what you can achieve with array notation ( arrayName[index]) can also be achieved with pointers, generally faster.

1. 1-D Arrays

Let us look at what happens when we write int myArray[5];.

Five consecutive blocks of memory starting from myArray[0] to myArray[4] are created with garbage values in them. Each of the blocks is of size 4 bytes.

Thus, if the address of myArray[0] is 100 (say), the address of the rest of the blocks would be 104, 108, 112, and 116.

Now, have a look at the following code -

int prime[5] = {2,3,5,7,11};
printf("Result using &prime = %d\n",&prime);
printf("Result using prime = %d\n",prime);
printf("Result using &prime[0] = %d\n",&prime[0]);

/* Output */
Result using &prime = 6422016
Result using prime = 6422016
Result using &prime[0] = 6422016

So, &prime, prime, and &prime[0] all give the same address, right? Well, wait and read because you are in for a surprise (and confusion). Let's try to increment each of &prime, prime, and &prime[0] by 1.

printf("Result using &prime = %d\n",&prime + 1);
printf("Result using prime = %d\n",prime + 1);
printf("Result using &prime[0] = %d\n",&prime[0] + 1);

/* Output */
Result using &prime = 6422036
Result using prime = 6422020
Result using &prime[0] = 6422020

Wait! How come &prime + 1 results to something different than the other two? And why prime + 1 and &prime[0] + 1 are still equal? Let's answer these questions.

1.prime and &prime[0], both point to the 0th element of the array prime. Thus, name of an array is itself a pointer to the 0th element of the array.

Here, both point to the first element of size 4 bytes. When you add 1 to them, they now point to the 1st element in the array. Therefore an increase in the address by 4.

2.&prime on the other hand is a pointer to an int array of size 5. It stores the base address of the array prime[5], which is equal to the address of the first element. However, increase by 1 to it results in an address with an increase of 5 x 4 = 20 bytes.

In short, arrayName and &arrayName[0] point to the 0th element whereas &arrayName points to the whole array.

We can access the array elements using subscripted variables like this -

int prime[5] = {2,3,5,7,11};
for( int i = 0; i < 5; i++)
{
  printf("index = %d, address = %d, value = %d\n", i, &prime[i], prime[i]);
}

We can do the same using pointers which are always faster than using subscripts.

int prime[5] = {2,3,5,7,11};
for( int i = 0; i < 5; i++)
{
  printf("index = %d, address = %d, value = %d\n", i, prime + i, *(prime + i));
}

Both methods give the output -

index = 0, address = 6422016, value = 2
index = 1, address = 6422020, value = 3
index = 2, address = 6422024, value = 5
index = 3, address = 6422028, value = 7
index = 4, address = 6422032, value = 11

Thus, &arrayName[i] and arrayName[i] are same as arrayName + i and *(arrayName + i) respectively.

2. 2-D Arrays

Two-dimensional arrays are an array of arrays.

int marks[5][3] = { { 98, 76, 89},
                    { 81, 96, 79},
                    { 88, 86, 89},
                    { 97, 94, 99},
                    { 92, 81, 59}
                  };

Here, marks can be thought of as an array of 5 elements, each of which is a one-dimensional array containing 3 integers. Let us work through a series of programs to understand different subscripted expressions.

printf("Address of whole 2-D array = %d\n", &marks);
printf("Addition of 1 results in %d\n", &marks +1);

/* Output */
Address of whole 2-D array = 6421984
Addition of 1 results in 6422044

Like 1-D arrays, &marks points to the whole 2-D array, marks[5][3]. Thus, increment to it by 1 ( = 5 arrays X 3 integers each X 4 bytes = 60) results in increment by 60 bytes.

printf("Address of 0th array = %d\n", marks);
printf("Addition of 1 results in %d\n", marks +1);
printf("Address of 0th array =%d\n", &marks[0]);
printf("Addition of 1 results in %d\n", &marks[0] + 1);

/* Output */
Address of 0th array = 6421984
Addition of 1 results in 6421996
Address of 0th array = 6421984
Addition of 1 results in 6421996

If marks was a 1-D array, marks and &marks[0] would have pointed to the 0th element. For a 2-D array, elements are now 1-D arrays. Hence, marks and &marks[0] point to the 0th array (element), and the addition of 1 point to the 1st array.

printf("Address of 0th element of 0th array = %d\n", marks[0]);
printf("Addition of 1 results in %d\n", marks[0] + 1);
printf("Address of 0th element of 1st array = %d\n", marks[1]);
printf("Addition of 1 results in %d\n", marks[1] + 1);

 /* Output */
Address of 0th element of 0th array = 6421984
Addition of 1 results in 6421988
Address of 0th element of 1st array = 6421996
Addition of 1 results in 6422000

And now, comes the difference. For a 1-D array, marks[0] would give the value of the 0th element. An increment by 1 would increase the value by 1.

But, in a 2-D array, marks[0] points to the 0th element of the 0th array. Similarly, marks[1] points to the 0th element of the 1st array. An increment by 1 would point to the 1st element in the 1st array.

printf("Value of 0th element of 0th array = %d\n", marks[0][0]);
printf("Addition of 1 results in %d", marks[0][0] + 1);

/* Output */
Value of 0th element of 0th array = 98
Addition of 1 results in 99

This is the new part. marks[i][j] gives the value of the jth element of the ith array. An increment to it changes the value stored at marks[i][j]. Now, let us try to write marks[i][j] in terms of pointers.

We know marks[i] + j would point to the ith element of the jth array from our previous discussion. Dereferencing it would mean the value at that address. Thus, marks[i][j] is equal to *(marks[i] + j).

From our discussion on 1-D arrays, marks[i] is the same as *(marks + i). Thus, marks[i][j] can be written as *(*(marks + i) + j) in terms of pointers.

Here is a summary of notations comparing 1-D and 2-D arrays.

Expression	1-D Array	2-D Array
`&ArrayName`	points to the address of whole array, adding 1 increases the address by `1 x sizeof(ArrayName)`	points to the address of whole array, adding 1 increases the address by `1 x sizeof(ArrayName)`
`ArrayName`	points to the `0th` element, adding 1 increases the address to `1st` element	points to the `0th` element (array), adding 1 increases the address to `1st` element (array)
`&ArrayName[i]`	points to the the `ith` element, adding 1 increases the address to `(i+1)th` element	points to the `ith` element (array), adding 1 increases the address to the `(i+1)th` element (array)
`ArrayName[i]`	gives the value of the `ith` element, adding 1 increases the value of the `ith` element	points to the `0th` element of the `ith` array, adding 1 increases the address to `1st` element of the `ith` array
`ArrayName[i][j]`	Nothing	gives the value of the `jth` element of the `ith` array, adding 1 increases the value of the `jth` element of the `ith` array
Pointer Expression To Access The Elements	`*(ArrayName + i)`	`((ArrayName + i) + j)`

3. Strings

A string is a one-dimensional array of characters terminated by a null(\0). When we write char name[] = "Srijan";, each character occupies one byte of memory with the last one always being \0.

Similar to the arrays we have seen, name and &name[0] points to the 0th character in the string, while &name points to the whole string. Also, name[i] can be written as *(name + i).

/* String */
char champions[] = "Liverpool";

printf("Pointer to whole string = %d\n", &champions);
printf("Addition of 1 results in %d\n", &champions + 1);

/* Output */
Address of whole string = 6421974
Addition of 1 results in 6421984

printf("Pointer to 0th character = %d\n", &champions[0]);
printf("Addition of 1 results in %d\n", &champions[0] + 1);

/* Output */
Address of 0th character = 6421974
Addition of 1 results in a pointer to 1st character 6421975

printf("Pointer to 0th character = %d\n", champions);
printf("Addition of 1 results in a pointer to 1st character %d\n", champions + 1);

/* Output */
Address of 0th character = 6421974
Addition of 1 results in 6421975

printf("Value of 4th character = %c\n", champions[4]);
printf("Value of 4th character using pointers = %c\n", *(champions + 4));

/* Output */
Value of 4th character = r
Value of 4th character using pointers = r

A two-dimensional array of characters or an array of strings can also be accessed and manipulated as discussed before.

/* Array of Strings */
char top[6][15] = {
                    "Liverpool",
                    "Man City",
                    "Man United",
                    "Chelsea",
                    "Leicester",
                    "Tottenham"
                  };

printf("Pointer to 2-D array = %d\n", &top);
printf("Addition of 1 results in %d\n", &top + 1);

 /* Output */
Pointer to 2-D array = 6421952
Addition of 1 results in 6422042

printf("Pointer to 0th string = %d\n", &top[0]);
printf("Addition of 1 results in %d\n", &top[0] + 1);

 /* Output */
Pointer to 0th string = 6421952
Addition of 1 results in 6421967

printf("Pointer to 0th string = %d\n", top);
printf("Addition of 1 results in %d\n", top + 1);

 /* Output */
Pointer to 0th string = 6421952
Addition of 1 results in 6421967

printf("Pointer to 0th element of 4th string = %d\n", top[4]);
printf("Pointer to 1st element of 4th string = %c\n", top[4] + 1);

 /* Output */
Pointer to 0th element of 4th string = 6422012
Pointer to 1st element of 4th string = 6422013

printf("Value of 1st character in 3rd string = %c\n", top[3][1]);
printf("Same using pointers = %c\n", *(*(top + 3) + 1));

 /* Output */
Value of 1st character in 3rd string = h
Same using pointers = h

4. Array of Pointers

Like an array of ints and an array of chars, there is an array of pointers as well. Such an array would simply be a collection of addresses. Those addresses could point to individual variables or another array as well.

The syntax for declaring a pointer array is -

dataType *variableName[size];

/* Examples */
int *example1[5];
char *example2[8];

Following operators precedence, the first example can be read as - example1 is an array([]) of 5 pointers to int. Similarly, example2 is an array of 8 pointers to char.

We can store the two-dimensional array to string top using pointer array and save memory as well.

char *top[] = {
                    "Liverpool",
                    "Man City",
                    "Man United",
                    "Chelsea",
                    "Leicester",
                    "Tottenham"
                  };

top will be containing the base addresses of all the respective names. The base address of "Liverpool" will be stored in top[0], "Man City" in top[1], and so on.

In the earlier declaration, we required 90 bytes to store the names. Here, we only require ( 58 (sum of bytes of names) + 12 ( bytes required to store the address in the array) ) 70 bytes.

The manipulation of strings or integers becomes a lot easier when using an array of pointers.

If we try to put "Leicester" ahead of "Chelsea", we just need to switch the values of top[3] and top[4] like below -

char *temporary;
temporary = top[3];
top[3] = top[4];
top[4] = temporary;

Without pointers, we would have required to exchange every character of the strings, which would have taken more time. That's why strings are generally declared using pointers.

5. Pointer to Array

Like "pointer to int" or "pointer to char", we have pointer to array as well. This pointer points to whole array rather than its elements.

Remember we discussed how &arrayName points to the whole array? Well, it is a pointer to array.

A pointer to array can be declared like -

dataType (*variableName)[size];

/* Examples */
int (*ptr1)[5];
char (*ptr2)[15];

Notice the parentheses. Without them, these would be an array of pointers. The first example can be read as - ptr1 is a pointer to an array of 5 int(integers).

int goals[] = { 85,102,66,69,67};
int (*pointerToGoals)[5] = &goals;
printf("Address stored in pointerToGoals %d\n", pointerToGoals);
printf("Dereferncing it, we get %d\n",*pointerToGoals);

/* Output */
Address stored in pointerToGoals 6422016
Dereferencing it, we get 6422016

When we dereference a pointer, it gives the value at that address. Similarly, by dereferencing a pointer to array, we get the array and the name of the array points to the base address. We can confirm that *pointerToGoals gives the array goals if we find its size.

printf("Size of goals[5] = %d, *pointerToGoals);

/* Output */
Size of goals[5] = 20

If we dereference it again, we will get the value stored in that address. We can print all the elements using pointerToGoals.

for(int i = 0; i < 5; i++)
printf("%d ", *(*pointerToGoals + i));

/* Output */
85 102 66 69 67

Pointers and pointer to arrays are quite useful when paired up with functions. We will discuss them in the next one.

Pointers In C - Definition, Notation, Types and Arithmetic

Srijan — Thu, 23 Jul 2020 08:19:30 +0000

Pointers are arguably the most difficult feature of C to understand. But, it is one of the features which make C an excellent language. In a series of articles, we will take a closer look at pointers and how they can be used in C programming.

Topics -

0. What exactly are pointers?
1. Pointer Notation and Definition
2. Some Special Pointers
3. Pointer Arithmetic

0. What exactly are pointers?

Before we go to the definition of pointers, let us understand what happens when we write

int digit = 42;

A block of memory is reserved by the compiler to hold an int value. The name of this block is digit and the value stored in this block is 42. Now, to remember the block, it is assigned with an address or a location number(say, 24650).

The value of the location number is not important for us, as it is a random value. However, we can access this address using & (ampersand) or address of operator like below.

printf("The address of digit = %d.",&digit);
 /* prints "The address of digit = 24650. */

Now, we can get the value of the variable digit from its address using another operator * (asterisk), called indirection or dereferencing or value at address operator.

printf("The value of digit = %d.", *(&digit);
 /* prints "The value of digit = 42. */

1. Pointer Definition and Notation

The address of digit can be stored in another variable known as a pointer variable. The syntax for storing a variable's address to a pointer is :

dataType *pointerVariableName = &variableName;

For our digit variable, this can be written as :

int *addressOfDigit = &digit;

int *addressOfDigit;
addressOfDigit= &digit;

This can be read as - A pointer to int (integer) addressOfDigit stores the address of(&) digit variable.

Few points to understand -

1.dataType - We need to tell the computer what is the data type of the variable whose address we are going to store. Here, int was the data type of digit.

It does not mean that addressOfDigit will store a value of type int.

An integer pointer (like addressOfDigit) can only store the address of variables of integer type.

int variable1;
int variable2;
char variable3;
int *addressOfVariables;

Here, we can assign the address of variable1 and variable2 to the integer pointer addressOfVariables but not to variable3 since it is of type char. We will need a character pointer variable to store its address.

2.* - A pointer variable is a special variable in the sense that it is used to store an address of another variable. To differentiate it from other variables that do not store address, we use *, as a symbol in the declaration.

Now, we can use our addressOfDigit pointer variable to print the address and the value of digit as below :

printf("The address of digit = %d.", addressOfDigit);
 /* prints "The address of digit = 24650." */
printf("The value of digit = %d.", *addressOfDigit);
 /*prints "The value of digit = 42. */

Here, *addressOfDigit is to be read as the value at the address stored in addressOfDigit.

Notice, we used %d as the format identifier for addressOfDigit. Well, this not completely correct. The correct identifier to be used would be %p.

Using %p, the address is displayed in hexadecimal value. But the memory address can be displayed in integers as well as octal values. Still, since it is not an entirely correct way, a warning is shown.

int num = 5;
int *p = &num;
printf("Address using %%p = %p",p);
printf("Address using %%d = %d",p);
printf("Address using %%o = %o",p);

The output according to compiler I'm using is -

Address using %p = 000000000061FE00
Address using %d = 6422016
Address using %o = 30377000

This is the warning shown when you use %d -

warning: format '%d' expects argument of type 'int', but argument 2 has type 'int *'

2. Some Special Pointers

1. Wild Pointer

char *alphabetAddress; /* uninitialised or wild pointer */
char alphabet = "a";
alphabetAddress = &alphabet; /* now, not a wild pointer */

When we defined our character pointer alphabetAddress, we did not initialize it. Such pointers are known as wild pointers. They store a garbage value i.e. memory address of a byte that we don't know is reserved or not (remember int digit = 42;, we reserved a memory address when we declared it).

Suppose we dereference a wild pointer and assign a value to the memory address it is pointing at. This will lead to unexpected behaviour since we will write data at a memory block that may be free or reserved.

2. Null Pointer

Now, to ensure we do not have a wild pointer, we can initialize a pointer with a NULL value, making it a null pointer.

char *alphabetAddress = NULL /* Null pointer */

A null pointer points at nothing, or at a memory address that users can not access.

3. Void Pointer

A void pointer can be used to point at a variable of any data type. It can be reused to point at any data type we want to. It is declared as

void *pointerVariableName = NULL;

Since they are very general in nature, they are also known as generic pointers.

With their flexibility, void pointers also bring some constraints. Void pointers cannot be dereferenced as any other pointer. Appropriate typecasting is necessary.

void *pointer = NULL;
int number = 54;
char alphabet = "z";
pointer = &number;
printf("The value of number = ", *pointer); /* Compilation Error */
/* Correct Method */
printf("The value of number = ", *(int *)pointer); /* prints "The value at number = 54" */
pointer = &alphabet;
printf("The value of alphabet = ", *pointer); /* Compilation Error */
printf("The value of alphabet = ", *(char *)pointer); /* prints "The value at alphabet = z */

Similarly, void pointers need to be typecasted for performing arithmetic operations.

Void pointers are of great use in C. Library functions malloc() and calloc() which dynamically allocate memory, return void pointers. qsort(), an inbuilt sorting function in C, has a function as its argument which itself takes void pointers as its argument.

4. Dangling Pointer

A dangling pointer points to a memory address which used to hold a variable. Since the address it points at is no longer reserved, using it will lead to unexpected results.

main(){
  int *ptr;
  ptr = (int *)malloc(sizeof(int));
  *ptr = 1;
  printf("%d",*ptr); /* prints 1 */
  free(ptr); /* deallocation */
  *ptr = 5;
  printf("%d",*ptr); /* may or may not print 5 */
}

Though the memory has been deallocated by free(ptr), the pointer to integer ptr still points to that unreserved memory address.

3. Pointer Arithmetic

We know by now that pointers are not like any other variable. They do not store any value but the address of memory blocks. Hence, it is quite clear that not all arithmetic operations would be valid with them. Would multiplying or dividing two pointers (having address) make sense?

Pointers have few but immensely useful valid operations -

1.you can assign the value of one pointer to another only if they are of the same type (unless typecasted or one of them being void *.

int ManU = 1;
int *addressOfManU = &ManU;
int *anotherAddressOfManU = NULL;
anotherAddressOfManU = addressOfManU; /* Valid */
double *wrongAddressOfManU = addressOfManU; /* Invalid */

2.you can only add or subtract integers to pointers.

int myArray = {3,6,9,12,15};
int *pointerToMyArray = &myArray[0];
pointerToMyArray += 3; /* Valid */
pointerToMyArray *= 3; /* Invalid */

When you add (or subtract) an integer (say n) to a pointer, you are not actually adding (or subtracting) the integer literally. You are adding (or subtracting) n-times the size of the data type of the variable the pointer is pointing to.

int number = 5;
 /* Suppose the address of number is 100 */
int *ptr = &number;
int newAddress = ptr + 3;
 /* Same as ptr + 3 * sizeof(int) */

The value stored in newAddress will not be 103, rather 112.

3.subtraction and comparison of pointers is valid only if both are members of the same array.

int myArray = {3,6,9,12,15};
int sixthMultiple = 18;
int *pointer1 = &myArray[0];
int *pointer2 = &myArray[1];
int *pointer6 = &sixthMuliple;
 /* Valid Expressions */
if(pointer1 == pointer2)
pointer2 - pointer1;
 /* Invalid Expressions
if(pointer1 == pointer6)
pointer2 - pointer6

The subtraction of pointers results in the number of elements separating them.

4.you can assign or compare a pointer with NULL.

The only exception to above rules is that the address of the first memory block after the last element of an array follows pointer arithmetic.

Pointer and arrays exist together. There is a reason why the most valid manipulations of pointers can only be done with arrays. We will discuss the above rules with arrays in the next article.

P.S. - Try to find what will be the value stored in pointerToMyArray for valid operations in 1 and 2, if the address of myArray[0] is 100.

The edits suggested by @pentacular have been included. Thanks to him/her.