Professional Documents
Culture Documents
Whatisc?: Execution of C Program
Whatisc?: Execution of C Program
Whatisc?: Execution of C Program
C language is a general purpose and structured pragramming langauge developed by 'Dennis Ritchie' at AT &T's Bell
Laboratories in the 1972s in USA.
It is also called as 'Procedure oriented programming language.'
C is not specially designed for specific applications areas like COBOL (Common Business-Oriented Language) or
FORTRAN (Formula Translation). It is well suited for business and scietific applications. It has some various features
like control structures, looping statements, arrays, macros required for these applications.
The C language has following numorous features as:
Portability
Flexibility
Effectiveness and efficiency
Reliability
Interactivity
Execution of C Program :
C program executes in following 4 (four steps).
1. Creating a program :
An editor like notepad or wordpad is used to create a C program. This file contains a source code which consists
of executable code. The file should be saved as '*.c' extension only.
2. Compiling the program :
The next step is to compile the program. The code is compiled by using compiler. Compiler converts executable
code to binary code i.e. object code.
3. Linking a program to library :
The object code of a program is linked with libraries that are needed for execution of a program. The linker is
used to link the program with libraries. It creates a file with '*.exe' extension.
4. Execution of program :
The final executable file is then run by dos command prompt or by any other software.
History of C :
Year of
Language Name Developed By
Establishment
1960 ALGOL-60 Cambridge University
CPL (Combined Programming
1963 Cambridge University
Language)
BCPL (Basic Combined Programming Martin Richard at Cambridge
1967
Language) University
Ken Thompson at AT & T's Bell
1970 B
Laboratories.
Dennis Ritchie at AT & T' Bell
1972 C
Laboratory.
The development of C was a cause of evolution of programming languages like Algol 60, CPL (Combined Programming
Langauge), BCPL (Basic Combined Programming Language) and B.
Algol-60 : (1963) :
ALGOL is an acronym for Algorithmic Language. It was the first structured procedural programming language,
developed in the late 1950s and once widely used in Europe. But it was too abstract and too general structured
langauage.
CPL : (1963) :
CPL is an acronym for Combined Programming Language. It was developed at Cambridge University.
BCPL : (1967) :
BCPL is an acronym for Basic Combined Programming Language. It was developed by Martin Richards at
Cambridge University in 1967. BCPL was not so powerful. So, it was failed.
B : (1970) :
B language was developed by Ken Thompson at AT & T Bell Laboratories in 1970. It was machine dependent.
So, it leads to specific problems.
C : (1972) :
'C' Programming Langauage was developed by Dennis Ritchie at AT & T Bell Laboratories in 1972. This is
general purpose, compiled, structured programming langauage. Dennis Ritchie studied the BCPL, then
improved and named it as 'C' which is the second letter of BCPL
Structure of C Program
The basic structure of C program is as follow:
Document Section
Links Section (File)
Definition Section
Global variable declaration Section
void main()
{
Variable declaration section
Function declaration section
executable statements;
}
Function definition 1
---------------------
---------------------
Function definition n
where,
Document Section : It consists of set of comment lines which include name of a program, author name, creation date
and other information.
Links Section (File) : It is used to link the required system libraries or header files to excute a program.
Definition Section : It is used to define or set values to variables.
Global variable declaration Section : It is used to declare global or public variable.
void main() : Used to start of actual C program. It includes two parts as declaration part and executable part.
Variable declaration section : Used to declare private variable.
Function declaration section : Used to declare functions of program from which we get required output.
Then, executable statements are placed for execution.
Function definition section : Used to define functions which are to be called from main().
Character Set :
A character refers to the digit, alphabet or special symbol used to data represetation.
1. Alphabets : A-Z, a-z
2. Digits : 0-9
3. Special Characters : ~ ! @ # $ % ^ & * ( ) _ + { } [ ] - < > , . / ? \ | : ; " '
4. White Spaces : Horizontal tab, Carriage return, New line, form feed
Identifier :
Identifier is the name of a variable that is made up from combination of alphabets, digits and underscore.
Variable :
It is a data name which is used to store data and may change during program execution. It is opposite to constant.
Variable name is a name given to memory cells location of a computer where data is stored.
* Rules for varibales:
First character should be letter or alphabet.
Keywords are not allowed to use as a variable name.
White space is not allowed.
C is case sensitive i.e. UPPER and lower case are significant.
Only underscore, special symbol is allowed between two characters.
The length of indentifier may be upto 31 characters but only only the first 8 characters are significant by
compiler.
(Note: Some compilers allow variable names whose length may be upto 247 characters. But, it is
recommended to use maximum 31 characters in variable name. Large variable name leads to occur errors.)
Keywords :
Keywords are the system defined identifiers.
All keywords have fixed meanings that do not change.
White spaces are not allowed in keywords.
Keyword may not be used as an indentifier.
It is strongly recommended that keywords should be in lower case letters.
There are totally 32(Thirty Two) keywords used in a C programming.
int float double long
short signed unsigned const
if else switch break
default do while for
register extern static struct
typedef enum return sizeof
goto union auto case
void char continue volatile
+194.143, -416.41
2. INTEGER CONSTANT :
It must have at least one digit.
It should not contain a decimal place.
It can be positive or negative.
Use of blank space and comma is not allowed between real constants.
Example:
3. CHARACTER CONSTANT :
It is a single alphabet or a digit or a special symbol enclosed in a single quote.
Maximum length of a character constant is 1.
Example:
4. STRING CONSTANT :
It is collection of characters enclosed in double quotes.
It may contain letters, digits, special characters and blank space.
Example:
Data Types in C :
"Data type can be defined as the type of data of variable or constant store."
When we use a variable in a program then we have to mention the type of data. This can be handled using data type
in C.
Followings are the most commonly used data types in C.
* QUALIFIER :
When qualifier is applied to the data type then it changes its size or its size.
Size qualifiers : short, long
Sign qualifiers : signed, unsigned
Example:
* TYPEDEF :
It is used to create new data type. But it is commonly used to change existing data type with another name.
Syntax:
OR
Operators in C :
"Operator is a symbol that is used to perform mathematical operations."
When we use a variable in a program then we have to mention the type of data. This can be handled using data type
in C.
Followings are the most commonly used data types in C.
#include <stdio.h>
#include <conio.h>
void main()
int a,b;
clrscr();
a = 53;
getch();
}
1. Assignment Operator
2. Arithmetic Operators
It is also called as 'Binary operators'. It is used to perform arithmetical operations.
These operators operate on two operands.
#include <stdio.h>
#include <conio.h>
void main()
int a,b,c,d,e,f,g;
clrscr();
scanf("%d",&a);
scanf("%d",&b);
c = a + b;
d = a - b;
e = a * b;
f = a / b;
g = a % b;
getch();
2. Arithmetic Operators
3. Logical Operators
Sometimes, we have to check more than one condition at a time then it is operator
which is primarily used to check more than two conditions. This operator returns 1 if
condition is true otherwise 0.
#include <stdio.h>
#include <conio.h>
void main()
clrscr();
getch();
}
3. Logical Operators
4. Relational Operators
It is also used to check conditions. These operators return 1 if condition is true
otherwise 0.
#include <stdio.h>
#include <conio.h>
void main()
clrscr();
getch();
4. Relational Operators
5. Shorthand Operators
It is used to perform mathematical operations at which the result or output can
affect on operands.
#include <stdio.h>
#include <conio.h>
void main()
int a,b;
clrscr();
a = 18;
b = 4;
b += a ; // b = b + a
getch();
}
5. Shorthand Operators
6. Unary Operators
It operates on a single operand. Therefore, this operator is called as 'unary
operator.' It is used to increase or decrease the value of variable by 1.
/* Program to demonstrate Unary / Ternary operators .
#include <stdio.h>
#include <conio.h>
void main()
int a=4, b;
clrscr();
a++; // Post
++a; // Pre
b=--a;
b=a++;
b++;
getch();
}
6. Unary Operators
7. Conditional Operator
Conditional operator is also called as 'ternary operator.' It is widely used to execute
condition in true part or in false part. It operates on three operands. The logical or
relational operator can be used to check conditions.
#include <stdio.h>
#include <conio.h>
void main()
int a, b=3;
clrscr();
a = 5;
// No
getch();
}
7. Conditional Operator
8. Bitwise Operators
Bitwise operators are used for manipulation of data at a bit level. They can be
directly applied to char, short int and long.
if(condition)
{
statements;
}
In above syntax, the condition is checked first. If it is true, then the program control flow goes inside the braces and
executes the block of statements associated with it. If it returns false, then program skips the braces. If there are
more than 1 (one) statements in if statement then use { } braces else it is not necessary to use.
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int a;
a=5;
clrscr();
if(a>4)
printf("\nValue of A is greater than 4 !");
if(a==4)
printf("\n\n Value of A is 4 !");
getch();
}
Output :
if(condition)
{
true statements;
}
else
{
false statements;
}
In above syntax, the condition is checked first. If it is true, then the program control flow goes inside the braces and
executes the block of statements associated with it. If it returns false, then it executes the else part of a program.
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int no;
clrscr();
printf("\n Enter Number :");
scanf("%d",&no);
if(no%2==0)
printf("\n\n Number is even !");
else
printf("\n\n Number is odd !");
getch();
}
Output :
Enter Number : 11
Number is odd !_
Nested If-Else Statement :
It is a conditional statement which is used when we want to check more than 1 conditions at a time in a same
program. The conditions are executed from top to bottom checking each condition whether it meets the conditional
criteria or not. If it found the condition is true then it executes the block of associated statements of true part else it
goes to next condition to execute.
Syntax:
if(condition)
{
if(condition)
{
statements;
}
else
{
statements;
}
}
else
{
statements;
}
In above syntax, the condition is checked first. If it is true, then the program control flow goes inside the braces and
again checks the next condition. If it is true then it executes the block of statements associated with it else executes
else part.
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int no;
clrscr();
printf("\n Enter Number :");
scanf("%d",&no);
if(no>0)
{
printf("\n\n Number is greater than 0 !");
}
else
{
if(no==0)
{
printf("\n\n It is 0 !");
}
else
{
printf("Number is less than 0 !");
}
}
getch();
}
Switch case Statement :
This is a multiple or multiway brancing decision making statement.
When we use nested if-else statement to check more than 1 conditions then the complexity of a program increases in
case of a lot of conditions. Thus, the program is difficult to read and maintain. So to overcome this problem, C
provides 'switch case'.
Switch case checks the value of a expression against a case values, if condition matches the case values then the
control is transferred to that point.
Syntax:
switch(expression)
{
case expr1:
statements;
break;
case expr2:
statements;
break;
' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '
' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '
case exprn:
statements;
break;
default:
statements;
}
In above syntax, switch, case, break are keywords.
expr1, expr2 are known as 'case labels.'
Statements inside case expression need not to be closed in braces.
Break statement causes an exit from switch statement.
Default case is optional case. When neither any match found, it executes.
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int no;
clrscr();
printf("\n Enter any number from 1 to 3 :");
scanf("%d",&no);
switch(no)
{
case 1:
printf("\n\n It is 1 !");
break;
case 2:
printf("\n\n It is 2 !");
break;
case 3:
printf("\n\n It is 3 !");
break;
default:
printf("\n\n Invalid number !");
}
getch();
}
Output 1 :
It is 3 !_
Output 2 :
Invalid number !_
break;
Figure :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int i;
clrscr();
for(i=1; ; i++)
{
if(i>5)
break;
printf("%d",i); // 5 times only
}
getch();
}
Output :
12345_
Break Statement :
Sometimes, it is necessary to exit immediately from a loop as soon as the condition is satisfied.
When break statement is used inside a loop, then it can cause to terminate from a loop. The statements after break
statement are skipped.
Syntax :
break;
Figure :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int i;
clrscr();
for(i=1; ; i++)
{
if(i>5)
break;
printf("%d",i); // 5 times only
}
getch();
}
Continue Statement :
Sometimes, it is required to skip a part of a body of loop under specific conditions. So, C supports 'continue'
statement to overcome this anomaly.
The working structure of 'continue' is similar as that of that break statement but difference is that it cannot terminate
the loop. It causes the loop to be continued with next iteration after skipping statements in between. Continue
statement simply skipps statements and continues next iteration.
Syntax :
continue;
Figure :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int i;
clrscr();
for(i=1; i<=10; i++)
{
if(i==6)
continue;
printf("\n\t %d",i); // 6 is omitted
}
getch();
}
Output :
1
2
3
4
5
7
8
Goto Statement :
It is a well known as 'jumping statement.' It is primarily used to transfer the control of execution to any place in a
program. It is useful to provide branching within a loop.
When the loops are deeply nested at that if an error occurs then it is difficult to get exited from such loops. Simple
break statement cannot work here properly. In this situations, goto statement is used.
Syntax :
goto [expr];
Figure :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int i=1, j;
clrscr();
while(i<=3)
{
for(j=1; j<=3; j++)
{
printf(" * ");
if(j==2)
goto stop;
}
i = i + 1;
}
stop:
printf("\n\n Exited !");
getch();
}
Output :
* *
Exited_
Functions in C :
The function is a self contained block of statements which performs a coherent task of a same kind.
C program does not execute the functions directly. It is required to invoke or call that functions. When a function is
called in a program then program control goes to the function body. Then, it executes the statements which are
involved in a function body. Therefore, it is possible to call fuction whenever we want to process that functions
statements.
Types of functions :
There are 2(two) types of functions as:
1. Built in Functions
2. User Defined Functions
1. Built in Functions :
These functions are also called as 'library functions'. These functions are provided by system. These functions are
stored in library files. e.g.
scanf()
printf()
strcpy
strlwr
strcmp
strlen
strcat
2. User Defined Functions :
The functions which are created by user for program are known as 'User defined functions'.
Syntax:
void main()
{
// Function prototype
<return_type><function_name>([<argu_list>]);
// Function Call
<function_name>([<arguments>]);
}
// Function definition
<return_type><function_name>([<argu_list>]);
{
<function_body>;
}
Program :
#include <stdio.h>
#include <conio.h>
void add()
{
int a, b, c;
clrscr();
printf("\n Enter Any 2 Numbers : ");
scanf("%d %d",&a,&b);
c = a + b;
printf("\n Addition is : %d",c);
}
void main()
{
void add();
add();
getch();
}
Output :
// Declaration
void <function_name>(<data_type><var_nm>)
// Calls
<function_name>(<var_nm>);
// Definition
void <function_name>(<data_type><var_nm>)
{
<function_body>;
- - - - - - - -;
}
Program :
#include <stdio.h>
#include <conio.h>
void printno(int a)
{
printf("\n Number is : %d", a);
}
void main()
{
int no;
void printno(int);
clrscr();
printf("\n Enter Number : ");
scanf("%d", &no);
printno(no);
getch();
}
Output :
Enter Number : 21
Number is : 21_
Function Call by Returning Value :
When a function returns value of variables then that function is known as 'function call by returning values.'
Syntax:
// Declaration
<data_type><function_name>();
// Calls
<variable_of_function>=<function_nm>();
// Definition
<data_type><function_name>()
{
<function_body>;
- - - - - - - -;
return <variable_of_function>;
}
Program :
#include <stdio.h>
#include <conio.h>
int number()
{
int no;
printf("\n Enter Number : ");
scanf("%d",&no);
return no;
}
void main()
{
int no;
int number();
clrscr();
no = number();
printf("\n Number is : %d",no);
getch();
}
Output :
Enter Number : 5
Number is : 5_
Function Call by Passing and Returning Value :
When a function passes and returns value of variables then that function is known as 'function call by passing and
returning values.'
Program :
#include <stdio.h>
#include <conio.h>
int number(int n)
{
return n;
}
void main()
{
int number(int);
int a = number(4);
clrscr();
printf("\n Number is : %d",a);
getch();
}
Output :
Number is : 4_
Recursion (Recursive Function) :
When a function of body calls the same function then it is called as 'recursive function.'
Example:
Recursion()
{
printf("Recursion !");
Recursion();
}
Program :
#include <stdio.h>
#include <conio.h>
Recursion()
{
int no;
printf("\nRecursion... ");
printf("\n\n Enter Number : ");
scanf("%d",&no);
if (no==3)
exit(0);
else
Recursion();
}
void main()
{
clrscr();
Recursion();
}
Output :
Recursion...
Enter Number : 2
Recursion...
Enter Number : 1
Recursion...
Enter Number : 3_
Features :
There should be at least one if statement used to terminate recursion.
It does not contain any looping statements.
Advantages :
It is easy to use.
It represents compact programming strctures.
Disadvantages :
It is slower than that of looping statements because each time function is called.
Note :
It can be applied to calcula
Storage Class :
'Storage' refers to the scope of a variable and memory allocated by compiler to store that variable. Scope of a variable
is the boundary within which a varible can be used. Storage class defines the the scope and lifetime of a variable.
From the point view of C compiler, a variable name identifies physical location from a computer where varaible is
stored. There are two memory locations in a computer system where variables are stored as : Memory and CPU
Registers.
Functions of storage class :
To detemine the location of a variable where it is stored ?
Set initial value of a variable or if not specified then setting it to default value.
Defining scope of a variable.
To determine the life of a variable.
Types of Storage Classes :
Storage classes are categorised in 4 (four) types as,
Automatic Storage Class
Register Storage Class
Static Storage Class
External Storage Class
Automatic Storage Class :
o Keyword : auto
o Storage Location : Main memory
o Initial Value : Garbage Value
o Life : Control remains in a block where it is defined.
o Scope : Local to the block in which variable is declared.
Syntax :
Example :
auto int a;
Program :
/* Program to demonstrate automatic storage class.
#include <stdio.h>
#include <conio.h>
void main()
{
auto int i=10;
clrscr();
{
auto int i=20;
printf("\n\t %d",i);
}
printf("\n\n\t %d",i);
getch();
}
Output :
20
10_
Register Storage Class :
o Keyword : register
o Storage Location : CPU Register
o Initial Value : Garbage
o Life : Local to the block in which variable is declared.
o Scope : Local to the block.
Syntax :
Example :
register int a;
When the calculations are done in CPU, then the value of variables are transferred from main memory to CPU.
Calculations are done and the final result is sent back to main memory. This leads to slowing down of processes.
Register variables occur in CPU and value of that register variable is stored in a register within that CPU. Thus, it
increases the resultant speed of operations. There is no waste of time, getting variables from memory and sending it
to back again.
It is not applicable for arrays, structures or pointers.
It cannot not used with static or external storage class.
Unary and address of (&) cannot be used with these variables as explicitly or implicitly.
Program :
/* Program to demonstrate register storage class.
#include <stdio.h>
#include <conio.h>
void main()
{
register int i=10;
clrscr();
{
register int i=20;
printf("\n\t %d",i);
}
printf("\n\n\t %d",i);
getch();
}
Output :
20
10_
Static Storage Class :
o Keyword : static
o Storage Location : Main memory
o Initial Value : Zero and can be initialize once only.
o Life : depends on function calls and the whole application or program.
o Scope : Local to the block.
Syntax :
static [data_type] [variable_name];
Example :
static int a;
Program :
/* Program to demonstrate static storage class.
#include <stdio.h>
#include <conio.h>
void main()
{
int i;
void incre(void);
clrscr();
for (i=0; i<3; i++)
incre();
getch();
}
void incre(void)
{
int avar=1;
static int svar=1;
avar++;
svar++;
printf("\n\n Automatic variable value : %d",avar);
printf("\t Static variable value : %d",svar);
}
Output :
Automatic variable value : 2 Static variable value : 2
Example :
extern int a;
The variable access time is very fast as compared to other storage classes. But few registers are available for user
programs.
The variables of this class can be referred to as 'global or external variables.' They are declared outside the functions
and can be invoked at anywhere in a program.
Program :
/* Program to demonstrate external storage class.
#include <stdio.h>
#include <conio.h>
Output :
20
10_
Array :
Array is a collection of homogenous data stored under unique name. The values in an array is called as 'elements of
an array.' These elements are accessed by numbers called as 'subscripts or index numbers.' Arrays may be of any
variable type.
Array is also called as 'subscripted variable.'
Types of an Array :
1. One / Single Dimensional Array
2. Two Dimensional Array
Single / One Dimensional Array :
The array which is used to represent and store data in a linear form is called as 'single or one dimensional array.'
Syntax:
Example:
In above example, a is an array of type integer which has storage size of 3 elements. The total size would be 3 * 2 =
6 bytes.
* MEMORY ALLOCATION :
Program :
/* Program to demonstrate one dimensional array.
#include <stdio.h>
#include <conio.h>
void main()
{
int a[3], i;;
clrscr();
printf("\n\t Enter three numbers : ");
for(i=0; i<3; i++)
{
scanf("%d", &a[i]); // read array
}
printf("\n\n\t Numbers are : ");
for(i=0; i<3; i++)
{
printf("\t %d", a[i]); // print array
}
getch();
}
Output :
Numbers are : 9 4 6_
Features :
o Array size should be positive number only.
o String array always terminates with null character ('\0').
o Array elements are countered from 0 to n-1.
o Useful for multiple reading of elements (numbers).
Disadvantages :
o There is no easy method to initialize large number of array elements.
o It is difficult to initialize selected elements.
Two Dimensional Array :
The array which is used to represent and store data in a tabular form is called as 'two dimensional array.' Such type of
array specially used to represent data in a matrix form.
The following syntax is used to represent two dimensional array.
Syntax:
Example:
int a[3][3];
In above example, a is an array of type integer which has storage size of 3 * 3 matrix. The total size would be 3 * 3 *
2 = 18 bytes.
It is also called as 'multidimensional array.'
* MEMORY ALLOCATION :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int a[3][3], i, j;
clrscr();
printf("\n\t Enter matrix of 3*3 : ");
for(i=0; i<3; i++)
{
for(j=0; j<3; j++)
{
scanf("%d",&a[i][j]); //read 3*3 array
}
}
printf("\n\t Matrix is : \n");
for(i=0; i<3; i++)
{
for(j=0; j<3; j++)
{
printf("\t %d",a[i][j]); //print 3*3 array
}
printf("\n");
}
getch();
}
Output :
Matrix is :
3 4 5
6 7 2
1 2 3_
struct structure_nm
{
<data-type> element 1;
<data-type> element 2;
- - - - - - - - - - -
- - - - - - - - - - -
<data-type> element n;
}struct_var;
Example :
struct emp_info
{
char emp_id[10];
char nm[100];
float sal;
}emp;
Note :
* INSTANCES OF STRUCTURE :
Instances of structure can be created in two ways as,
Instance 1:
struct emp_info
{
char emp_id[10];
char nm[100];
float sal;
}emp;
Instance 2:
struct emp_info
{
char emp_id[10];
char nm[100];
float sal;
};
struct emp_info emp;
In above example, emp_info is a simple structure which consists of stucture members as Employee ID(emp_id),
Employee Name(nm), Employee Salary(sal).
* ACEESSING STRUCTURE MEMBERS :
Structure members can be accessed using member operator '.' . It is also called as 'dot operator' or 'period
operator'.
structure_var.member;
Program :
struct comp_info
{
char nm[100];
char addr[100];
}info;
void main()
{
clrscr();
printf("\n Enter Company Name : ");
gets(info.nm);
printf("\n Enter Address : ");
gets(info.addr);
printf("\n\n Company Name : %s",info.nm);
printf("\n\n Address : %s",info.addr);
getch();
}
Output :
<data_type> *pointer_name;
In above syntax,
* = variable pointer_name is a pointer variable.
pointer_name requires memory location
pointer_name points to a variable of type data type.
How to Use ?
int *tot;
Illustration :
int tot = 95;
Figure :
In above example, the statement instructs the system to find out a location for integer variable quantity and puts the
values 95 in that memory location.
* Features of Pointer :
Program :
#include <stdio.h>
#include <conio.h>
void main()
{
int a=10;
int *ptr;
clrscr();
ptr = &a;
printf("\n\t Value of a : %d", a);
scanf("\n\n\t Value of pointer ptr : %d", *ptr);
printf("\n\n\t Address of pointer ptr : %d", ptr);
getch();
}
Output :
Value of a : 10
union union_name
{
<data-type> element 1;
<data-type> element 2;
<data-type> element 3;
}union_variable;
Example:
union techno
{
int comp_id;
char nm;
float sal;
}tch;
In above example, it declares tch variable of type union. The union contains three members as data type of int, char,
float. We can use only one of them at a time.
* MEMORY ALLOCATION :
#include <stdio.h>
#include <conio.h>
union techno
{
int id;
char nm[50];
}tch;
void main()
{
clrscr();
printf("\n\t Enter developer id : ");
scanf("%d", &tch.id);
printf("\n\n\t Enter developer name : ");
scanf("%s", tch.nm);
printf("\n\n Developer ID : %d", tch.id);//Garbage
printf("\n\n Developed By : %s", tch.nm);
getch();
}
Output :
Developer ID : 25972
Developed By : technowell_
String Handling in C :
String :
A string is a collection of characters. Strings are always enlosed in double quotes as "string_constant".
Strings are used in string handling operations such as,
Counting the length of a string.
Comparing two strings.
Copying one string to another.
Converting lower case string to upper case.
Converting upper case string to lower case.
Joining two strings.
Reversing string.
Declaration :
The string can be declared as follow :
Syntax:
char string_nm[size];
Example:
char name[50];
String Structure :
When compiler assigns string to character array then it automatically suppliesnull character ('\0') at the end of
string. Thus, size of string = original length of string + 1.
char name[7];
name = "TECHNO"
Read Strings :
To read a string, we can use scanf() function with format specifier %s.
char name[50];
scanf("%s",name);
The above format allows to accept only string which does not have any blank space, tab, new line, form feed, carriage
return.
Write Strings :
To write a string, we can use printf() function with format specifier %s.
char name[50];
scanf("%s",name);
printf("%s",name);
string.h' is a header file which includes the declarations, functions, constants of string handling utilities. These string
functions are widely used today by many programmers to deal with string operations.
Some of the standard member functions of string.h header files are,
Function Name Description
Program :
/* Program to demonstrate string.h header file working.
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
char str[50];
clrscr();
printf("\n\t Enter your name : ");
gets(str);
printf("\nLower case of string: %s",strlwr(str));
printf("\nUpper case of string: %s",strupr(str));
printf("\nReverse of string: %s",strrev(str));
printf("\nLength of String: %d",strlen(str));
getch();
}
Output :
Program :
/* Program to demonstrate assert.h header file working.
#include <stdio.h>
#include <conio.h>
#include <assert.h>
void main()
{
clrscr();
assert(12 == 2);
getch();
}
Output :
Example :
/* Program to demonstrate ctype.h header file working.
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
void main()
{
int len, i;
char *str = "TECHNOEXAM";
clrscr();
len = strlen(str);
for(i=1;i<=len;i++)
{
str[i] = tolower(str[i]); //tolower()
}
printf("\n\t Using tolower() : %s"<,str);
for(i=1;i<=len;i++)
{
str[i] = toupper(str[i]); //toupper()
}
printf("\n\n\t Using toupper() : %s",str);
getch();
}
Output :
Parameters are passed as an array of pointers. It loads & executes new child
spawnv -
process.
Program :
/* Program to demonstrate process.h header file working.
#include <stdio.h>
#include <conio.h>
#include <process.h>
void main()
{
clrscr();
// under DOS PSP segment
printf("\n\t Program's process identification");
printf(" number is : %X",getpid());
getch();
}
Output :
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
char no[10];
clrscr();
printf("\n\t Using abs(-194): %d",abs(-194)); // 1
printf("\n\n\t Enter any number : ");
scanf("%s",no);
printf("\n\t Using atof() : %lf",atof(no)); // 2
printf("\n\n\t Using atoi() : %d",atoi(no)); // 3
getch();
}
Output :
Program :
/* Program to demonstrate graphics.h header file working.
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main()
{
int gdriver=DETECT, gmode;
clrscr();
initgraph(&gdriver,&gmode,"c:\\tc\\bgi");
circle(70,70,20);
getch();
closegraph();
}
Output :