Data Types

In the C programming language, data types refer to an extensive system used for
declaring variables or functions of different types. The type of a variable determines how
much space it occupies in storage and how the bit pattern stored is interpreted.
The types in C can be classified as follows:
S.N.

Types and Description

Basic Types:

They are arithmetic types and consists of the two types: (a) integer types and (b)
floating-point types.
Enumerated types:

They are again arithmetic types and they are used to define variables that can only
be assigned certain discrete integer values throughout the program.
The type void:

3
The type specifier void indicates that no value is available.
Derived types:
4

They include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types
and (e) Function types.

Write down the basic structure of C programming.

Basic structure of C programming: To write a C program, we first create functions and

then put them together. A C program may contain one or more sections. They are
illustrated below.
Documentation section : The documentation section consists of a set of comment lines
giving the name of the program, the author and other details, which the programmer
would like to use later.

Link section : The link section provides instructions to the compiler to link functions
from the system library.
Definition section : The definition section defines all symbolic constants.
Global declaration section : There are some variables that are used in more than one
function. Such variables are called global variables and are declared in the global
declaration section that is outside of all the functions. This section also declares all the
user-defined functions.
main () function section : Every C program must have one main function section. This
section contains two parts; declaration part and executable part
Declaration part : The declaration part declares all the variables used in the executable
part.
Executable part : There is at least one statement in the executable part. These two parts
must appear between the opening and closing braces. The program execution begins at
the opening brace and ends at the closing brace. The closing brace of the main function is
the logical end of the program. All statements in the declaration and executable part end
with a semicolon.
Subprogram section : The subprogram section contains all the user-defined functions that
are called in the main () function. User-defined functions are generally placed
immediately after the main () function, although they may appear in any order.

All section, except the main () function section may be absent when they are not required.

Loop
There may be a situation, when you need to execute a block of code several number of
times. In general, statements are executed sequentially: The first statement in a function is
executed first, followed by the second, and so on.
Programming languages provide various control structures that allow for more
complicated execution paths.
A loop statement allows us to execute a statement or group of statements multiple times
and following is the general form of a loop statement in most of the programming
languages:

Loop Type

while loop

Description
Repeats a statement or group of statements while a given
condition is true. It tests the condition before executing the
loop body.

for loop

Execute a sequence of statements multiple times and

abbreviates the code that manages the loop variable.

do...while loop

Like a while statement, except that it tests the condition at the

end of the loop body

nested loops

You can use one or more loop inside any another while, for or
do..while loop.

Loop Control Statements:

Loop control statements change execution from its normal sequence. When execution
leaves a scope, all automatic objects that were created in that scope are destroyed.
C supports the following control statements. Click the following links to check their
detail.
Control Statement

Description

break statement

Terminates the loop or switch statement and transfers

execution to the statement immediately following the loop or
switch.

continue statement

Causes the loop to skip the remainder of its body and

immediately retest its condition prior to reiterating.

goto statement

Transfers control to the labeled statement. Though it is not

advised to use goto statement in your program.

Switch statement
A switch statement allows a variable to be tested for equality against a list of values.
Each value is called a case, and the variable being switched on is checked for each switch
case.
Syntax:
The syntax for a switch statement in C programming language is as follows:
switch(expression){

case constant-expression :
statement(s);
break; /* optional */
case constant-expression :
statement(s);
break; /* optional */

/* you can have any number of case statements */

default : /* Optional */
statement(s);
}
The following rules apply to a switch statement:

The expression used in a switch statement must have an integral or enumerated

type, or be of a class type in which the class has a single conversion function to an
integral or enumerated type.

You can have any number of case statements within a switch. Each case is
followed by the value to be compared to and a colon.

The constant-expression for a case must be the same data type as the variable in
the switch, and it must be a constant or a literal.

When the variable being switched on is equal to a case, the statements following
that case will execute until a break statement is reached.

When a break statement is reached, the switch terminates, and the flow of control
jumps to the next line following the switch statement.

Not every case needs to contain a break. If no break appears, the flow of control
will fall through to subsequent cases until a break is reached.

