C Pass Addresses and Pointers

In this tutorial, you'll learn to pass addresses and pointers as arguments to functions with the

help of examples.

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

To accept these addresses in the function definition, we can use pointers. It's because pointers

are used to store addresses. Let's take an example:

Example: Pass Addresses to Functions

#include <stdio.h>

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

int main()

int num1 = 5, num2 = 10;

// address of num1 and num2 is passed

swap( &num1, &num2);

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

printf("num2 = %d", num2);

return 0;
}

void swap(int* n1, int* n2)

int temp;

temp = *n1;

*n1 = *n2;

*n2 = temp;

Run Code

Example 2: Passing Pointers to Functions

#include <stdio.h>

void addOne(int* ptr) {

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

int main()

int* p, i = 10;

p = &i;

addOne(p);

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

return 0;
}

File Handling in C Language with Examples

In this article, I am going to discuss File Handling in C Language with examples. Please

read our previous article where we discussed Dynamic Memory Management in C.

What is a File?

A file is the name of a physical memory location in the secondary storage area. The file

contains a sequence of bytes of data in the secondary storage area in the form of an

unstructured manner. In the implementation, when we were required to interact with the

secondary storage area, then recommended going for file operations. By using files, primary

memory-related data can be sent to the secondary storage area and secondary storage area

information can be loaded to primary memory. In ‘C’ programming language, IO Operations

are classified into two types:

1. Standard IO Operations

2. Secondary IO Operations

When we are interacting with Secondary IO devices, then it is called Secondary IO

Operations. Standard IO related and Secondary IO related, all predefined functions are

declared in stdio.h only.

Why files are needed?

The entire data is lost, when a program is terminated. Storing the data in a file will preserve

your data once the program is terminated. It will take a lot of time to enter a large number of

data. However, if you’ve got a file containing all the information, you’ll easily access the

contents of the file using a few commands in C. Without any prior changes, you can easily

move your data from one computer to another.

Types of Files

When handling files, there are two sorts of files you ought to know about:
 1. Text files

2. Binary files

Text files

Text files are the normal .txt files. You can easily create text files using any simple text editor

like Notepad. When you open those files, you will see all the contents within the file as plain

text. You can easily edit or delete the contents. They take minimum effort to for easily

readable, supply the smallest amount of security, and take bigger space for storing. In the

Text files, data is represented with the help of ASCII values, i.e., .txt, .c, .cpp

Binary files

Binary files are mostly the .bin files on your computer. Instead of storing data in plain text,

they store it within the binary form (0’s and 1’s). They can hold a better amount of

knowledge, aren’t readable easily, and provides better security than text files. In binary Files,

data is represented with the help of byte, i.e., .exe, .mp3, .mp4, .jpeg

Points to Remember:

1. To specify that a given file is being opened or created in “text mode” then append “t”

to the string mode. Examples: rt, wt, at, rt+, wt+, at+

2. To specify the binary mode, append “b” to the end of the string mode. Example: RB.

Wb, ab, r+b, w+b, a+b

3. “fopen” and “fsopen” also allow that “t” or “b” to be inserted between the letter and

the ‘t’ character in the string. Example: rt+ is equivalent to r+t.

4. If “t” or “b” is not giving in the string, the mode is governed by “f” mode, if “f” mode

is set to O_BINARY, files are opened in BINARY mode.

5. If “f” mode is set to O_TEXT, they are opened in text mode. These constants are

defined in fcntl.h
File Operations

In C, you’ll perform four major operations on files, either text or binary:

1. Creating a new file

2. Opening an existing file

3. Closing a file

4. Reading from a file and writing information to a file

Example:

#include<stdio.h>

#include<dos.h>

#include<stdlib.h>

int main()

FILE* fp;

fp = fopen("F:\.txt","w");

if(fp == NULL)

printf("\n Unable to create File");

return EXIT_FAILURE;

fprintf(fp,"Welcome");

fprintf(fp,"\n%d HELLO WORLD %f", 100, 12.50);

return EXIT_SUCCESS;

Output:

Points to Remember:

