Unit 3 Advanced Concepts of C Programming:

Note:

This material is for introductory reading. You may refer text book for more detail part.

Be prepared with Lab work (Programs). It is practical example of each topic from syllabus.

C Pointers:

A pointer is a derived data type in C. It is built from the one of the fundamental data types available in the
C. Pointer contain memory address as their values. Memory addresses are the locations in computer
memory where program instructions and data are stored. So, we can use pointers to access and manipulate
data stored in memory.

There are 2 important operators that we will use in pointers concepts i.e.

 Dereferencing operator (*) used to declare pointer variable and access the value stored in the
address.

 Address operator (&) used to returns the address of a variable or to access the address of a
variable to a pointer.

BENEFITS OF POINTERS:

1. Pointers are more efficient in handling arrays and data tables.

2. Pointers can be used to return multiple values from a function through function arguments.

3. Pointers allow references to functions. So we can pass function as argument to other function.

4. We can save data storage space in memory by using pointer arrays to character strings.

5. Pointers allow C to support dynamic memory management.

6. Pointer is an efficient tool to manipulate dynamic data structure such as structures, linked lists, queues,
stacks and trees.

7. Pointers reduce length and complexity of programs.

8. Pointers increase execution speed and reduce execution time.

Important Points:

 %p format specifier is used to print the address stored in pointer variables.

 Printing a pointer with %d format specifier may result in a warning or undefined behavior
because the size of a pointer (usually 4 or 8 bytes) may not match that of an integer.
  Note: 8 bytes for a 64-bit System 4 bytes for a 32-bit System.

 The memory address format will always be in hexadecimal format (starting with 0x).

 C does not use the term “reference” explicitly (unlike C++), “referencing” in C usually refers to
obtaining the address of a variable using the address operator (&).

 Pointers are essential for dynamic memory allocation, providing control over memory usage with
functions like malloc, calloc, and free.

Pointer Declaration:
To declare a pointer, use the dereferencing operator (*) followed by the data type.

Syntax:

The general form of a pointer variable declaration is –

type *var-name;

Example of Valid Pointer Variable Declarations:

int *ip; /* pointer to an integer */

double *dp; /* pointer to a double */

float *fp; /* pointer to a float */

char *ch; /* pointer to a character */

Pointer Initialization:
After declaring a pointer variable, you need to initialize it with the address of another variable using
the address of (&) operator. This process is known as referencing a pointer.

Syntax:

The following is the syntax to initialize a pointer variable –

pointer_variable = &variable;

Example:

Here is an example of pointer initialization –

int Var = 10;

int *ptr = &Var;

Example:

#include <stdio.h>

int main() {

int Var = 10;

int * ptr = &Var; // Pointer declaration and initialization

printf("Value of Var = %d\n", *ptr); // Printing the current value

printf("Address of Var = %p\n", ptr);

* ptr = 20; // Changing the value

printf("Value of Var = %d\n", *ptr); // Printing the updated value

printf("Address of Var = %p\n", &Var);

return 0; }

Pointer Arithmetic in C:

Pointer Arithmetic is the set of valid arithmetic operations that can be performed on pointers.
The pointer variables store the memory address of another variable. It doesn‟t store any value.

1. Increment/Decrement of a Pointer

2. Addition of integer to a pointer

3. Subtraction of integer to a pointer

4. Subtracting two pointers of the same type

5. Comparison of pointers

1. Increment/Decrement of a Pointer:

Increment: It is a condition that also comes under addition. When a pointer is incremented, it actually
increments by the number equal to the size of the data type for which it is a pointer.
For Example:
If an integer pointer that stores address 1000 is incremented, then it will increment by 4(size of an int),
and the new address will point to 1004. While if a float type pointer is incremented then it will increment
by 4 (size of a float) and the new address will be 1004.

#include <stdio.h>

int main(){

int x = 10;

int *y = &x;

printf("Value of y before increment: %u\n", y);

y++;

printf("Value of y after increment: %u", y);

}
Decrement: It is a condition that also comes under subtraction. When a pointer is decremented, it actually
decrements by the number equal to the size of the data type for which it is a pointer.

For Example:

If an integer pointer that stores address 1000 is decremented, then it will decrement by 4(size of an int),
and the new address will point to 996. While if a float type pointer is decremented then it will decrement
by 4(size of a float) and the new address will be 996.

Note: It is assumed here that the architecture is 64-bit and all the data types are sized accordingly. For
example, integer is of 4 bytes.

2. Addition of Integer to Pointer

When a pointer is added with an integer value, the value is first multiplied by the size of the data type and
then added to the pointer.
new_address = current_address + i * size_of(data type)

For Example:
Consider the same example as above where the ptr is an integer pointer that stores 1000 as an address. If
we add integer 5 to it using the expression, ptr = ptr + 5, then, the final address stored in the ptr will
be ptr = 1000 + sizeof(int) * 5 = 1020.

#include <stdio.h>

int main(){

int x = 10;

int *y = &x;

printf("Value of y before increment: %u\n", y);

y = y+ 4;

printf("Value of y after increment: %u", y);

3. Subtraction of Integer to Pointer:

When a pointer is subtracted with an integer value, the value is first multiplied by the size of the data type
and then subtracted from the pointer similar to addition.

new_address = current_address - i * size_of(data type)

For Example:
Consider the same example as above where the ptr is an integer pointer that stores 1000 as an address. If
we subtract integer 5 from it using the expression, ptr = ptr – 5, then, the final address stored in the ptr
will be ptr = 1000 – sizeof(int) * 5 = 980.
#include <stdio.h>

int main(){

int x = 10;

int *y = &x;

printf("Value of y before increment: %u\n", y);

y = y -2;

printf("Value of y after increment: %u", y);

4. Subtraction of Two Pointers:

The subtraction of two pointers is possible only when they have the same data type. The result is
generated by calculating the difference between the addresses of the two pointers.

 0 if both pointers refer same address mean same variable.

 1 if first pointer allocated after second.

 -1 if first pointer allocated before second.

Example:

#include <stdio.h>

int main(){

int x = 10, y=5,diff;

int *ptr1 = &x;

int *ptr2 = &y;

printf("ptr1: %u \nptr2: %u\n", ptr1,ptr2);

diff = ptr1- ptr2;

printf("Difference: %u", diff);

return 0;

5. Comparison of Pointers:

We can compare the two pointers by using the comparison operators in C. We can implement this by
using all operators in C >, >=, <, <=, ==, !=. It returns true for the valid condition and returns false for
the unsatisfied condition.

1. Step 1: Initialize the integer values and point these integer values to the pointer.

2. Step 2: Now, check the condition by using comparison or relational operators on pointer
variables.

3. Step 3: Display the output.

// C Program to illustrare pointer comparision

#include <stdio.h>

int main()

// declaring array

int arr[5];

// declaring pointer to array name

int* ptr1 = arr;

// declaring pointer to first element

int* ptr2 = &arr[0];

if (ptr1 == ptr2) {

printf("Pointer to Array Name and First Element are Equal.");

else {

printf("Pointer to Array Name and First Elementare not Equal.");

return 0;

}
Output:

Pointer to Array Name and First Element are Equal.

Illegal arithmetic with pointers:

There are various operations which cannot be performed on pointers. Since, pointer stores address hence
we must ignore the operations which may lead to an illegal address, for example, addition, and
multiplication. A list of such operations is given below.

o Address + Address = illegal

o Address * Address = illegal

o Address % Address = illegal

o Address / Address = illegal

o Address & Address = illegal

o Address ^ Address = illegal

o Address | Address = illegal

o ~Address = illegal
* POINTERS AND ARRAYS (POINTERS TO ARRAYS)

ARRAY NAME AS A POINTER:

When an array is declared, the compiler allocates a base address and sufficient amount of storage to
contain all the elements of the array in continuous memory locations. The base address is the location of
the first element (index 0) of the array. The compiler also defines the array name as a constant pointer to
the first element. Suppose we declare an array x as follows:

int [x] = {1, 2, 3, 4, 5};

Suppose the base address of x is1000 and assuming that each integer requires two bytes, the five elements
will be stored as follows:

The name x is defined as a constant pointer pointing to the first element, x [0] and therefore the value of x
is 1000, the location where x [0] is stored. That is,

x = &x [0] =1000

If we declare p as an integer pointer, then we can make the pointer p to point to the array x by the
following assignment:

p=x;

This is equivalent to p = &x [0];

Now we can access every value of x using p++ to move from one element to another.

The relationship between p and x is shown as:

p= &x [0] (=1000) p+3=&x [3] (=1006)

p+1=&x [1] (=1002) p+4=&x [4] (=1008)

p+2=&x [2] (=1004)

Address of an element is calculated using its index and the scale factor of the data type.

For instance,

Address of x [3] = base address + (3 x scale factor of int)

=1000 + (3 x 2)

When handling arrays, instead of using array indexing, we can use pointers to access array elements.
Note that *(p+3) gives the value of x [3].

The pointer accessing method is much faster than array indexing.

Example:

#include<stdio.h>

void main()

int x[5]={1,2,3,4,5};

int *p=x;

int i;

printf("printing array elements...\n");

for(i=0;i<5;i++)

printf("Address of x[%d] = %u and value = %d\n",i,(p+i), *(p+i));

Pointer to Pointer (Double Pointer):

In C, double pointers are those pointers which store the address of another pointer. The first pointer is
used to store the address of the variable, and the second pointer is used to store the address of the first
pointer. That is why they are also known as a pointer to pointer.

Syntax of Double Pointer:

type **name;

Initialization:

type **name = &single_ptr; // With declaration

Example:

#include<stdio.h>
intmain(){
// A variable
intvar=10;

// Pointer to int
int*ptr1=&var;

// Pointer to pointer (double pointer)

int**ptr2=&ptr1;

printf("var: %d\n",var);
printf("*ptr1: %d\n",*ptr1);
printf("**ptr2: %d",**ptr2);

return0;
}

Output:

var: 10
*ptr1: 10
**ptr2: 10

Dynamic memory allocation:

It can be defined as a procedure in which the size of a data structure (like Array) is changed during the
runtime.
C provides some functions to achieve these tasks. There are 4 library functions provided by C defined
under <stdlib.h> header file to facilitate dynamic memory allocation in C programming.

They are:

1. malloc()
2. calloc()

3. free()

4. realloc()

C malloc():

The “malloc” or “memory allocation” method in C is used to dynamically allocate a single large block of
memory with the specified size. It returns a pointer of type void which can be cast into a pointer of any
form. It doesn‟t initialize memory at execution time so that it has initialized each block with the default
garbage value initially.

Syntax of malloc() in C:

int *ptr;

ptr = (cast-type*) malloc(byte-size)

For Example:

ptr = (int*) malloc(100 * sizeof(int));

Since the size of int is 4 bytes, this statement will allocate 400 bytes of memory. And, the pointer ptr
holds the address of the first byte in the allocated memory.

If space is insufficient, allocation fails and returns a NULL pointer.

Example:

#include <stdio.h>

#include <stdlib.h>

int main()

int* ptr;

int n, i;

printf("Enter number of elements:");

 scanf("%d",&n);

printf("Entered number of elements: %d\n", n);

ptr = (int*)malloc(n * sizeof(int));

if (ptr == NULL) {

printf("Memory not allocated.\n");

exit(0);

else {

printf("Memory successfully allocated using malloc.\n");

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

ptr[i] = i + 1;

printf("The elements of the array are:\n");

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

printf("address = %u value=%d \n",(ptr+i), ptr[i]);

return 0;

Output:

Enter number of elements:3

Entered number of elements: 3

Memory successfully allocated using malloc.

The elements of the array are:

address = 393939648 value=1

address = 393939652 value=2

address = 393939656 value=3

C calloc() method:
“calloc” or “contiguous allocation” method in C is used to dynamically allocate the specified number of
blocks of memory of the specified type. It is very much similar to malloc() but has two different points
and these are:

1. It initializes each block with a default value „0‟.

2. It has two parameters or arguments as compare to malloc().

Syntax of calloc() in C:

ptr = (cast-type*)calloc(n, element-size);

here, n is the no. of elements and element-size is the size of each element.

For Example:

ptr = (float*) calloc(25, sizeof(float));

This statement allocates contiguous space in memory for 25 elements each with the size of the float.

If space is insufficient, allocation fails and returns a NULL pointer.

Example of calloc() in C:

#include<stdio.h>
#include<stdlib.h>
intmain()
{
int*ptr;
intn,i;
n=5;
printf("Enter number of elements: %d\n",n);
ptr=(int*)calloc(n,sizeof(int));
if(ptr==NULL)
{
printf("Memory not allocated.\n");
exit(0);
 }
else
{
printf("Memory successfully allocated using calloc.\n");
for(i=0;i<n;++i)
{
ptr[i]=i+1;
}
printf("The elements of the array are: ");
for(i=0;i<n;++i)
{
printf("%d, ",ptr[i]);
}
}
return0;
}

Output:

Enter number of elements: 5

Memory successfully allocated using calloc.

The elements of the array are: 1, 2, 3, 4, 5,

C free() method:

“free” method in C is used to dynamically de-allocate the memory. The memory allocated using functions
malloc() and calloc() is not de-allocated on their own. Hence the free() method is used, whenever the
dynamic memory allocation takes place. It helps to reduce wastage of memory by freeing it.

Syntax of free() in C:

free(ptr);
Example of free() in C:

#include <stdio.h>

#include <stdlib.h>

int main()

int *ptr, *ptr1;

int n, i;

n = 5;

printf("Enter number of elements: %d\n", n);

ptr = (int*)malloc(n * sizeof(int));

ptr1 = (int*)calloc(n, sizeof(int));

if (ptr == NULL || ptr1 == NULL)

printf("Memory not allocated.\n");

exit(0);

else

printf("Memory successfully allocated using malloc.\n");

free(ptr);

printf("Malloc Memory successfully freed.\n");

printf("\nMemory successfully allocated using calloc.\n");

free(ptr1);

printf("Calloc Memory successfully freed.\n");

return 0;

}
Output:
Enter number of elements: 5

Memory successfully allocated using malloc.

Malloc Memory successfully freed.

Memory successfully allocated using calloc.

Calloc Memory successfully freed.

C realloc() method:

“realloc” or “re-allocation” method in C is used to dynamically change the memory allocation of a

previously allocated memory. In other words, if the memory previously allocated with the help of malloc
or calloc is insufficient, realloc can be used to dynamically re-allocate memory. re-allocation of memory
maintains the already present value and new blocks will be initialized with the default garbage value.

Syntax of realloc() in C:

ptr = realloc(ptr, newSize);

where ptr is reallocated with new size 'newSize'.

If space is insufficient, allocation fails and returns a NULL pointer.

Example of realloc() in C:

#include <stdio.h>

#include <stdlib.h>

int main(){
 int* ptr;

int n, i;

n = 5;

printf("Enter number of elements: %d\n", n);

ptr = (int*)calloc(n, sizeof(int));

if (ptr == NULL)

printf("Memory not allocated.\n");

exit(0);

else

printf("Memory successfully allocated using calloc.\n");

for (i = 0; i < n; ++i)

ptr[i] = i + 1;

printf("The elements of the array are: ");

for (i = 0; i < n; ++i)

printf("%d, ", ptr[i]);

n = 10;

printf("\n\nEnter the new size of the array: %d\n", n);

ptr = (int*)realloc(ptr, n * sizeof(int));

if (ptr == NULL)

printf("Reallocation Failed\n");
exit(0);

printf("Memory successfully re-allocated using realloc.\n");

for (i = 5; i < n; ++i)

ptr[i] = i + 1;

printf("The elements of the array are: ");

for (i = 0; i < n; ++i)

printf("%d, ", ptr[i]);

free(ptr);

return 0;

}
Output:

Enter number of elements: 5

Memory successfully allocated using calloc.
The elements of the array are: 1, 2, 3, 4, 5,

Enter the new size of the array: 10

Memory successfully re-allocated using realloc.
The elements of the array are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

C Preprocessor Directives:
It is a program that preprocesses the source code before it passes through the compiler.

In almost every C program we come across, we see a few lines at the top of the program preceded by a
hash (#) sign. They are called preprocessor directives and are preprocessed by the preprocessor before
actual compilation begins. Preprocessor directives are mostly used in defining macros, evaluating
conditional statements, source file inclusion, pragma directives, line control, error detection, etc.

List of Preprocessor Directives in C:

The following table lists all the preprocessor directives available in the C programming language:
Preprocessor Directives Description

#define Used to define a macro.

#undef Used to undefine a macro.

#include Used to include a file in the source code program.

Used to include a section of code if a certain macro is defined by

#ifdef
#define.

Used to include a section of code if a certain macro is not

#ifndef
defined by #define.

#if Check for the specified condition.

#else Alternate code that executes when #if fails.

#endif Used to mark the end of #if, #ifdef, and #ifndef.

#error Used to generate a compilation error message.

#line Used to modify line number and filename information.

#pragma once To make sure the header is included only once.

#pragma message Used for displaying a message during compilation.

1. #define – Macro Directive:

Syntax:

#define token value

#define PI 3.14159
2. #include – File Inclusion Directive:

Syntax:

#include <file_name>
or
#include "filename"

#include <stdio.h>

3. #if, #ifdef, #else, #elif, #endif – Conditional Compilation

Syntax:

#ifdef MACRO
controlled text
#endif

File management:
Why do we need File Handling in C?

So far the operations using the C program are done on a prompt/terminal which is not stored anywhere.
The output is deleted when the program is closed. But in the software industry, most programs are written
to store the information fetched from the program. The use of file handling is exactly what the situation
calls for.

In order to understand why file handling is important, let us look at a few features of using files:

 Reusability: The data stored in the file can be accessed, updated, and deleted anywhere and
anytime providing high reusability.

 Portability: Without losing any data, files can be transferred to another in the computer system.
The risk of flawed coding is minimized with this feature.

 Efficient: A large amount of input may be required for some programs. File handling allows you
to easily access a part of a file using few instructions which saves a lot of time and reduces the
chance of errors.

 Storage Capacity: Files allow you to store a large amount of data without having to worry about
storing everything simultaneously in a program.

Types of Files in C

A file can be classified into two types based on the way the file stores the data. They are as follows:

 Text Files

 Binary Files
1. Text Files

A text file contains data in the form of ASCII characters and is generally used to store a stream of
characters.

 Each line in a text file ends with a new line character („\n‟).

 It can be read or written by any text editor.

 They are generally stored with .txt file extension.

 Text files can also be used to store the source code.

2. Binary Files

A binary file contains data in binary form (i.e. 0’s and 1’s) instead of ASCII characters. They contain
data that is stored in a similar manner to how it is stored in the main memory.

 The binary files can be created only from within a program and their contents can only be read by
a program.

 More secure as they are not easily readable.

 They are generally stored with .bin file extension.

C File Operations

C file operations refer to the different possible operations that we can perform on a file in C such as:

1. Creating a new file – fopen() with attributes as “a” or “a+” or “w” or “w+”

2. Opening an existing file – fopen()

3. Reading from file – fscanf() or fgets()

4. Writing to a file – fprintf() or fputs()

5. Moving to a specific location in a file – fseek(), rewind()

6. Closing a file – fclose()

Functions for C File Operations:

File Pointer in C

A file pointer is a reference to a particular position in the opened file. It is used in file handling to perform
all file operations such as read, write, close, etc. We use the FILE macro to declare the file pointer
variable. The FILE macro is defined inside <stdio.h> header file.

Syntax of File Pointer

FILE* pointer_name;

File Pointer is used in almost all the file operations in C.

Open a File in C

For opening a file in C, the fopen() function is used with the filename or file path along with the required
access modes.

Syntax of fopen()
FILE* fopen(const char *file_name, const char *access_mode);

Or

fp = fopen(“filename”, “mode”);

eg;

fp = fopen(“myfile.txt”,”r”);

Parameters

 file_name: name of the file when present in the same directory as the source file. Otherwise, full
path.

 access_mode: Specifies for what operation the file is being opened.

Return Value

 If the file is opened successfully, returns a file pointer to it.

 If the file is not opened, then returns NULL.

File opening modes in C

File opening modes or access modes specify the allowed operations on the file to be opened. They are
passed as an argument to the fopen() function. Some of the commonly used file access modes are listed
below:

File Opening modes in C:

Mode Meaning of Mode Description

r Open for reading. If the file does not exist, fopen( ) returns NULL.

If the file exists, its contents are overwritten. If the file does not
Open for writing.
w exist, it will be created.

Data is added to the end of the file. If the file does not exist, it
Open for append.
a will be created.

Open for both reading and

If the file does not exist, fopen( ) returns NULL.
r+ writing.

w+ Open for both reading and If the file exists, its contents are overwritten. If the file does not
Mode Meaning of Mode Description

writing. exist, it will be created.

Open for both reading and

If the file does not exist, it will be created.
a+ appending.

Note: if you want to perform operations on a binary file, then you have to append „b‟ at the last. For
example, instead of “w”, you have to use “wb”, instead of “a+” you have to use “a+b”.

Comparisons:

Example of Opening a File

// C Program to illustrate file opening

#include <stdio.h>

#include <stdlib.h>

int main()

// file pointer variable to store the value returned by fopen

FILE* fptr;

// opening the file in read mode

fptr = fopen("filename.txt", "r");

// checking if the file is opened successfully

 if (fptr == NULL) {

printf("The file is not opened. The program will "

"now exit.");

exit(0);

return 0;

Output

The file is not opened. The program will now exit.

The file is not opened because it does not exist in the source directory. But the fopen() function is also
capable of creating a file if it does not exist. It is shown below

Create a File in C

The fopen() function can not only open a file but also can create a file if it does not exist already. For that,
we have to use the modes that allow the creation of a file if not found such as w, w+, wb, wb+, a, a+, ab,
and ab+.

FILE *fptr;
fptr = fopen("filename.txt", "w");

Example of Opening a File

// C Program to create a file

#include <stdio.h>

#include <stdlib.h>

int main()

// file pointer

FILE* fptr;

// creating file using fopen() access mode "w"

fptr = fopen("file.txt", "w");

// checking if the file is created

if (fptr == NULL) {
 printf("The file is not opened. The program will exit now");

exit(0);

else {

printf("The file is created Successfully.");

return 0;

Output

The file is created Successfully.

Reading from a File

The file read operation in C can be performed using functions fscanf() or fgets(). Both the functions
performed the same operations as that of scanf and gets but with an additional parameter, the file pointer.
There are also other functions we can use to read from a file. Such functions are listed below:

Function Description

fscanf() Use formatted string and variable arguments list to take input from a file.

fgets() Input the whole line from the file.

fgetc() Reads a single character from the file.

fgetw() Reads a number from a file.

So, it depends on you if you want to read the file line by line or character by character.

Example:

FILE * fptr;
fptr = fopen(“fileName.txt”, “r”);
fscanf(fptr, "%s %s %s %d", str1, str2, str3, &year);
char c = fgetc(fptr);

The getc() and some other file reading functions return EOF (End Of File) when they reach the end of the
file while reading. EOF indicates the end of the file and its value is implementation-defined.
Note: One thing to note here is that after reading a particular part of the file, the file pointer will be
automatically moved to the end of the last read character.

Write to a File

The file write operations can be performed by the functions fprintf() and fputs() with similarities to read
operations. C programming also provides some other functions that can be used to write data to a file such
as:

Function Description

Similar to printf(), this function use formatted string and varible arguments list to print output
fprintf()
to the file.

fputs() Prints the whole line in the file and a newline at the end.

fputc() Prints a single character into the file.

fputw() Prints a number to the file.

Example:

FILE *fptr ;
fptr = fopen(“fileName.txt”, “w”);
fprintf(fptr, "%s %s %s %d", "We", "are", "in", 2012);
fputc("a", fptr);

Closing a File

The fclose() function is used to close the file. After successful file operations, you must always close a
file to remove it from the memory.

Syntax of fclose()

fclose(file_pointer);

where the file_pointer is the pointer to the opened file.

Example:

FILE *fptr ;
fptr= fopen(“fileName.txt”, “w”);
---------- Some file Operations -------
fclose(fptr);