A switch statement can have an optional default case, which must appear at the
end of the switch. The default case can be used for performing a task when none of the
cases is true. No break is needed in the default case.
Flow Diagram:

Example:
#include <stdio.h>
int main ()
{
/* local variable definition */
char grade = 'B';
switch(grade)
{

case 'A' :
printf("Excellent!\n" );
break;
case 'B' :
case 'C' :
printf("Well done\n" );
break;
case 'D' :
printf("You passed\n" );
break;
case 'F' :
printf("Better try again\n" );
break;
default :
printf("Invalid grade\n" );
}
printf("Your grade is %c\n", grade );
return 0;
}

Nested loops in C
C programming language allows to use one loop inside another loop. Following section
shows few examples to illustrate the concept.
Syntax:

The syntax for a nested for loop statement in C is as follows:

for ( init; condition; increment )
{
for ( init; condition; increment )
{
statement(s);
}
statement(s);
}
The syntax for a nested while loop statement in C programming language is as follows:
while(condition)
{
while(condition)
{
statement(s);
}
statement(s);
}
The syntax for a nested do...while loop statement in C programming language is as
follows:
do
{
statement(s);

do
{
statement(s);
}while( condition );

}while( condition );
A final note on loop nesting is that you can put any type of loop inside of any other type
of loop. For example, a for loop can be inside a while loop or vice versa.
Example:
The following program uses a nested for loop to find the prime numbers from 2 to 100:
#include <stdio.h>
int main ()
{
/* local variable definition */
int i, j;

for(i=2; i<100; i++) {

for(j=2; j <= (i/j); j++)
if(!(i%j)) break; // if factor found, not prime
if(j > (i/j)) printf("%d is prime\n", i);
}
return 0;
}

When the above code is compiled and executed, it produces the following result:
2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime
17 is prime

Arrays
C programming language provides a data structure called the array, which can store a
fixed-size sequential collection of elements of the same type. An array is used to store a
collection of data, but it is often more useful to think of an array as a collection of
variables of the same type.
Instead of declaring individual variables, such as number0, number1, ..., and number99,
you declare one array variable such as numbers and use numbers[0], numbers[1], and ...,

numbers[99] to represent individual variables. A specific element in an array is accessed

by an index.
All arrays consist of contiguous memory locations. The lowest address corresponds to the
first element and the highest address to the last element.
Arrays in C
Declaring Arrays
To declare an array in C, a programmer specifies the type of the elements and the number
of elements required by an array as follows:
type arrayName [ arraySize ];
This is called a single-dimensional array. The arraySize must be an integer constant
greater than zero and type can be any valid C data type. For example, to declare a 10element array called balance of type double, use this statement:
double balance[10];
Now balance is avariable array which is sufficient to hold upto 10 double numbers.
Initializing Arrays
You can initialize array in C either one by one or using a single statement as follows:
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
The number of values between braces { } can not be larger than the number of elements
that we declare for the array between square brackets [ ].
If you omit the size of the array, an array just big enough to hold the initialization is
created. Therefore, if you write:
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
You will create exactly the same array as you did in the previous example. Following is
an example to assign a single element of the array:
balance[4] = 50.0;
The above statement assigns element number 5th in the array with a value of 50.0. All
arrays have 0 as the index of their first element which is also called base index and last

index of an array will be total size of the array minus 1. Following is the pictorial
representation of the same array we discussed above:
Array Presentation
Accessing Array Elements
An element is accessed by indexing the array name. This is done by placing the index of
the element within square brackets after the name of the array. For example:
double salary = balance[9];
The above statement will take 10th element from the array and assign the value to salary
variable. Following is an example which will use all the above mentioned three concepts
viz. declaration, assignment and accessing arrays:
#include <stdio.h>
int main ()
{
int n[ 10 ]; /* n is an array of 10 integers */
int i,j;
/* initialize elements of array n to 0 */
for ( i = 0; i < 10; i++ )
{
n[ i ] = i + 100; /* set element at location i to i + 100 */
}
/* output each array element's value */
for (j = 0; j < 10; j++ )
{
printf("Element[%d] = %d\n", j, n[j] );

}
return 0;
}
When the above code is compiled and executed, it produces the following result:
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Difference between Call by Value and Call by Reference