1. When we are opening a file, two parameters must be passed: Path and Mode

2. The file may open or may not open. If open, then it returns ADDRESS. If not, then it

returns NULL.

3. stdio.h provides the standard IO Related predefined function prototype.

4. conio.h provides the Console Related predefined function prototype.

5. FILE is a predefined structure that is available in stdio.h. By using the FILE structure,

we can handle file properties. The size of the FILE structure is 16 bytes.

6. fp is a variable of type FILE*, which maintains the address of FILE. The size of fp is

2 bytes because it holds an address.

fopen()

It is a predefined function, which is declared in stdio.h, by using this function we can open a

file in a specific path with a specific mode. It requires two arguments of type const char*. On

success, fopen() returns FILE*, on failure returns NULL. Generally, fopen() is failed to open

FILE in the following cases:

2. Mode is incorrect

3. Permissions are not available

4. Memory is not available

Syntax: FILe *fopen(const char* path, const char* mode);

fprintf()

By using this predefined function, we can write the content in the file. fprintf() can take any

number of arguments but the first argument must be FILE* and the remaining arguments are

of any path.

Syntax: int fprintf(FILE* stream, const char*path,…..);

fclose()

By using this predefined function, we can close the file after saving data. fclose() requires

one argument of type FILE* and returns an int value.

Syntax: int fclose(FILE* stream);

File Modes

Always FILE modes will indicate for what purpose the file needs to be opened or created.

File modes are classified into three types:

1. Write

2. Read

3. Append

Depending on operations, file modes are classified into 6 types:

1. Write(w): Create a file for writing, if the file already exists, then it will override (the

old file is deleted and a new file is created). In “w” mode, whether the file exists or

not, always a new file is constructed.

NULL. When we are working with “r” mode, if the file doesn’t exist, a new file is not

constructed.

3. Append(a): Open an existing file for appending (write the data at end of the file) or

create a new file for writing if it doesn’t exist. When we are working with “a”, if file

doesn’t exist, then only a new file is constructed.

4. w+ (write and read): Create a file for update i.e. write and read if the file already

exists then it will override. In w+ mode, if the file is available or not, always a new

file is constructed.

5. r+ (read and write): Open an existing file for update I.e. read and write. Generally,

“r+” mode is required, when we need to update existing information. In “r+” mode, if

the file doesn’t exist, a new file is not constructed.

6. a+ (w+ and r+): Open an existing file for update or create a new file for update. By

using a+ mode, we can perform random operations.

Program For Reading Data From Files using C Language

#include<stdio.h>

#include<stdlib.h>

int main()

FILE* fp;

char ch;

fp = fopen("F:\.txt","r");