call by value

call by reference

In call by value, a copy of actual arguments

is passed to formal arguments of the called
function and any change made to the formal
arguments in the called function have no
effect on the values of actual arguments in
the calling function.

In call by reference, the location (address)

of actual arguments is passed to formal
arguments of the called function. This
means by accessing the addresses of actual
arguments we can alter them within from
the called function.

In call by value, actual arguments will

remain safe, they cannot be modified
accidentally.

In call by reference, alteration to actual

arguments is possible within from called
function; therefore the code must handle
arguments carefully else you get unexpected
results.

Example using Call by Value

The classic example of wanting to modify the caller's memory is a swapByValue()
function which exchanges two values. For C uses call by value, the following version of
swap swapByValue() will not work...
#include <stdio.h>
void swapByValue(int, int); /* Prototype */
int main() /* Main function */
{
int n1 = 10, n2 = 20;
/* actual arguments will be as it is */
swapByValue(n1, n2);
printf("n1: %d, n2: %d\n", n1, n2);
}
void swapByValue(int a, int b)

{
int t;
t = a; a = b; b = t;
}
OUTPUT
======
n1: 10, n2: 20
The swapByValue() does not affect the arguments n1 and n2 in the calling function it
only operates on a and b local to swapByValue() itself. This is a good example of how
local variables behave.

Example using Call by Reference

In call by reference, to pass a variable n as a reference parameter, the programmer must
pass a pointer to n instead of n itself. The formal parameter will be a pointer to the value
of interest. The calling function will need to use & to compute the pointer of actual
parameter. The called function will need to dereference the pointer with * where
appropriate to access the value of interest. Here is an example of a correct swap
swapByReference() function. So, now you got the difference between call by value and
call by reference!
#include <stdio.h>
void swapByReference(int*, int*); /* Prototype */
int main() /* Main function */
{
int n1 = 10, n2 = 20;
/* actual arguments will be altered */
swapByReference(&n1, &n2);
printf("n1: %d, n2: %d\n", n1, n2);

}
void swapByReference(int *a, int *b)
{
int t;
t = *a; *a = *b; *b = t;
}
OUTPUT
======
n1: 20, n2: 10

Recursion
Recursion is the process of repeating items in a self-similar way. Same applies in
programming languages as well where if a programming allows you to call a function
inside the same function that is called recursive call of the function as follows.
void recursion()
{
recursion(); /* function calls itself */
}
int main()
{
recursion();
}
The C programming language supports recursion, i.e., a function to call itself. But while
using recursion, programmers need to be careful to define an exit condition from the
function, otherwise it will go in infinite loop.
Recursive function are very useful to solve many mathematical problems like to calculate
factorial of a number, generating Fibonacci series, etc.
Number Factorial
Following is an example, which calculates factorial for a given number using a recursive
function:
#include <stdio.h>
int factorial(unsigned int i)
{
if(i <= 1)
{

return 1;
}
return i * factorial(i - 1);
}
int main()
{
int i = 15;
printf("Factorial of %d is %d\n", i, factorial(i));
return 0;
}
When the above code is compiled and executed, it produces the following result:
Factorial of 15 is 2004310016
Fibonacci Series
Following is another example, which generates Fibonacci series for a given number using
a recursive function:
#include <stdio.h>
int fibonaci(int i)
{
if(i == 0)
{
return 0;
}
if(i == 1)

{
return 1;
}
return fibonaci(i-1) + fibonaci(i-2);
}
int main()
{
int i;
for (i = 0; i < 10; i++)
{
printf("%d\t%n", fibonaci(i));
}
return 0;
}
When the above code is compiled and executed, it produces the following result:
0

13

21

34

C Program to Find the Transpose of a given Matrix