if(fp == NULL)
{

printf("\n File not Found");

return EXIT_FAILURE;

while(1)

fscanf(fp,"%c",&ch);

if(feof(fp)) //if(ch == EOF)

break;

printf("%c",ch);

fclose(fp);

return EXIT_SUCCESS;

Output:
fscanf()

It is a predefined function that is declared in stdio.h, by using this function, we can read the

data from a file. fscanf() can take any number of arguments but the first argument must be

and the remaining arguments should be scanf() function format. When we are working with

fscanf() function, it can read the entire content of the file except.

Syntax: int fscanf(FILE* stream, const char” format,…..);

feof()

By using this function, we can find the end of the character position. It requires one argument

of type FILE* and returns an int value. When the file pointer is pointing to the EOF character

then it returns a non-zero value, if it is pointing to other than the EOF character then it returns

zero.

Syntax: int feof(FILE* stream);

fgetc()

It is a predefined unformatted function that is declared in stdio.h, by using this function we

can read the data from a file including EOF characters also. It returns an int value i.e. ASCII

value of a character.

Syntax: int getc(FILE* stream);

Program for Reading a line from a file and displaying it using C Language

#include <stdio.h>

#include <stdlib.h> // For exit() function

int main() {

char c[1000];

FILE *fptr;

if ((fptr = fopen("F:\.txt", "r")) == NULL) {

// Program exits if file pointer returns NULL.

exit(1);

// reads text until newline is encountered

fscanf(fptr, "%[^\n]", c);

printf("Data from the file:\n%s", c);

fclose(fptr);

return 0;

Output

Example to understand File Handling in C Language:

#include<stdio.h>

#include<conio.h>

int main()

{
FILE* fp;

char path[50];

char str[50];

fprintf(stdout, "Enter a file path : ");

gets(path);

fp = fopen(path,”a");

if(fp == NULL)

fprintf(stderr, "Unable o create file");

getch();

return 1;

printf("Enter a String : ");

fflush(stdin);

gets(str);

fputs(str, fp);

fclose(fp);

return 0;

}
Output

1.txt

Delay in File Handling

It is a predefined function that is declared in dos.h. By using this function, we can suspend

the program from execution. The delay() function requires one argument of type unsigned

integer i.e. milliseconds value. By using delay(), we can suspend the program for a minimum

of 1 sec and a maximum of 5 sec.

Syntax: void delay(unsigned milliseconds);

sleep()

It is a predefined function that is declared in dos.h. By using this function, we can suspend

the program execution sleep() function requires one argument of type unsigned integer

seconds format data.

Syntax: void sleep(unsigned seconds);

stdout: It is a global pointer variable that is defined in stdio.h. By using this global pointer,

we can handle the standard output buffer.

stderr: By using this global pointer, we can handle standard IO Related errors. When we are

working with stderr, it will redirect the data back to stdout.

stdprn: By using this global pointer, we can handle the printer.

fseek()

By using this predefined function, we can create the movement in the file pointer. fseek()

requires three arguments of type FILE*, long integer, and an integer type.

Syntax: int fseek(FILE* stream, long offset, int whence);

Where stream will provide file information, Offset is the number of bytes, and whence value

is file pointer location. The whence value can be recognized by using the following constant

values:

1. SEEK_SET: This constant will pass the file pointer to the beginning of the file.

2. SEEK_CUR: This constant will provide the constant position of the file pointer.

3. SEEK_END: This constant value will send the file pointer to the end of the file.

These constant values can be recognized using INTEGER values also.

1. SEEK_SET value is 0.

2. SEEK_CUR value is 1.

3. SEEK_END value is 2.

rewind()

By using this predefined function, we can send the control to the beginning of the file.

rewind() requires one argument of type FILE*.

Syntax : void rewind(FILE* stream);

The behavior of rewind() is similar to – fseek(FILE*, O, SEEK_SET)

By using this predefined function, we can find the size of the file. ftell() requires one

argument of type FILE* and returns a long integer value. Generally, ftell() returns file pointer

position, so if the file pointer is pointing to the end of the character then it is equal to the size

of the file.

Syntax: long ftell(FILE* stream);

remove()

By using this predefined function, we can delete two files permanently from the hard disk.

remove() requires one argument of type constant char* and returns an int value.

Syntax: int remove(const char* filename);

rename()

By using this predefined function, we can change the name of an existing file. rename()

function requires two types of arguments of type const char and returns an int value.

Syntax: int rename(const char* oldname, const char* newname);

Program to Reverse the string data present in a file using C Language

#include<stdio.h>

#include<string.h>

#include<malloc.h>

int main()

FILE *fp;

char path[50];

long int fsize, i = 0;

char ch;

printf ("Enter a file path :");

gets (path);

fp = fopen (path, "rt");

if (fp == NULL)

printf ("\n File not found");

return 1;

fseek (fp, 0, SEEK_END);

fsize = ftell (fp);

fseek (fp, 0, SEEK_SET);

str = (char *) calloc (fsize, sizeof (char));

while (1)

ch = fgetc (fp);

if (feof (fp))

break;

str[i++] = ch;
}

str[i] = '\o';

fclose (fp);

remove (path);

strrev (str);

fp = fopen (path, "wt");

fputs (str, fp);

fclose (fp);

free (str);

str = NULL;

return 0;

Output
1.txt

Program to Find and Update (or Replace) a Character in a File using C Language

#include<stdio.h>

#include<stdlib.h>

int main()

FILE *fp;

char path[50];

char ch, sch, dch;

printf ("Enter a file path : ");

gets (path);

fp = fopen (path, "rt+");

if (fp == NULL)

printf ("File not found");

return 1;

}
printf ("\n Enter a source character(s) : ");

fflush (stdin);

sch = getchar ();

printf ("\n Enter a destination character(D) : ");

fflush (stdin);

dch = getchar ();

while (1)

ch = fgetc (fp);

if (ch == EOF)

break;

if (ch == sch)

fseek (fp, -1, SEEK_CUR);

fprintf (fp, "%c", dch);

fseek (fp, 0, SEEK_CUR);

fclose (fp);

return 0;
}

Output

2.txt

Program for Encoding and Decoding using C Language

#include<stdio.h>

#include<conio.h>

int main()

FILE *fp;

int flag, code = 0;

char path[30];
char ch;

printf ("Enter a file path : ");

gets (path);

fp = fopen (path, "r+");

if (fp == NULL)

printf ("\n File not found");

getch ();

return 1;

do

printf ("\n 1 for ENCODE : ");

printf ("\n 2 for DECODE : ");

scanf ("%d", &flag);

while (flag != 1 && flag != 2);

if (flag == 1)

code = 40;

else
code = -40;

while (1)

ch = fgetc (fp);

if (ch == EOF)

break;

if(ch != '\n' && ch != '\r')

fseek (fp, -1, SEEK_CUR);

fprintf (fp, "%c", ch + code);

fseek (fp, 0, SEEK_CUR);

fclose (fp);

return 0;

}
Output