#include<stdio.h>
#include<conio.h>
void main()
{
int A[2][3] , B[3][2];
int i, j;

/* 'i' used for rows and 'j' used for columns */

clrscr();
printf(" Enter the elements of A\n");
for(i=0 ; i<2 ; i++)
{
for(j=0 ; j<3 ; j++)
{
scanf("%d" , &A[i][j] );
}
}
printf(" Matrix is\n");
for(i=0 ; i<2 ; i++)
{
for(j=0 ; j<3 ; j++)
{
printf("%d\t" , A[i][j] );

/* '\t' used for Tab */

}
printf("\n");
}
for(i=0 ; i<3 ; i++)
{
for(j=0 ; j<2 ; j++)
{
B[i][j] = A[j][i];
}
}
printf(" After Transpose\n");
for(i=0 ; i<3 ; i++)
{
for(j=0 ; j<2 ; j++)
{
printf("%d\t" , B[i][j] );
}
printf("\n");
}
getch();
}

/* '\n' used for next line character */

Program to copy the contents of one file into another

#include <stdio.h>
#include <stdlib.h> // For exit()
int main()
{
FILE *fptr1, *fptr2;
char filename[100], c;
printf("Enter the filename to open for reading \n");
scanf("%s", filename);
// Open one file for reading
fptr1 = fopen(filename, "r");
if (fptr1 == NULL)
{
printf("Cannot open file %s \n", filename);
exit(0);
}
printf("Enter the filename to open for writing \n");
scanf("%s", filename);
// Open another file for writing
fptr2 = fopen(filename, "w");
if (fptr2 == NULL)
{
printf("Cannot open file %s \n", filename);
exit(0);
}
// Read contents from file
c = fgetc(fptr1);
while (c != EOF)
{
fputc(c, fptr2);
c = fgetc(fptr1);
}
printf("\nContents copied to %s", filename);
fclose(fptr1);

fclose(fptr2);
return 0;
}

Program to Find the Number of Integers Divisible by 7

#include <stdio.h>
void main()
{
int i, num1, num2, count = 0, sum = 0;
printf("Enter the value of num1 and num2 \n");
scanf("%d %d", &num1, &num2);
/* Count the number and compute their sum*/
printf("Integers divisible by 5 are \n");
for (i = num1; i < num2; i++)
{
if (i % 5 == 0)
{
printf("%3d,", i);
count++;
sum = sum + i;
}
}
printf("\n Number of integers divisible by 5 between %d and %d =
%d\n", num1, num2, count);
printf("Sum of all integers that are divisible by 5 = %d\n", sum);
}
|Output -

Write a c program to find out the sum of series 1 + 2 + . + n.

#include<stdio.h>
int main(){
int n,i;
int sum=0;
printf("Enter the n i.e. max values of series: ");
scanf("%d",&n);
sum = (n * (n + 1)) / 2;
printf("Sum of the series: ");
for(i =1;i <= n;i++){
if (i!=n)
printf("%d + ",i);
else
printf("%d = %d ",i,sum);
}
return 0;
}

C program for addition of two matrices

#include<stdio.h>
int main(){
int a[3][3],b[3][3],c[3][3],i,j;
printf("Enter the First matrix->");
for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf("%d",&a[i][j]);
printf("\nEnter the Second matrix->");
for(i=0;i<3;i++)
for(j=0;j<3;j++)
scanf("%d",&b[i][j]);
printf("\nThe First matrix is\n");
for(i=0;i<3;i++){
printf("\n");
for(j=0;j<3;j++)
printf("%d\t",a[i][j]);
}
printf("\nThe Second matrix is\n");
for(i=0;i<3;i++){
printf("\n");
for(j=0;j<3;j++)

printf("%d\t",b[i][j]);
}
for(i=0;i<3;i++)
for(j=0;j<3;j++)
c[i][j]=a[i][j]+b[i][j];
printf("\nThe Addition of two matrix is\n");
for(i=0;i<3;i++){
printf("\n");
for(j=0;j<3;j++)
printf("%d\t",c[i][j]);
}
return 0;
}

Write a c program to read one matrix and find the sum of its diagonal
#include<stdio.h>
void main()
{
int a[10][10],sum=0;
int i,j,m,n;
clrscr();
printf("Enter Order of Matrix = ");
scanf("%d%d",&m,&n);
if(m!=n)
{
printf("Not a Square Matrix : ");
getch();
exit();
}
printf("Enter Elements : ");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
if(i==j)
{
sum+=a[i][j];
}
}
}
printf("Sum of Diagonal Elements = %d ",sum);
getch();
}