2.txt (after Encoding)

2.txt (after Decoding)

Program for Operations on Audio File using C Language

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

#define f1 "F:\\part1.mp3"

#define f2 "F:\\part2.mp3"
#define f3 "F:\\part3.mp3"

#define f4 "F:\\part4.mp3"

int main(void)

FILE *sfp;

FILE *dfp;

char spath[30];

char dpath[4][30] = { f1, f2, f3, f4 };

long int fsize = 0, nb = 0; // nb is number of bytes

int i = 0;

char ch;

printf ("\n Enter sfp path : ");

gets (spath);

if (sfp == NULL)

printf ("\n %s NOT FOUND", spath);

return EXIT_FAILURE;

fseek (sfp, 0, SEEK_END);

fsize = ftell (sfp);

dfp = fopen (dpath[i], "wb");

if (dfp == NULL)

fclose (sfp);

printf ("\n%s Unable to create");

return EXIT_FAILURE;

while (1)

ch = fgetc (sfp);

if (feof (sfp))

break;

fprintf (dfp, "%c", ch);

++nb;

if (nb = fsize / 4 && i != 3)

fclose (dfp);

nb = 0;

++i;
dfp = fopen (dpath[i], "wb");

if (dfp == NULL)

printf ("\n %s Unable to create", dpath[i]);

fclose (sfp);

return EXIT_FAILURE;

fclose (sfp);

fclose (dfp);

return EXIT_SUCCESS;

Output
Program to combine two or more audio files together using C Language

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

#define f1 "F:\\part1.mp3"

#define f2 "F:\\part2.mp3"

#define f3 "F:\\part3.mp3"

#define f4 "F:\\part4.mp3"

int main(void)

FILE *sfp;

FILE *dfp;

char dpath[30];

char spath[4][30] = { f1, f2, f3, f4 };

int i = 0;

char ch;

printf ("\n enter dfp path : ");

gets (dpath);

dfp = fopen (dpath, "wb");

if (dfp == NULL)
{

printf ("\n%sUnable to create", dpath);

return EXIT_SUCCESS;

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

sfp = fopen (spath[i], "rb");

if (sfp == NULL)

fclose (dfp);

printf ("\n%s Not Found", spath[i]);

return EXIT_FAILURE;

while (1)

ch = fgetc (sfp);

if (feof (sfp))

break;

fprintf (dfp, "%c", ch);

}
fclose (sfp);

fclose (dfp);

return EXIT_SUCCESS;