Output

Print the Markssheet of Students of BA Final Year

/* variable description
rl -> Roll No
s1 -> Subject1 Marks
s2 -> Subject2 Marks
s3 -> Subject3 Marks
t -> total
per -> percentage
nm -> name of student
div -> division */
/* linking section */
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<string.h>
void main()
{
/*variable declaration part */
int rl,s1,s2,s3,t;
float per;
char nm[25],div[10];

clrscr();
/*reading part */
printf("Enter the Roll No : ");
scanf("%d",&rl);
printf("Enter Name

: ");

fflush(stdin);
gets(nm);
printf("Enter Three Subject Marks :\n");
scanf("%d%d%d",&s1,&s2,&s3);
/* processing part */
t=s1+s2+s3;
per=t/3.0;
if(per>=75)
strcpy(div,"Honour");
else if( per>=60)
strcpy(div,"First");
else if( per>=48)
strcpy(div,"Second");
else if (per>=36)
strcpy(div,"Pass");
else

strcpy(div,"Fail");
/* display part */
printf("\t\tUniversity of Gwalior\n");
printf("\n\n");
printf("Roll No: %d \t Name : %s\n",rl,nm);
printf("---------------------------------------------------\n");
printf("Subject

Max

Min

Obt.Marks\n");

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

100

36

%d\n",s1);

printf("socio.

100

36

%d\n",s2);

printf("Hindi

100

36

%d\n",s3);

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

Total

%d\n",t);

printf("per %f\t\t\t div: %s \n",per,div);

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

Write a program using command line arguments to calculate the sum of three
numbers
#include<stdio.h>
void main(int argc, char * argv[]) {
int i, sum = 0;
if (argc != 3) {
printf("You have forgot to type numbers.");
exit(1);
}
printf("The sum is : ");
for (i = 1; i < argc; i++)
sum = sum + atoi(argv[i]);
printf("%d", sum);
}

Output :
The sum is : 30

Array of Structures
C Structure is collection of different datatypes ( variables ) which are grouped
together. Whereas, array of structures is nothing but collection of structures. This is
also called as structure array in C.
Example program for array of structures in C:
This program is used to store and access id, name and percentage for 3 students.
Structure array is used in this program to store and display records for many
students. You can store n number of students record by declaring structure
variable as struct student record[n], where n can be 1000 or 5000 etc.
#include <stdio.h>
#include <string.h>
struct student
{
int id;
char name[30];
float percentage;
};
int main()
{
int i;
struct student record[2];
// 1st student's record
record[0].id=1;
strcpy(record[0].name, "Raju");

record[0].percentage = 86.5;
// 2nd student's record
record[1].id=2;
strcpy(record[1].name, "Surendren");
record[1].percentage = 90.5;
// 3rd student's record
record[2].id=3;
strcpy(record[2].name, "Thiyagu");
record[2].percentage = 81.5;
for(i=0; i<3; i++)
{
printf(" Records of STUDENT : %d \n", i+1);
printf(" Id is: %d \n", record[i].id);
printf(" Name is: %s \n", record[i].name);
printf(" Percentage is: %f\n\n",record[i].percentage);
}
return 0;
}
Output:
Records of STUDENT : 1
Id is: 1
Name is: Raju
Percentage is: 86.500000
Records of STUDENT : 2
Id is: 2
Name is: Surendren
Percentage is: 90.500000
Records of STUDENT : 3
Id is: 3
Name is: Thiyagu
Percentage is: 81.500000