Programming for Problem Solving Notes All Unit in One_copy
Programming for Problem Solving Notes All Unit in One_copy
SANTOSH KUMAR
PPS Page 1
UNIT I
Computer systems:
A Computer is an electronic device which performs operations such as accepts data
As an input, store the data, manipulate or process the data and produce the results an output.
Main task performed by a computer
• Accept the data
• Process or manipulate the data
• Display or store the result in the form of human understanding
• Store the data, instructions and results.
Computer hardware is the collection of physical elements that comprise a computer system.
Computer software is a collection of computer programs and related data that provides the
instructions for a computer what to do and how to do it. Software refers to one or more computer
programs and data held in the storage of the computer for some purpose
PPS Page 2
Basically computer software is of three main types
PPS Page 3
• Image editing
Computing Environment:
Time-Sharing Environment:
In the time-sharing environment, all computing must be done by the central computer. The central
computer the shared resources, it manage the shared data and printing. Employees in large
companies often work in what is known as time sharing environment. In the time sharing
environment, many users are connected to one or more computers. These computers may be mini
computers and central mainframes. In this environment the output devices, auxiliary storage
devices are shared by all the users.
PPS Page 4
Client/Server Environment
Client/Server computing environment splits the computing function between a
central computer and user‟s computers. The users are given personal computers or
work stations so that some of the computation responsibility can be moved from the
central computer and assigned to the workstations. In the client/server environment
the users micro computers or work stations are called the client. The central
computer which may be a powerful micro computer, minicomputer or central
mainframe system is known as server.
PPS Page 5
COMPUTER LANGUAGES
In order to communicate with the computer user also needs to have a language that should be
understood by the computer. For this purpose, different languages are developed for performing
different types of work on the computer. Basically, languages are divided into two categories
according to their interpretation.
PPS Page 6
Advantages of Machine Language
i) It makes fast and efficient use of the computer.
ii) It requires no translator to translate the code i.e. Directly understood by the computer
Disadvantages of Machine Language:
i) All operation codes have to be remembered iv) These
languages are machine dependent i.e. a particular
Machine language can be used on only one type of computer
Assembly Language
It was developed to overcome some of the many inconveniences of machine language. This is
another low level but a very important language in which operation codes and operands are given
in the form of alphanumeric symbols instead of 0‟s and l‟s. These alphanumeric symbols will be
known as mnemonic codes and can have maximum up to 5 letter combination e.g. ADD for
addition, SUB for subtraction, START,LABEL etc. Because of this feature it is also known as
„Symbolic Programming Language‟. This language is also very difficult and needs a lot of practice
to master it because very small
English support is given to this language. The language mainly helps in compiler orientations. The
instructions of the Assembly language will also be converted to machine codes by language
translator to be executed by the computer.
PPS Page 7
i) It is easier to understand and use as compared to machine language.
ii)It is easy to locate and correct errors. iii)
It is modified easily
Disadvantages of Assembly Language
i) Like machine language it is also machine dependent.
ii) Since it is machine dependent therefore programmer Should have the knowledge of the
hardware also.
High Level Languages
High level computer languages give formats close to English language and the purpose of
developing high level languages is to enable people to write programs easily and in their own
native language environment (English). High-level languages are basically symbolic languages
that use English words and/or mathematical symbols rather than mnemonic codes. Each instruction
in the high level language is translated into many machine language instructions thus showing one-
to-many translation
Types of High Level Languages
Many languages have been developed for achieving different variety of tasks, some are fairly
specialized others are quite general purpose. These are categorized according to their use as
a) Algebraic Formula-Type Processing. These languages are oriented towards the
computational procedures for solving mathematical and statistical problem
Examples are
• BASIC (Beginners All Purpose Symbolic Instruction Code).
• FORTRAN (Formula Translation).
• PL/I (Programming Language, Version 1).
• ALGOL (Algorithmic Language).
• APL (A Programming Language).
b) Business Data Processing:
• These languages emphasize their capabilities for maintaining data processing procedures
and files handling problems. Examples are:
• COBOL (Common Business Oriented Language).
• RPG (Report Program Generator
b) String and List Processing: These are used for string manipulation including search for
patterns, inserting and deleting characters. Examples are:
• LISP (List Processing).
PPS Page 8
• Prolog (Program in Logic).
Object Oriented Programming Language
In OOP, the computer program is divided into objects. Examples are:
• C++
• Java
e) Visual programming language: these are designed for building Windows-based applications
Examples are:
• Visual Basic
• Visual Java
• Visual C
PPS Page 9
Following are the advantages of a high level language:
• User-friendly
• Similar to English with vocabulary of words and symbols Therefore it is easier to
learn.
• They are easier to maintain.
Disadvantages of High Level Language
• A high-level language has to be translated into the machine language by a translator and thus a
price in computer time is paid.
• The object code generated by a translator might be inefficient Compared to an equivalent
assembly language program
1. Writing and editing the program using Text editor (source code).
2. Compile the program using any C compiler.(.bak file)
3. Linking the program with the required library modules(object file)
4. Executing the program. (.Exe file)
PPS Page 10
Loading program: The process of transferring a program from secondary storage to
main memory for execution is called loading a program. A program called loader
does loading.
Executing program: Execution is the last step. In this step program starts
execution. Its instructions start working and output of the program display on the
screen.
Properties of an Algorithm:
1) Finiteness: - An algorithm terminates after a finite numbers of steps.
2) Definiteness: - Each step in algorithm is unambiguous. This means that the action specified
by the step cannot be interpreted (explain the meaning of) in multiple ways & can be
performed without any confusion.
3) Input: - An algorithm accepts zero or more inputs
PPS Page 11
4) Output:- An algorithm should produce at least one output.
5) Effectiveness: - It consists of basic instructions that are realizable. This means that the
instructions can be performed by using the given inputs in a finite amount of time.
Writing an algorithm
An algorithm can be written in English, like sentences and using mathematical
formulas. Sometimes algorithm written in English like language is Pseudo code.
Examples
1) Finding the average of three numbers
1. Let a,b,c are three integers
2. Let d is float
3. Display the message “Enter any three integers:”
4. Read three integers and stores in a,b,c
5. Compute the d = (a+b+c)/3.0
6. Display “The avg is:” , d 7. End.
◼ Example 1: Write an algorithm to determine a student‟s final grade and indicate whether it
is passing or failing. The final grade is calculated as the average of four marks.
Pseudocode::
◼ Input a set of 4 marks
◼ Calculate their average by summing and dividing by 4 ◼ if average is below 50
Print “FAIL”
else
Print “PASS”
◼ Detailed Algorithm :
◼ Step 1: Input M1,M2,M3,M4
Step 2: GRADE (M1+M2+M3+M4)/4
Step 3: if (GRADE < 50) then
Print “FAIL”
else
Print “PASS”
endif
Flowcharts :
The pictorial representation of algorithm is called flowchart.
PPS Page 12
2 : as different symbols are used to specify the type of operation performed, it is easier to
understand the complex programs with the help of flowcharts.
Flowchart Symbols
S.NO Description Symbols
PPS Page 13
Algorithm to find whether a number even or odd:
PPS Page 14
FLOWCHART : start
read num
If
stop
System Development:
PPS Page 15
Or
Systems Requirements
Analysis
Design
Coding
System Test
Maintenance
1. Statement of Problem
a) Working with existing system and using proper questionnaire, the problem should be
explained clearly.
b) What inputs are available, what outputs are required and what is needed for creating workable
solution, should be understood clearly.
2. Analysis
a) The method of solutions to solve the problem can be identified.
b) We also judge that which method gives best results among different methods of solution.
3. Design
a) Algorithms and flow charts will be prepared.
b) Focus on data, architecture, user interfaces and program components.
4. System Test
The algorithms and flow charts developed in the previous steps are converted into actual programs
in the high level languages like C.
PPS Page 16
a. Compilation
The process of translating the program into machine code is called as Compilation. Syntactic errors
are found quickly at the time of compiling the program. These errors occur due to the usage of
wrong syntaxes for the statements.
Eg: x=a*y+b
There is a syntax error in this statement, since, each and every statement in C language ends with a
semicolon (;).
b. Execution
The next step is Program execution. In this phase, we may encounter two types of errors. Runtime
Errors: these errors occur during the execution of the program and terminate the program
abnormally.
Logical Errors: these errors occur due to incorrect usage of the instructions in the program. These
errors are neither detected during compilation or execution nor cause any stoppage to the program
execution but produces incorrect output.
5. Maintenance
We are maintenance the software by updating the information, providing the security and license
for the software.
What is C?
C is a programming language developed at AT & T‟s Bell Laboratories of USA in 1972. It was
designed and written by Dennis Ritche. Dennis Ritchie is known as the founder of c
language.
It was developed to overcome the problems of previous languages such as B, BCPL etc.
Features of C
1. Portability or machine independent
2. Sound and versatile language 3. Fast program
execution.
4. An extendible language.
5. Tends to be a structured language.
Historical developments of C(Background)
Year Language Developed by Remarks
PPS Page 17
1960 ALGOL International committee Too general, too abstract
/* Documentation section */
/* Link section */
/* Definition section */ /*
Global declaration section */
main()
{
Declaration part
Executable part (statements)
}
/* Sub-program section */
➢ The documentation section is used for displaying any information about the
program like the purpose of the program, name of the author, date and time written
etc, and this section should be enclosed within comment lines. The statements in the
documentation section are ignored by the compiler.
➢ The link section consists of the inclusion of header files.
➢ The definition section consists of macro definitions, defining constants etc,.
➢ Anything declared in the global declaration section is accessible throughout the
program, i.e. accessible to all the functions in the program.
➢ main() function is mandatory for any program and it includes two parts, the
declaration part and the executable part.
PPS Page 18
➢ The last section, i.e. sub-program section is optional and used when we require
including user defined functions in the program.
First C Program
Before starting the abcd of C language, you need to learn how to write, compile and run the first c
program.
To write the first c program, open the C console and write the following code:
1. #include <stdio.h>
2. #include <conio.h>
3. void main(){
4. printf("Hello C Language");
5. getch();
6. }
#include <stdio.h> includes the standard input output library functions. The printf() function is
defined in stdio.h .
#include <conio.h> includes the console input output library functions. The getch() function is
defined in conio.h file.
void main() The main() function is the entry point of every program in c language. The void
keyword specifies that it returns no value.
getch() The getch() function asks for a single character. Until you press any key, it blocks the
screen.
C TOKENS: The smallest individual units are known as tokens. C has six types of tokens.
1: Identifiers
2: Keywords
3: Constants
4: Strings
5: Special Symbols
6: Operators
PPS Page 19
Identifiers:
Identifiers refer to the names of variables, constants, functions and arrays. These are user-defined
names is called Identifiers. These identifier are defined against a set of rules.
2. The first character of an identifier can only contain alphabet( a-z , A-Z ) or underscore ( _
).
3. Identifiers are also case sensitive in C. For example name and Name are two different
identifier in C.
Ex : Valid Invalid
STDNAME Return
SUB $stay
TOT_MARKS 1RECORD
Y2K
Keywords: A keyword is a reserved word. All keywords have fixed meaning that means we
cannot change. Keywords serve as basic building blocks for program statements. All keywords
must be written in lowercase. A list of 32 keywords in c language is given below:
PPS Page 20
goto if int long return
Data Types/Types:
To store data the program must reserve space which is done using datatype. A datatype is a
keyword/predefined instruction used for allocating memory for data. A data type specifies
the type of data that a variable can store such as integer, floating, character etc. It used for
declaring/defining variables or functions of different types before to use in a program.
PPS Page 21
Void Data Type void
The basic data types are integer-based and floating-point based. C language supports both signed
and unsigned literals. The memory size of basic data types may change according to 32 or 64 bit
operating system. Let‟s see the basic data types. Its size is given according to 32 bit architecture.
PPS Page 22
long int or signed long int 4 -2147483648 to 2147483647 %ld
Variables
A variable is a name of memory location. It is used to store data. Variables are changeable, we
can change value of a variable during execution of a program. . It can be reused many times.
Declaration of Variables : A variable can be used to store a value of any data type. The
declaration of variables must be done before they are used in the program. The general format for
declaring a variable.
PPS Page 23
Ex : int x,y,z;
float a,b;
char m,n;
Assigning values to variables : values can be assigned to variables using the assignment
operator (=). The general format statement is :
Ex : x=100;
a= 12.25;
m=‟f‟;
we can also assign a value to a variable at the time of the variable is declared. The general format
of declaring and assigning value to a variable is :
Ex ; int x=100;
float a=12.25;
char m=‟f‟;
Types of Variables in C
1. local variable
2. global variable
3. static variable
Constants
Constants refer to fixed values that do not change during the execution of a program.
PPS Page 24
CONSTANTS
TYPES OF C CONSTANT:
1. Integer constants
2. Real or Floating point constants
3. Character constants
4. String constants
5. Backslash character constants
Integer constants:
An integer constant is a numeric constant (associated with number) without any fractional or
exponential part. There are three types of integer constants in C programming:
For example:
In C programming, octal constant starts with a 0 and hexadecimal constant starts with a
0x.
PPS Page 25
b) Decimal Integer value with base 10.
c) Decimal Integer should not prefix with 0.
d) It allows only sign (+,-).
e) No special character allowed in this integer.
Ex : valid invalid
7 $77
77 077
+77 7,777
-77
2 : Octal : An integer constants with base 8 is called octal. These rules are :
EX : VALID INVALID
0123 123 -> it because no prefix with 0
+0123 0128 -> because digits from 0 to 7. -
0123
Ex : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 b)
it should prefix with 0X or 0x.
c) it allows sign (+,-).
d) No special character is allowed.
EX : OX1a, ox2f
PPS Page 26
-2.0
0.0000234
-0.22E-5
Real Notation : The real notation is represented by an integer followed by a decimal point and the
fractional(decimal) part. It is possible to omit digits before or after the decimal point.
Ex : 15 ............................................................................................................................... 32
30 .............................................................................................. 75
-9.52 ............................................................................................ 92
+.94
mantisha e exponent
The mantisha is either a real/floating point number expressed in decimal notation or an integer
and the exponent is an integer number with an optional sign. The character e separating the
mantisha and the exponent can be written in either lowercase or uppercase.
Ex : 1.5E-2
100e+3
-2.05e2
Character Constant:
Single Character Constant : A character constant is either a single alphabet, a single digit, a
single special symbol enclosed within single inverted commas.
PPS Page 27
„A‟ „ab‟
String constant : A string constant is a sequence of characters enclosed in double quote, the
characters may be letters, numbers, special characters and blank space etc
a) \n newline
b) \r carriage return
c) \t tab
d) \v vertical tab
e) \b backspace
f) \f form feed (page feed)
g) \a alert (beep)
h) \‟ single quote(„)
i) \” double quote(“)
j) \? Question mark (?)
k) \\ backslash (\)
PPS Page 28
5. clrscr();
6. printf("The value of PI is: %f",PI);
7. getch();
8. } Output:
The value of PI is: 3.140000
2) C #define preprocessor
The #define preprocessor is also used to define constant.
C#define
The #define preprocessor directive is used to define constant or micro substitution. It can use any
basic data type.
Syntax:
#define token value
Let's see an example of #define to define a constant.
#include <stdio.h>
1. #define PI 3.14
2. main() {
3. printf("%f",PI);
4. } Output:
3.140000
Input / Output (I/O) Functions : In „C‟ language, two types of Input/Output functions are
available, and all input and output operations are carried out through function calls. Several
functions are available for input / output operations in „C‟. These functions are collectively known
as the standard i/o library.
Input: In any programming language input means to feed some data into program. This can be
given in the form of file or from command line.
Output: In any programming language output means to display some data on screen, printer or in
any file.
The Standard Files
C programming treats all the devices as files. So devices such as the display are addressed in the
same way as files and the following three files are automatically opened when a program executes
to provide access to the keyboard and screen.
Standard File File Pointer Device
PPS Page 29
Standard input stdin Keyboard
I / O Functions
scanf() print()
getc() putc()
fscanf() fprintf() getchar() putchar()
gets() puts()
getch()
getche()
. Formated I/O Functions : formatted I/O functions operates on various types of data.
1 : printf() : output data or result of an operation can be displayed from the computer to a
standard output device using the library function printf(). This function is used to print any
combination of data.
PPS Page 30
Formating string : it prints all the character given in doublequotes (“ “) except formatting
specifier.
scanf() : input data can be entered into the computer using the standard input „C‟ library
function called scanf(). This function is used to enter any combination of input.
The scanf() function is used to read information from the standard input device (keyboard).
Each variable name (argument) must be preceeded by an ampersand (&). The (&) symbol gives
the meaning “address of “ the variable.
a) character I/O:
a) String I/O:
1. gets(): Used for accepting any string from the standard input(stdin)
eg:gets()
PPS Page 31
2. puts(): Used to display a string or character array Eg:puts()
3. Cgets():read a string from the console eg; cgets(char *st) 4.
Cputs():display the string to the console eg; cputs(char *st)
Ex : a+b;
Where a,b are operands and + is the operator.
Types of Operator :
1) Arithmetic Operators.
2) Relational Operators.
3) Logical Operators.
4) Assignment Operators. 5). Unary Operators.
6) Conditional Operators.
7) Special Operators.
8) Bitwise Operators.
9) Shift Operators.
Arithmetic Operators
An arithmetic operator performs mathematical operations such as addition, subtraction and
multiplication on numerical values (constants and variables). C Program to demonstrate the
working of arithmetic operators
#include <stdio.h> void
main()
{
int a = 9,b = 4, c;
c = a+b;
printf("a+b = %d \n",c);
c = a-b; printf("a-b =
%d \n",c);
c = a*b;
printf("a*b = %d \n",c);
c=a/b;
PPS Page 32
printf("a/b = %d \n",c);
c=a%b;
printf("Remainder when a divided by b = %d \n",c);
}
Output
a+b = 13
a-b = 5
a*b = 36
a/b = 2
Remainder when a divided by b=1
Relational Operators. A relational operator checks the relationship between two operands.
If the relation is true, it returns 1; if the relation is false, it returns value 0.
Operands may be variables, constants or expressions.
PPS Page 33
//false printf("%d < %d = %d \n", a, b, a < b);
//true return 0; }
Output
5 == 5 = 1
5 == 10 = 0
5>5=0
5 > 10 = 0
5<5=0
5 < 10 = 1
5 != 5 = 0
5 != 10 = 1
5 >= 5 = 1
5 >= 10 = 0
5 <= 5 = 1
5 <= 10 = 1
PPS Page 34
Logical Operators.
These operators are used to combine the results of two or more conditions. An expression
containing logical operator returns either 0 or 1 depending upon whether expression results true or
false. Logical operators are commonly used in decision making in C programming.
Operator Meaning Example Return value
&& Logical AND (9>2)&&(17>2) 1
|| Logical OR (9>2) || (17 = = 7) 1
! Logical NOT 29!=29 0
Logical AND : If any one condition false the complete condition becomes false.
Truth Table
Op1 Op2 Op1 && Op2
true true true
true false false
false true false
false false false
Logical OR : If any one condition true the complete condition becomes true.
Truth Table
Op1 Op2 Op1 // Op2
true true true
true false true
false true true
false false false
Logical Not : This operator reverses the value of the expression it operates on i.e, it makes a
true expression false and false expression true.
Op1 Op1 !
true false
false true
// C Program to demonstrate the working of logical operators
#include <stdio.h>
PPS Page 35
equals to %d \n", result); result = (a = b) && (c <
Output
(a = b) || (c < b) equals to 1
(a != b) || (c < b) equals to 0
!(a != b) equals to 1
!(a == b) equals to 0
Assignment Operators. Assignment operators are used to assign a value (or) an expression
(or) a value of a variable to another variable.
Ex : x=10;
y=a+b;
z=p;
PPS Page 36
Compound assignment operator:
„C‟ provides compound assignment operators to assign a value to variable in order to assign a
new value to a variable after performing a specified operation.
#include
<stdio.h> int
main() { int a =
5, c; c = a;
printf("c = %d \n",
c); c += a; // c = c+a
c -= a; // c = c-a
c *= a; // c = c*a
c /= a; // c = c/a
PPS Page 37
c %= a; // c = c%a
return 0; }
Output
c=5 c
= 10 c
=5 c
= 25 c
=5 c
=0
1. Increment operator is used to increment the current value of variable by adding integer 1.
We have two types of increment operator i.e Pre-Increment and Post-Increment Operator.
Pre-Increment
Pre-increment operator is used to increment the value of variable before using in the expression. In the
Pre-Increment value is first incremented and then used inside the expression.
b = ++y;
PPS Page 38
In this example suppose the value of variable „y‟ is 5 then value of variable „b‟ will be 6 because
the value of „y‟ gets modified before using it in a expression.
Post-Increment
Post-increment operator is used to increment the value of variable as soon as after executing
expression completely in which post increment is used. In the Post-Increment value is first used in
a expression and then incremented.
b = x++;
In this example suppose the value of variable „x‟ is 5 then value of variable „b‟ will be 5 because
old value of „x‟ is used.
Note :
We cannot use increment operator on the constant values because increment operator operates on
only variables. It increments the value of the variable by 1 and stores the incremented value back
to the variable
b = ++5;
or b =
5++;
Operator Meaning
++x Pre increment
- -x Pre decrement
PPS Page 39
x++ Post increment
x-- Post decrement
Where
1 : ++x : Pre increment, first increment and then do the operation.
2 : - -x : Pre decrement, first decrements and then do the operation. 3 : x++ : Post
increment, first do the operation and then increment.
4 : x- - : Post decrement, first do the operation and then decrement.
Output
++a = 11
--b = 99
++c = 11.500000
++d = 99.500000
#include<stdio.h>
void main() {
int i = 1;
printf("%d %d %d", i, ++i, i++);
}
Output : 3 3 1
Pictorial representation
PPS Page 40
Explanation of program
I am sure you will get confused after viewing the above image and output of program.
1. Whenever more than one format specifiers (i.e %d) are directly or indirectly related with
same variable (i,i++,++i) then we need to evaluate each individual expression from right
to left.
2. As shown in the above image evaluation sequence of expressions written inside printf
will be – i++,++i,i
3. After execution we need to replace the output of expression at appropriate place
No Step Explanation
Evaluate
1 At the time of execution we will be using older value of i = 1
i++
Evaluate At the time of execution we will be increment value already modified after
2
++i step 1 i.e i = 3
PPS Page 41
Output :
2
2
Explanation of Program
#include
<stdio.h> int
main(){ char
February; int
days;
printf("If this year is leap year, enter 1. If not enter any integer: ");
scanf("%c",&February);
PPS Page 42
// If test condition (February == 'l') is true, days equal to 29.
// If test condition (February =='l') is false, days equal to 28.
days = (February == '1') ? 29 : 28;
printf("Number of days in February = %d",days);
return 0;
}
Output
If this year is leap year, enter 1. If not enter any integer: 1
Number of days in February = 29
Bitwise Operators:
Bitwise operators are used to manipulate the data at bit level. It operates on integers only. It may
not be applied to float.In arithmetic-logic unit (which is within the CPU), mathematical operations
like: addition, subtraction, multiplication and division are done in bit-level which makes processing
faster and saves power. To perform bit-level operations in C programming, bitwise operators are
used.
Operator Meaning
& Bitwise AND
| Bitwise OR
^ Bitwise XOR
<< Shift left
>> Shift right
~ One‟s complement.
PPS Page 43
#include
<stdio.h> int
main() {
int a = 12, b = 25;
printf("Output = %d", a&b);
return 0; }
Output
Output =8
Bitwise OR operator |
The output of bitwise OR is 1 if at least one corresponding bit of two operands is 1. In C
Programming, bitwise OR operator is denoted by |.
12 = 00001100 (In Binary)
25 = 00011001 (In Binary)
Bitwise OR Operation of 12 and 25
00001100
| 00011001
________
00011101 = 29 (In decimal)
}
Output
Output =29
PPS Page 44
The result of bitwise XOR operator is 1 if the corresponding bits of two operands are opposite. It
is denoted by ^.
12 = 00001100 (In Binary)
25 = 00011001 (In Binary)
Bitwise XOR Operation of 12 and 25
00001100
| 00011001
________
00010101 = 21 (In decimal)
Output
Output = 21
~ 00100011
________
11011100 = 220 (In decimal)
Twist in bitwise complement operator in C Programming
PPS Page 45
For any integer n, bitwise complement of n will be -(n+1). To understand this, you should have
the knowledge of 2's complement.
2's Complement
Two's complement is an operation on binary numbers. The 2's complement of a number is equal to
the complement of that number plus 1. For example:
The bitwise complement of 35 is 220 (in decimal). The 2's complement of 220 is -36. Hence, the
output is -36 instead of 220.
#include <stdio.h>
%d\n",~35); printf("complement =
%d\n",~-12);
return 0; }
PPS Page 46
Output
Complement = -36
Complement = 11
Right shift
operator Left shift
operator.
Right shift operator shifts all bits towards right by certain number of specified bits. It is denoted
by >>.
Left shift operator shifts all bits towards left by certain number of specified bits. It is denoted by
<<.
Special Operators
1 ) Comma Operator :The comma operator is used to separate the statement elements such as
variables, constants or expressions, and this operator is used to link the related expressions
together, such expressions can be evaluated from left to right and the value of right most
expressions is the value of combined expressions
2 ) Sizeof Operator : The sizeof() is a unary operator, that returns the length in bytes o the
specified variable, and it is very useful to find the bytes occupied by the specified variable in the
memory.
Syntax : sizeof(variable-name);
int a;
Ex : sizeof(a); //OUTPUT-----2bytes
PPS Page 47
#include <stdio.h> int main() { int a, e[10];
float b; double c; char d; printf("Size of
int=%lu bytes\n",sizeof(a)); printf("Size of
float=%lu bytes\n",sizeof(b)); printf("Size of
double=%lu bytes\n",sizeof(c)); printf("Size
of char=%lu byte\n",sizeof(d));
printf("Size of integer type array having 10 elements = %lu bytes\n",
sizeof(e)); return 0; }
Output
Expressions
Operator Precedence : Arithmetic Operators are evaluvated left to right using the
precedence of operator when the expression is written without the paranthesis.They are two
levels of arithmetic operators in C.
1 : High Priority * / %
2 : Low Priority + -.
PPS Page 48
Arithmetic Expression evaluation is carried out using the two phases from left to right.
1 : First phase : The highest priority operator are evaluated in the 1st phase.
2 : Second Phase : The lowest priority operator are evaluated in the 2nd phase.
Ex : a=x-y/3+z*2+p/4.
x=7, y=9, z=11, p=8.
a= 7-9/3+11*2+8/4.
1st phase :
1 : a = 7-3+11*2+8/4
2 : a = 7-3+22+8/4 3 : a = 7-3+22+2 2nd phase :
1 : a = 4+22+2
2 : a = 26+2
3 : a = 28
Whenever parentheses are used, the expressions within parantheses highest priority. If two or
more sets of paranthesis appear one after another. The expression contained in the left-most set is
evaluated first and the right-most in the last.
1st phase :
1 : 9-12/6*(2-1)
2 : 9-12/6*1 2nd phase : 1 : 9-2*1 2 : 9-2.
3rd phase :
1 : 7.
Rules for Evaluation of Expression :
Every operator has a precedence value. An expression containing more than one
oerator is known as complex expression. Complex expressions are executed according to
precedence of operators.
PPS Page 49
Associativity specifies the order in which the operators are evaluated with the same
precedence in a complex expression. Associativity is of two ways, i.e left to ringht and right to
left. Left to right associativity evaluates an expression starting from left and moving towards right.
Right to left associativity proceds from right to left.
PPS Page 50
, Comma operator 15 L-R (left to right)
Syntax:
(type_name) expression;
1. int f= 9/4;
2. printf("f : %d\n", f );//Output: 2
Example:
main()
); getchar();
or
Type Casting - C Programming
PPS Page 51
Type casting refers to changing an variable of one data type into another. The compiler will
automatically change one type of data into another if it makes sense. For instance, if you assign an
integer value to a floating-point variable, the compiler will convert the int to a float. Casting allows
you to make this type conversion explicit, or to force it when it wouldn‟t normally happen.
When the type conversion is performed automatically by the compiler without programmers
intervention, such type of conversion is known as implicit type conversion or type promotion.
int x;
%c*/ }
The type conversion performed by the programmer by posing the data type of the expression of
specific type is known as explicit type conversion. The explicit type conversion is also known as
type casting.
(data_type)expression;
where, data_type is any valid c data type, and expression may be constant, variable or expression.
For example,
int x;
char*/
PPS Page 52
}
The following rules have to be followed while converting the expression from one type to another
to avoid the loss of information:
Example
If we want to get the exact value of 7/5 then we need explicit casting from int to float:
Integer Promotion
Integer promotion is the process by which values of integer type "smaller" than int or unsigned int
are converted either to int or unsigned int. Consider an example of adding a character with an
integer −
PPS Page 53
c; printf("Value of sum : %d\n",
sum );
When the above code is compiled and executed, it produces the following result −
Here, the value of sum is 116 because the compiler is doing integer promotion and converting
the value of 'c' to ASCII before performing the actual addition operation.
PPS Page 54
UNIT II
STATEMENTS
A statement causes the computer to carry out some definite action. There are three different
classes of statements in C:
Null statement
PPS Page 55
A null statement consisting of only a semicolon and performs no operations. It can appear
wherever a statement is expected. Nothing happens when a null statement is executed. Syntax: -
;
Statements such as do, for, if, and while require that an executable statement appear as the
statement body. The null statement satisfies the syntax requirement in cases that do not need a
substantive statement body.
The Null statement is nothing but, there is no body within loop or any other statements in C.
for (i=0;i<10;i++)
//empty body
Expression
PPS Page 56
Most of the statements in a C program are expression statements. An expression statement is
simply an expression followed by a semicolon. The lines
i = 0; i = i
+ 1;
are all expression statements. In C, however, the semicolon is a statement terminator. Expression
statements do all of the real work in a C program. Whenever you need to compute new values for
variables, you'll typically use expression statements (and they'll typically contain assignment
operators). Whenever you want your program to do something visible, in the real world, you'll
typically call a function (as part of an expression statement). We've already seen the most basic
example: calling the function printf to print text to the screen.
Note -If no expression is present, the statement is often called the null statement.
Return
The return statement terminates execution of a function and returns control to the calling function,
with or without a return value. A function may contain any number
of return statements. The return statement has syntax:
return expression(opt);
If present, the expression is evaluated and its value is returned to the calling function. If necessary,
its value is converted to the declared type of the containing function's return value.
A return statement with an expression cannot appear in a function whose return type is void . If
there is no expression and the function is not defined as void , the return value is undefined. For
example, the following main function returns an unpredictable value to the operating system:
main ( )
return;
Compound statements
PPS Page 57
A compound statement (also called a "block") typically appears as the body of another statement,
such as the if statement, for statement, while statement, etc
A Compound statement consists of several individual statements enclosed within a pair of braces
{ }. The individual statements may themselves be expression statements, compound statements or
control statements. Unlike expression statements, a compound statement does not end with a
semicolon. A typical Compound statement is given below.
pi=3.14;
area=pi*radius*radius;
Example:
A selection statement selects among a set of statements depending on the value of a controlling
expression. Or
PPS Page 58
Moving execution control from one place/line to another line based on condition
Or
Conditional statements control the sequence of statement execution, depending on the value of a
integer expression
1: if
2: switch.
1: simple if statement.
2: if –else statement
4: else if ladder.
if statement.
The if statement controls conditional branching. The body of an if statement is executed if the
value of the expression is nonzero. Or if statement is used to execute the code if condition
is true. If the expression/condition is evaluated to false (0), statements inside the body of if is
skipped from execution.
Syntax : if(condition/expression)
true statement;
} statement-x;
If the condition/expression is true, then the true statement will be executed otherwise the true
statement block will be skipped and the execution will jump to the statement-x. The „true
statement‟ may be a single statement or group of statement.
PPS Page 59
If there is only one statement in the if block, then the braces are optional. But if
there is more than one statement the braces are compulsory
Flowchart
Example:
#include<stdio.h
a=15,b=20;
if(b>a)
{ printf("b is
greater");
PPS Page 60
}
Output
b is greater
#include
<stdio.h> int
main() {
int number;
return 0; }
Output 1
Enter an integer: -2 You
entered -2.
The if statement is easy.
Output 2
Enter an integer: 5
The if statement in C programming is easy.
If-else statement : The if-else statement is an extension of the simple if statement. The general
form is. The if...else statement executes some code if the test expression is true (nonzero) and some
other code if the test expression is false (0).
Syntax : if (condition)
{
true statement;
}
else
{
false statement;
PPS Page 61
}
statement-x;
If the condition is true , then the true statement and statement-x will be executed and if the
condition is false, then the false statement and statement-x is executed. Or
If test expression is true, codes inside the body of if statement is executed and, codes inside the
body of else statement is skipped.
If test expression is false, codes inside the body of else statement is executed and, codes inside the
body of if statement is skipped.
Flowchart
Example:
// Program to check whether an integer entered by the user is odd or even
// True if remainder is 0
if( number%2 == 0 )
PPS Page 62
printf("%d is an even integer.",number);
else
printf("%d is an odd
integer.",number); return 0; }
Output
Enter an integer: 7
7 is an odd integer.
Syntax : if(condition-1)
{ {
if (condition-2)
{
statement-1;
}
else {
statement-2;
}
}
else {
statement-3;
}
statement-x;
If the condition-1 is false, the statement-3 and statement-x will be executed. Otherwise it
continues to perform the second test. If the condition-2 is true, the true statement-1 will be
executed otherwise the statement-2 will be executed and then the control is transferred to the
statement-x
Flowchart
PPS Page 63
Example
#include<stdio.h> int
var1, var2;
printf("Input the value of var1:");
scanf("%d", &var1);
printf("Input the value of var2:");
scanf("%d",&var2); if
(var1 !=var2)
{
printf("var1 is not equal to var2");
//Below – if-else is nested inside another if block
if (var1 >var2)
{
printf("var1 is greater than var2");
}
else
{
printf("var2 is greater than var1");
}
}
else
{
printf("var1 is equal to var2"); }
…
Else if ladder.
The if else-if statement is used to execute one code from multiple conditions.
Syntax : if( condition-1)
{
PPS Page 64
statement-1;
}
else if(condition-2)
{
statement-2;
}
else if(condition-3)
{
statement-3;
}
else if(condition-n)
{
statement-n;
}
else
{
default-statement;
}
statement-x;
Flowchart
Example
PPS Page 65
#include<stdio.h>
#include<conio.h
> void main(){
int number=0;
clrscr();
printf("enter a number:");
scanf("%d",&number);
if(number==10){
printf("number is equals to 10");
}
else if(number==50){
printf("number is equal to 50");
}
else if(number==100){
printf("number is equal to 100");
}
else{
printf("number is not equal to 10, 50 or 100");
}
getch();
}
Points to Remember
1. In if statement, a single statement can be included without enclosing it into curly braces { }
2. int a = 5;
3. if(a > 4)
4. printf("success");
No curly braces are required in the above case, but if we have more than one statement inside
5. == must be used for comparison in the expression of if condition, if you use = the expression will
8. printf("hello");
In above example, hello will be printed.
PPS Page 66
Switch statement : when there are several options and we have to choose only one option from
the available ones, we can use switch statement. Depending on the selected option, a particular
task can be performed. A task represents one or more statements.
Syntax:
switch(expression)
{ case value-
1:
statement/block-1;
break; case value-2:
statement/block t-2;
break; case value-3:
statement/block -3;
break; case value-4:
statement/block -4;
break; default:
default- statement/block t; break;
PPS Page 67
}
The expression following the keyword switch in any „C‟ expression that must yield an integer
value. It must be ab integer constants like 1,2,3 .
The keyword case is followed by an integer or a character constant, each constant in each
must be different from all the other.
First the integer expression following the keyword switch is evaluated. The value it gives
is searched against the constant values that follw the case statements. When a match is found, the
program executes the statements following the case. If no match is found with any of the case
statements, then the statements follwing the default are executed.
main()
{ int
a;
printf("Please enter a no between 1 and 5: ");
scanf("%d",&a);
switch(a)
{ case 1: printf("You
chose One");
break;
case 2:
C PROGRAMMING Page 67
Flowchart
PPS Page 69
Points to Remember
It isn't necessary to use break after each block, but if you do not use it, all the consecutive block
of codes will get executed after the matching block.
1. int i = 1;
2. switch(i)
3. {
4. case 1:
5. printf("A"); // No break
6. case 2:
7. printf("B"); // No break
8. case 3:
9. printf("C");
10. break;
11. }
Output : A B C
The output was supposed to be only A because only the first case matches, but as there is no
break statement after the block, the next blocks are executed, until the cursor encounters a break.
default case can be placed anywhere in the switch case. Even if we don't include the default case
PPS Page 70
Iteration Statements/ Loop Control Statements
How it Works
A sequence of statements are executed until a specified condition is true. This sequence of
statements to be executed is kept inside the curly braces { } known as the Loop body. After every
execution of loop body, condition is verified, and if it is found to be true the loop body is executed
again. When the condition check returns false, the loop body is not executed.
The loops in C language are used to execute a block of code or a part of the program several
times. In other words, it iterates/repeat a code or group of code many times.
Or Looping means a group of statements are executed repeatedly, until some logical condition is
satisfied.
Suppose that you have to print table of 2, then you need to write 10 lines of code.By using the
loop statement, you can do it by 2 or 3 lines of code only.
PPS Page 71
C language provides three iterative/repetitive loops.
1 : while loop
2 : do-while loop
3 : for loop
initialization ;
while (condition)
or decrement ;
The while loop is an entry controlled loop statement, i.e means the condition is evaluated
first and it is true, then the body of the loop is executed. After executing the body of the loop, the
condition is once again evaluated and if it is true, the body is executed once again, the process of
repeated execution of the loop continues until the condition finally becomes false and the control
is transferred out of the loop.
#include<conio.h> void
main( )
int x;
PPS Page 72
x=1;
while(x<=10)
{ printf("%d\t",
x); x++; }
getch(); }
Output 1 2 3 4 5 6 7 8 9 10
#include<stdio.h>
#include<conio.h>
main()
clrscr(); printf("Enter a
number: ");
scanf("%d", &n);
while(n!=0)
rem=n%10;
reverse=reverse*10+rem;
n/=10;
PPS Page 73
Flowchart
do-while loop
Syntax : variable initialization ;
do{
or decrement ;
}while (condition);
The do-while loop is an exit controlled loop statement The body of the loop are executed first
and then the condition is evaluated. If it is true, then the body of the loop is executed once again.
The process of execution of body of the loop is continued until the condition finally becomes false
and the control is transferred to the statement immediately after the loop. The statements are always
executed at least once.
Flowchart
PPS Page 74
Example : Program to print first ten multiple of 5
#include<stdio.h>
#include<conio.h>
void main() {
int a,i;
a=5; i=1; do {
printf("%d\t",a*i);
10); getch(); }
Output
5 10 15 20 25 30 35 40 45 50
Example
main() {
int i=0
do
{
PPS Page 75
printf("while vs do-while\n");
}while(i= =1);
printf("Out of loop");
Output: while vs
do-while
Out of loop
For Loop:
• This is an entry controlled looping statement.
• One of the most important features of this loop is that the three actions can be taken at a
time like variable initialization, condition checking and increment/decrement.
• The for loop can be more concise and flexible than that of while and do-while loops.
Statements;
Example:
#include<stdio.h>
#include<conio.h> void
main( )
int x;
printf("%d\t",x);
PPS Page 76
}
getch(); }
Output
1 2 3 4 5 6 7 8 9 10
1) Here instead of num++, I‟m using num=num+1 which is nothing but same as num++.
2) Initialization part can be skipped from loop as shown below, the counter variable is declared
before the loop itself. int num=10; for (;num<20;num++)
Must Note: Although we can skip init part but semicolon (;) before condition is must, without which
you will get compilation error. 3) Like initialization, you can also skip the increment part as we did
below. In this case semicolon (;) is must, after condition logic. The increment part is being done in
for loop body itself.
//Code
num++;
4) Below case is also possible, increment in body and init during declaration of counter variable.
(;num<20;)
//Statements
num++;
PPS Page 77
5) Counter can be decremented also, In the below example the variable gets decremented each
time the loop runs until the condition num>10 becomes false. for(num=20; num>10; num--)
scanf("%d", &num);
sum += count;
return 0; }
Output
Sum = 55
#include<stdio.h>
#include<conio.h>
i,fact=1,number;
clrscr();
scanf("%d",&number);
PPS Page 78
for(i=1;i<=number;i++){
fact=fact*i;
getch();
Output:
Enter a number: 5
PPS Page 79
Infinitive for loop in C
If you don't initialize any variable, check condition and increment or decrement variable in for
loop, it is known as infinitive for loop. In other words, if you place 2 semicolons in for loop, it is
known as infinitive for loop.
for(; ;){
Where to The for loop is The other two loops i.e. while and do
Use for Loop, while Loop appropriate while loops are more suitable in the
and do while Loop when we know in situations where it is not known before
advance hand when the loop will terminate.
how many times the loop
will be executed.
PPS Page 81
How all the three loops A do while loop will
works? A while loop always executed the
A for loop initially will always code in the do {} i.e.
initiates a counter evaluate the body of the loop
variable test-expression block first and then
(initializationexpression), initially. It the evaluates the
then it checks the test-
test-expression condition. In this
expression, and executes
becomes true, case also, the
the body of the loop if the
then the body of counter variable is
test expression is true.
the loop will be initialized outside
After executing the body
executed. The the body of the loop.
of the loop,
update
Position of the In for loop, all the In while and do while loop, they are placed in
statements : three statements are different position.
placed in one position
• Initialization
• test-expression
• update-expression
PPS Page 82
Syntax of Loops for ( while(testexpression) do {
initializationexp.(s); { body-of-theloop;
test-expression(s); body-of-theloop;
updateexpression(s) updateexpression(s);
) updateexpression(s); }
{ } while (test-
expression);
body-of-the-loop
;
Which one is Entry Both loops i.e. for loop and while loop are do while loop is an
Controlled Loop entry controlled loop, means condition is exit controlled loop,
and checked first and if the condition is true then means means that
Which one is Exit the body of the loop will executes. condition is placed
Controlled Loop ? after the body of the
loop and is evaluated
before exiting from
the loop.
PPS Page 83
Conversion of one Loop : int i = 1; int i = 1;
to another
: : :
Loop or
Example : Print for (int i=1; i<=10; : :
numbers from 1 to 10 i++)
using all the three loops. while (i<=10) do
{
{ {
Printf(“%d”,i); }
Printf(“%d”,i);
Printf(“%d”,i); ++i;
++i
}
}
while (i<=10)
Syntax:
{ for(initialization; condition;
increment/decrement) {
statement ;
Example: main() {
PPS Page 84
printf("%d, %d",i ,j);
#include<stdio.h>
#include<conio.h>
void main( ) {
int i,j;
for(i=1;i<5;i++)
printf("\n");
for(j=i;j>0;j--
printf("%d",j);
} }
getch();
Output
21
321
4321 54321
PPS Page 85
Jump Statements
Jumping statements are used to transfer the program‟s control from one location to another, these
are set of keywords which are responsible to transfer program‟s control within the same block or
from one function to another.
• return statement
• break statement
• continue statement
goto statement : goto statement doesnot require any condition. This statement passes control
anywhere in the program i.e, control is transferred to another part of the program without testing
any condition.
.....
..... label:
statements;
Or
The goto statement requires a label to identify the place to move the execution. A label is a valid
variable/identifier name and must be ended with colon ( : )
PPS Page 86
Flowchart
Example
int main()
{ int
age;
Vote:
NoVote:
&age); if(age>=18)
goto Vote;
else
goto NoVote;
return 0;
PPS Page 87
Output Enter you age:19
Break Statement
Break is a keyword. The break statement terminates the loop (for, while and do...while loop)
immediately when it is encountered. The break statement is used/ associated with decision
break;
Flowchart
PPS Page 88
Example
clrscr();
PPS Page 89
if(i==5){//if value of i is equal to 5, it will break
Output
12345
Continue Statement
Continue is keyword exactly opposite to break. The continue statement is used for continuing
next iteration of loop statements. When it occurs in the loop it does not terminate, but it skips
some statements inside the loop / the statements after this statement. . The continue statement is
used/ associated with decision making statement such as if ,if-else. Syntax of continue
Statement continue;
PPS Page 90
How continue statement works?
Example
1. #include <stdio.h>
2. #include <conio.h>
PPS Page 91
3. void main(){
4. int i=1;//initializing a local variable
5. clrscr();
6. //starting a loop from 1 to 10
7. for(i=1;i<=10;i++){
8. if(i==5){//if value of i is equal to 5, it will continue the loop
9. continue;
10. }
11. printf("%d \n",i);
12. }//end of for loop
13. getch();
14. }
Output
1234678910
1 : break statement takes the control to the 1 :continue statement takes the control to
ouside of the loop the beginning of the loop..
ARRAYS
Using Arrays in C
C supports a derived data type known as array that can be used to handle large amounts of data
(multiple values) at a time.
Definition:
PPS Page 92
Or
An array is a collection of data that holds fixed number of values of same type.
Or
Array is a collection or group of elements (data). All the elements of array are
homogeneous (similar). It has contiguous memory location.
Or
An array is a data structured that can store a fixed size sequential collection of elements of same
data type.
Suppose you have to store marks of 50 students, one way to do this is allotting 50 variables.
So it will be typical and hard to manage. For example we can not access the value of these
variables with only 1 or 2 lines of code.
Another way to do this is array. By using array, we can access the elements easily. Only
few lines of code is required to access the elements of array.
Advantage of C Array
2) Easy to traverse data: By using the for loop, we can retrieve the elements of an array easily.
3) Easy to sort data: To sort the elements of array, we need a few lines of code only.
4) Random Access: We can access any element randomly using the array.
Disadvantage of Array
Fixed Size: Whatever size, we define at the time of declaration of array, we can't exceed the
limit. So, it doesn't grow the size dynamically like LinkedList Declaration of an Array
int arr[10];
Here int is the data type, arr is the name of the array and 10 is the size of array. It means array arr
can only contain 10 elements of int type. Index of an array starts from 0 to size-1 i.e first element
of arr array will be stored at arr[0] address and last element will occupy arr[9].
Initialization of an Array
After an array is declared it must be initialized. Otherwise, it will contain garbage value(any
random value). An array can be initialized at either compile time or at runtime.
PPS Page 94
int marks[4]={ 67, 87, 56, 77 }; //integer array initialization
4 : String initialization.
int a[5]={10,20,30,40,50};
If the size of integer is 2 bytes, 10 bytes will be allocated for the variable a. Ex
b[7]
C O M P U T E R
Other Examples : char b[5]={„J‟,‟B‟,‟R‟,‟E‟,‟C‟,‟B‟};
//error : number of initial values are more than the size of array.
//error : Number of initial values are more than the size of array.
int a[5]={10,15};
PPS Page 96
The array a is partial initialization as
a[0] a[1] a[2] a[3] a[4]
10 15 0 0 0
1000 1002 1004 1006 1008
In general array_name[n-1] can be used to access nth element of an array. where n is any integer
number.
Example
float mark[5];
Suppose you declared an array mark as above. The first element is mark[0], second element is
mark[1] and so on.
PPS Page 97
Few key notes:
As you can see, in above example that I have used „for loop‟ and „scanf statement‟ to enter data
into array. You can use any loop for data input.
Code:
For example you want to read and display array elements, you can do it just by using any loop.
Suppose array is mydata[20].
{ printf("%d\n",
mydata[x]);
Exmaple
PPS Page 98
#include<stdio.h>
#include<conio.h
int i;
getch(); }
Output
2 3 4
Exmaple
1. include <stdio.h>
2. #include <conio.h>
3. void main(){
4. int i=0;
5. int marks[5]={20,30,40,50,60};//declaration and initialization of array 6. clrscr();
7.
8. //traversal of array
9. for(i=0;i<5;i++){
10. printf("%d \n",marks[i]); 11. }
12.
13. getch();
14. }
Output
20
30
40
50
60
An array can also be initialized at runtime using scanf() function. This approach is usually
used for initializing large array, or to initialize array with user specified values.
Example
PPS Page 99
#include<stdio.h>
#include<conio.h>
void main()
{ int
arr[4];
int i, j;
for(i=0;i<4;i++)
initialization
for(j=0;j<4;j++)
printf("%d\n",arr[j]);
getch(); }
The two dimensional, three dimensional or other dimensional arrays are also known
as multidimensional arrays.
data_type array_name[size1][size2];
twodimen[4][3];
Example :
int a[3][4];
arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};
An element in a two-dimensional array is accessed by using the subscripts, i.e., row index
and column index of the array.
Example
1. #include <stdio.h>
2. #include <conio.h>
3. void main(){
4. int i=0,j=0;
5. int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};
6. clrscr();
7. //traversing 2D array
8. for(i=0;i<4;i++){
Output
arr[0][0] = 1 arr[0][1]
= 2 arr[0][2] = 3
arr[1][0] = 2 arr[1][1]
= 3 arr[1][2] = 4
arr[2][0] = 3 arr[2][1]
= 4 arr[2][2] = 5
arr[3][0] = 4 arr[3][1]
= 5 arr[3][2] = 6
#include<stdio.h>
#include<conio.h>
a[25][25],b[25][25],c[25][25],i,j,m,n; clrscr();
of A matrics"); for(i=0;i<m;i++)
{ for(j=0;j<n;j++)
scanf("\t%d",&a[i][j]);
matrics"); for(i=0;i<m;i++)
{ for(j=0;j<n;j++)
scanf("\t%d",&b[i][j]);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf("\t%d",a[i][
j]);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf("\t%d",a[i][j]);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
c[i][j]=a[i][j]+b[i][j];
printf("\t%d",c[i][j]);
} }
getch();
int a[25][25],b[25][25],c[25][25],i,j,m,n,k,r,s;
matrics:\n"); scanf("%d%d",&m,&n);
of A matrics"); for(i=0;i<m;i++)
{ for(j=0;j<n;j++)
scanf("\t%d",&a[i][j]);
matrics"); for(i=0;i<m;i++)
{ for(j=0;j<n;j++)
scanf("\t%d",&b[i][j]);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf("\t%d",a[i][j]);
for(i=0;i<m;i++)
for(j=0;j<n;j++)
printf("\t%d",b[i][j]);
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
c[i][j]=0;
for(k=0;k<m;k++) c[i][j]=c[i][j]+a[i][k]*b[k][j];
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
printf("\t%d",c[i][j]);
getch();
Multidimensional Arrays
How to initialize a multidimensional array?
You can initialize a three dimensional array in a similar way like a two dimensional array. Here's
an example
int test[2][3][4] = {
};
Example
main()
int i, j, k, test[2][3][2];
++k ) { scanf("%d",
&test[i][j][k]);
return 0; }
Output
Enter 12 values:
123456789101112
Displaying Values:
test[0][0][0] = 1 test[0][0][1]
= 2 test[0][1][0] = 3
test[0][1][1] = 4 test[0][2][0]
= 5 test[0][2][1] = 6
test[1][0][0] = 7 test[1][0][1]
= 8 test[1][1][0] = 9
test[1][1][1] = 10
test[1][2][0] = 11
test[1][2][1] = 12
STRINGS:
String Concepts
String is an array of characters that is terminated by \0 (null character). This null character
indicates the end of the string. Strings are always enclosed by double quotes ( " " ).
Whereas, character is enclosed by single quotes.
Or
C Strings
Declaration of String: C does not support string as a data type. However, it allows us to represent
strings as character arrays. In C, a string variable is any valid C variable name and it is always
declared as an array of characters.
Note: In declaration of string size must be required to mention otherwise it gives an error.
Ex: char str[]; // Invalid char str[0]; // Invalid char str[-1]; // Invalid
Using this declaration the compiler allocates 9 memory locations for the variable a ranging
from 0 to 8.
0 1 2 3 4 5 6 7 8
Here, the string variable a can hold maximum of 9 characters including NULL(\0)
character.
Note: In Initialization of the string if the specific number of character is not initialized it then rest
of all character will be initialized with NULL.
char str[5]={'5','+','A'};
Ex:
Char b[9]={„C‟,‟O‟,‟M‟,‟P‟,‟U‟,‟T‟,‟E‟,‟R‟};
The compiler allocates 9 memory locations ranging from 0 to 8 and these locations are
initialized with the characters in the order specified. The remaining locations are automatically
initialized to null characters.
C O M P U T E R \0
0 1 2 3 4 5 6 7 8
2 : Partial Array Initilization : If the characters to be initialized is less than the size of the
array, then the characters are stored sequentially from left to right.The remaining locations will
be initialized to NULL characters automatically.
int a[10]={„R‟,‟A‟,‟M‟,‟A‟ };
The compiler allocates 10 bytes for the variable a ranging from 0 to 9 and
initializes first four locations with the ASCII characters of „R‟, „A‟, „M‟, „A‟.The remaining
locations are automatically filled with NULL characters (i.e,\0).
R A M A \0 \0 \0 \0 \0 \0
0 1 2 3 4 5 6 7 8 9
char b[]={„C‟,‟O‟,‟M‟,‟P‟,‟U‟,‟T‟,‟E‟,‟R‟};
In this declaration, The compiler will set the array size to the total number of initial
values i.e 8. The character will be stored in these memory locations in the order specified.
4) Array Initilization with a String : consider the declaration with string initialization.
char b[ ] = “COMPUTER”;
Here, the string length is 8 bytes. But , string size is 9 bytes. So the compiler reserves 8+1
memory locations and these locations are initialized with the characters in the order specified. The
string is terminated by \0 by the compiler.
C O M P U T E R \0
0 1 2 3 4 5 6 7 8
The string “COMPUTER” contin 8 charactes, because it is a string. It always ends with
null character. So, the array is 9 bytes (i.e string length+1 byte for null character).
Reading and Writing Strings : The „%s‟ control string can be used in scanf() statement to read
a string from the teriminal and the same may be used to write string to the terminal in printf()
statement.
scanf(“%s”,name);
printf(“%s”,name);
Example:
1. #include <stdio.h>
2. void main ()
3. {
4. char ch[13]={'c', 'p', 'r', 'o', 'g', 'r', 'a', 'm', 'm', i', „n‟, „g‟, „\0‟};
6.
9. }
Output
Example:
main() { char
name[20];
scanf("%s", name);
printf("Your name is
%s.", name);
return 0; }
Output
The strings can be read from the keyboard and can be displayed onto the monitor
using various functions.
The various input and output functions that are associated with can be classified as
scanf() print()
getc() putc()
fscanf() fprintf()
getchar() putchar()
gets() puts()
getch()
getche()
1 : getchar() function : A single character can be given to the computer using „C‟ input library
function getchar().
The getchar() function is written in standared I/O library. It reads a single character from a
standared input device. This function do not require any arguments, through a pair of parantheses,
must follow the statements getchar().
#include<stdio.h>
#include<conio.h>
#include<ctype.h> void
main()
ch;
clrscr();
ch=getchar(); if(isalpha(ch)>0)
printf("it is a alphabet:%c\n",ch);
digit:%c\n",ch); else
printf("it is a alphanumeric:%c\n",ch);
getch();
}.
it is a alphabet:a
2 : putchar() function :The putchar() function is used to display one character at a time on the
standared output device. This function does the reverse operation of the single character input
function.
#include<stdio.h>
#include<conio.h>
#include<ctype.h> void
main()
putchar(toupper(ch));
else
getch();
3 : gets() : The gets() function is used to read the string (String is a group of characters) from the
standard input device (keyboard).
Ex :#include<stdio.h>
#include<conio.h> void
main()
char str[40];
clrscr();
gets(str);
getch();
4 : puts() :The puts() function is used to display the string to the standared output device
(Monitor).
#include<conio.h> void
main()
{ char
str[40];
puts("Enter
String
name:");
getch();
subbareddy
subbareddy
getch() function :The getch function reads a single character directly from the keyboard, without
echoing to the screen.
: #include<stdio.h>
void main()
char c;
c=getch();
: #include<stdio.h>
void main()
char c;
c=getche();
getc() function : This function is used to accept a single character from the standared input to a
character variable.
putc() function :This function is used to display a single character in a character variable to
standared output device.
Array of Strings
1 : strlen(string) – String Length : This function is used to count and return the number of
characters present in a string.
Syntax : var=strlen(string);
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main() {
char name[]="JBREC";
int len1,len2;
clrscr();
len1=strlen(name); len2=strlen("JBRECECE");
getch();
OUTPUT :
#include<stdio.h>
#include<conio.h> void
main()
string:"); scanf("%s",str);
for(index=0;str[index]!=0;index++);
getch();
OUTPUT :
2 : strcpy(string1,string2) – String Copy : This function is used to copy the contents of one string
to another string.
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
char str1[]="REDDY";
string2 is :%s",str2);
OUTPUT :
#include<stdio.h>
#include<conio.h> void
main() { char
scanf(“%s”,str1);
for(index=0;str1[index]!='\0';index++)
str2[index]=str1[index];
str2[index]='\0';
printf("String1 is :%s\n",str1);
printf("String2 is :%s\n",str2);
getch();
OUTPUT :
is : cprogramming
3 : strlwr(string) – String LowerCase : This function is used to converts upper case letters of the
string in to lower case letters.
Syntax : strlwr(string);
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
{ char
str[]="JBREC";
#include<stdio.h>
#include<conio.h> void
main()
scanf("%s",str);
for(index=0;str[index]!='\0';index++)
str[index]=str[index]+32;
getch();
4 : strupr(string) – String UpperCase : This function is used to converts lower case letters of the
string in to upper case letters.
Syntax : strupr(string);
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main() {
char str[]="jbrec";
strupr(str);
printf("UpperCase is :%s\n",str);
getch();
#include<stdio.h> #include<conio.h>
for(index=0;str[index]!='\0';index++)
str[index]=str[index]-32;
getch();
Syntax : strcmp(string1,string2);
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
{ char
str1[]="reddy"; char
str2[]="reddy";
int i,j,k;
i=strcmp(str1,str2);
j=strcmp(str1,"subba");
printf("%5d%5d%5d\n",i,j,k); }
OUTPUT : 0 -1 32
#include<stdio.h>
#include<conio.h>
index,l1,l2,flag=1; printf("Enter
scanf("%s",str2); l1=strlen(str1);
l2=strlen(str2); printf("Length of
string1:%d\n",l1); printf("Length of
string2:%d\n",l2); if(l1==l2)
for(index=0;str1[index]!='\0';index++)
if(str1[index]!=str2[index])
flag=0;
break;
} } else flag=0;
if(flag==1) printf("Strings
are equal");
Length of string1 :5
Length of string2 :5
when the above function is executed, string2 is combined with string1 and it
removes the null character (\0) of string1 and places string2 from there.
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
{ char
str1[10]="jbrec"; char
str2[]="ece";
strcat(str1,str2);
printf("%s\n",str1);
getch();
OUTPUT : jbrecece
ece
7 : strrev(string) - String Reverse :This function is used to reverse a string. This function takes
only one argument and return one argument.
Syntax : strrev(string);
#include<stdio.h>
#include<conio.h>
#include<string.h> void
main()
is:%s",strrev(str)); getch();
UNIT – III
FUNCTIONS:
To perform any task, we can create function. A function can be called many times. It provides
modularity and code reusability.
Advantage of functions
1) Code Reusability
By creating functions in C, you can call it many times. So we don't need to write the same code
again and again.
2) Code optimization
Example: Suppose, you have to check 3 numbers (781, 883 and 531) whether it is prime number or not.
Without using function, you need to write the prime number logic 3 times. So, there is repetition of code.
But if you use functions, you need to write the logic only once and you can reuse it several times.
Types of Functions
1. Library Functions: are the functions which are declared in the C header files such as
scanf(), printf(), gets(), puts(), ceil(), floor() etc. You just need to include appropriate
System defined functions are implemented in .dll files. (DLL stands for Dynamic Link
Library).
To use system defined functions the respective header file must be included.
2. User-defined functions: are the functions which are created by the C programmer, so that
he/she can use it many times. It reduces complexity of a big program and optimizes the
code. Depending upon the complexity and requirement of the program, you can create as
many user-defined functions as you want.
In order to write an efficient user defined function, the programmer must familiar with the
following three elements.
2 : Function Call.
3 : Function Definition
A function declaration is the process of tells the compiler about a function name. Syntax
return_type function_name(parameter/argument);
b);
int add();
When we call any function control goes to function body and execute entire code.
name(parameter/argument);
Defining a function.
Defining of function is nothing but give body of function that means write logic inside function
body. Syntax return_ type function-name(parameter list) // function header.
declaration of variables;
{ {
z = x + y; }
return z;
When the compiler encounters functionName(); inside the main function, control of the program
jumps to void functionName()
And, the compiler starts executing the codes inside the user-defined function.
The control of the program jumps to statement next to functionName(); once all the codes inside
the function definition are executed.
Example:
#include<stdio.h>
#include<conio.h>
clrsct();
defining function
c=a+b; printf("Sum:
%d", c);
calling function
Output Sum:30
Example:
%d",&n1,&n2);
function definition
// return statement
2 : Formal parameters.
1 : Actual Parameters : These are the parameters transferred from the calling function
(main program) to the called function (function).
2 : Formal Parameters :These are the parameters transferred into the calling function
(main program) from the called function(function).
Ex : main()
..... .
Where
1 : Actual parameters are used in calling 1 : Formal parameters are used in the
function when a function is invoked. function header of a called function.
Here a,b are actual parameters. Here m,n are called formal parameters.
PASSING PARAMETERS TO FUNCTIONS :There are two ways to pass value or data to
function in C language: call by value and call by reference. Original value is not modified in call
by value but it is modified in call by reference.
In call by value, value being passed to the function is locally stored by the function parameter in
stack memory location. If you change the value of function parameter, it is changed for the
current function only. It will not change the value of variable inside the caller method such as
main(). Or
When a function is called with actual parameters, the values of actual parameters are copied into
formal parameters. If the values of the formal parametes changes in the function, the values of
the actual parameters are not changed. This way of passing parameters is called pass by value or
call by value.
Ex :
#include<stdio.h>
#include<conio.h>
void main()
int i,j;
scanf("%d%d",&i,&j);
printf("Before swapping:%d%d\n",i,j);
swap(i,j);
printf("After swapping:%d%d\n",i,j);
} void
swap(int a,int b)
int temp;
temp=a;
a=b;
b=temp;
Output
Before swapping: 10 20
After swapping: 10 20
2 : Pass by reference (OR) Call by Reference : In pass by reference, a function is called with
addresses of actual parameters. In the function header, the formal parameters receive the
addresses of actual parameters. Now the formal parameters do not contain values, instead they
contain addresses. Any variable if it contains an address, it is called a pointer variable. Using
pointer variables, the values of the actual parameters can be changed. This way of passing
parameters is called call by reference or pass by reference.
Ex : #include<stdio.h>
#include<conio.h>
void main()
int i,j;
scanf("%d%d",&i,&j);
printf("Before swapping:%d%d\n",i,j);
printf("After swapping:%d%d\n",i,j);
int temp;
temp=*a;
*a=*b;
*b=temp;
Output
Before swapping:10 20
After swapping: 20 10
1 : When a function is called the values of 1 : When a function is called the address of
variables are passed variables are passed.
2 : Change of formal parameters in the 2 : The actual parameters are changed since
function will not affect the actual the formal parameters indirectly manipulate
parameters in the calling function. the actual parametes.
3 : Execution is slower since all the values 3 : Execution is faster since only address
have to be copied into formal parameters. are copied.
1 : In this category, there is no data transfer between the calling function and called function.
2 : But there is flow of control from calling function to the called function.
3 : When no parameters are there , the function cannot receive any value from the calling
function.
4: When the function does not return a value, the calling function cannot receive any value from
the called function.
Ex #include<stdio.h>
#include<conio.h>
void sum();
void main()
sum();
getch();
void sum()
int a,b,c;
scanf("%d%d",&a,&b);
c=a+b;
printf("sum=%d",c); }
Ex : #include<stdio.h>
#include<conio.h> int
sum();
void main()
int c;
clrscr();
c=sum();
printf("sum=%d",c);
getch();
int sum()
int a,b,c;
scanf("%d%d",&a,&b);
c=a+b; return
c;
1 : In this category, there is data transfer from the calling function to the called function using
parameters.
2 : But there is no data transfer from called function to the calling function.
3 : When parameters are there , the function can receive any values from the calling function.
Ex : #include<stdio.h>
#include<conio.h>
void main()
int m,n;
clrscr();
scanf("%d%d",&m,&n);
sum(m,n);
getch(); }
int c;
c=a+b;
printf("sum=%d",c);
1 : In this category, there is data transfer from the calling function to the called function using
parameters.
2 : But there is no data transfer from called function to the calling function.
3 : When parameters are there , the function can receive any values from the calling function.
4: When the function returns a value, the calling function receive a value from the called
function.
#include<conio.h> int
main() {
int m,n,c;
clrscr();
scanf("%d%d",&m,&n);
c=sum(m,n);
printf("sum=%d",c);
getch(); }
int c; c=a+b;
return c; }
Inter‐Function Communication
When a function gets executed in the program, the execution control is transferred from calling
function to called function and executes function definition, and finally comes back to the calling
function. In this process, both calling and called functions have to communicate each other to
exchange information. The process of exchanging information between calling and called
functions is called as inter function communication.
• Downward Communication
• Upward Communication
• Bi-directional Communication
In this type of inter function communication, the data is transferred from calling function to
called function but not from called function to calling function. The functions with parameters
and without return value are considered under downward communication. In the case of
downward communication, the execution control jumps from calling function to called function
along with parameters and executes the function definition,and finally comes back to the calling
function without any return value. For example consider the following program...
Example:
clrscr() ;
num1 = 10 ;
num2 = 20 ;
getch() ;
function
{ printf("SUM = %d",
a+b) ;
Output
Upward Communication
In this type of inter function communication, the data is transferred from called function to
calling function but not from calling function to called function. The functions without parameters
and with return value are considered under upward communication. In the case of upward
communication, the execution control jumps from calling function to called function without
parameters and executes the function definition, and finally comes back to the calling function
along with a return value. For example consider the following program...
Exmaple:
#include <stdio.h>
#include<conio.h> void
main(){
int result ;
clrscr() ;
called function {
20; return
(num1+num2) ;
Output
SUM=30
In this type of inter function communication, the data is transferred from calling function to called
function and also from called function to calling function. The functions with parameters and with
return value are considered under bi-directional communication. In the case of bidrectional
communication, the execution control jumps from calling function to called function along with
parameters and executes the function definition, and finally comes back to the calling function
along with a return value. For example consider the following program...
Example:
clrscr() ;
called function
return (a+b) ;
Output
SUM=30
Standard Functions
The standard functions are built-in functions. In C programming language, the standard functions
are declared in header files and defined in .dll files. In simple words, the standard functions can be
defined as "the ready made functions defined by the system to make coding more easy". The
standard functions are also called as library functions or pre-defined functions.
In C when we use standard functions, we must include the respective header file using #include
statement. For example, the function printf() is defined in header
file stdio.h (Standard Input Output header file). When we use printf() in our program, we must
include stdio.h header file using #include<stdio.h> statement.
time.h Provides functions to perform operations on time and date time(), localtime()
locale.h Defines the location specific settings such as date formats setlocale()
and currency symbols
stdarg.h Used to get the arguments in a function if the arguments va_start(), va_end(),
are not specified by the function va_arg()
1 : stdio.h
2 : stdlib.h
3 : string.h
4 : math.h
5 : ctype.h
6 : time.h
scanf() int Enter data items from the standard input device.
getchar() int Enter a single character from the standard input device.
fread(s,il,i2,f) int Enter i2 data items, each of size i1 bytes, from file f.
exit(u) void Close all files and buffers, and terminate the program.
realloc(p,u) void* Allocate u bytes of new memory to the pointer variable p, return
a pointer to the beginning of the new memory space.
floor(d) double Return a value rounded down to the next lower integer.
difftime(11,12) double Return the time difference 11-12, where 11 and 12 represent
elapsed time beyond a designated base time.
time(p) long int Return the number of seconds elapsed beyond a designated
base time.
Storage Classes
In C language, each variable has a storage class which is used to define scope and life time of a
variable.
Storage: Any variable declared in a program can be stored either in memory or registers.
Registers are small amount of storage in CPU. The data stored in registers has fast access
compared to data stored in memory.
Storage class of a variable gives information about the location of the variable in
which it is stored, initial value of the variable, if storage class is not specified; scope of the
variable; life of the variable.
1: Automatic Storage class : To define a variable as automatic storage class, the keyword „auto‟
is used. By defining a variable as automatic storage class, it is stored in the memory. The default
value of the variable will be garbage value. Scope of the variable is within the block where it is
defined and the life of the variable is until the control remains within the block. Syntax : auto
data_type variable_name;
Example: void
main()
detail; or
The variables a and b are declared as integer type and auto. The keyword auto is
not mandatory. Because the default storage class in C is auto.
Note: A variable declared inside a function without any storage class specification, is by default
an automatic variable. Automatic variables can also be called local variables because they
are local to a function.
main() 10 {
function2(); printf(“%d”,x);
void function1()
int x=10;
printf(“%d”,x);
void function2()
int x=0;
function1();
printf(“%d”,x);
2: Register Storage class : To define a variable as register storage class, the keyword
Register variable has faster access than normal variable. Frequently used variables are kept in
register. Only few variables can be placed inside register.
void main() 20
{ 20
demo(); 20
demo(); demo();
void demo()
printf(“%d\n”,i);
i++;
3 : Static Storage class : When a variable is declared as static, it is stored in the memory. The
default value of the variable will be zero. Scope of the variable is within the block where it is
defined and the life of the variable persists between different function calls. To define a variable
as static storage class, the keyword „static‟ is used. A static variable can be initialized only once,
it cannot be reinitialized.
{ 21
demo(); 22
demo(); demo();
void demo()
printf(“%d”,i);
i++;
4 : External Storage class : When a variable is declared as extern, it is stored in the memory.
The default value is initialized to zero. The scope of the variable is global and the life of the
variable is until the program execution comes to an end. To define a variable as external storage
class, the keyword „extern‟ is used. An extern variable is also called as a global variable. Global
variables remain available throughout the entire program. One important thing to remember about
global variable is that their values can be changed by any function in the program.
extern int i;
Ex:
main()
number=10;
} fun1()
} fun2()
number=30;
Ex : void fun1();
void fun2();
main()
fun1();
fun2(); }
void fun1()
{ extern int e;
void fun2()
extern keyword
The extern keyword is used before a variable to inform the compiler that this variable is declared
somewhere else. The extern declaration does not allocate storage for variables. Problem when
x = 10;
printf("%d",x);
Recursion
When function is called within the same function, it is known as recursion in C. The function
which calls the same function, is known as recursive function.
A function that calls itself, and doesn't perform any task after function call, is know as tail
recursion. In tail recursion, we generally call the same function with return statement.
Features :
• It is easy to use.
• It is slower than that of looping statements because each time function is called.
Note: while using recursion, programmers need to be careful to define an exit condition from the
function, otherwise it will go into an infinite loop. Recursive functions are very useful to solve
many mathematical problems, such as calculating the factorial of a number, generating Fibonacci
series, etc.
Example of recursion.
recursionfunction(){ recursionfunction();//calling
self function
#include<stdio.h>
#include<conio.h>
/*Wrong value*/
if (n == 0)
void main(){
fact=factorial(5); printf("\n
factorial of 5 is %d",fact);
Preprocessor Commands
A program in C language involves into different processes. Below diagram will help you to
understand all the processes that a C program comes across.
o #include
o #define
o #undef
o #ifdef o
#ifndef
o #if o
#else o
#elif o
#error o
#pragm
C Macros
A macro is a segment of code which is replaced by the value of macro. Macro is defined by
#define directive. There are two types of macros:
1. Object-like Macros
2. Function-like Macros
Object-like Macros
The object-like macro is an identifier that is replaced by value. It is widely used to represent
numeric constants. For example:
#define PI 3.14
Here, PI is the macro name which will be replaced by the value 3.14.
Function-like Macros
Predefined Macros
There are some predefined macros which are readily for use in C programming.
No. Macro Description
Output
File :test.c
Time :03:36:24
Line :8
ANSI :1
C #include
The #include preprocessor directive is used to paste code of given file into current file. It is used
include system-defined and user-defined header files. If included file is not found, compiler
renders error.
By the use of #include directive, we provide information to the preprocessor where to look for
the header files. There are two variants to use #include directive.
1. #include <filename>
2. #include "filename"
The #include <filename> tells the compiler to look for the directory where system header files
are held. In UNIX, it is \usr\include directory.
Let's see a simple example of #include directive. In this program, we are including stdio.h file
because printf() function is defined in this file.
1. #include <stdio.h>
2. main() {
3. printf("Hello C");
4. } Output:
Hello C
#include notes:
Note 1: In #include directive, comments are not recognized. So in case of #include <a//b>, a//b is
treated as filename.
Note 2: In #include directive, backslash is considered as normal text not escape sequence. So in
case of #include <a\nb>, a\nb is treated as filename.
Note 3: You can use only comment after filename otherwise it will give error.
C #define
The #define preprocessor directive is used to define constant or micro substitution. It can use any
basic data type.
Syntax:
#include <stdio.h>
#define PI 3.14
main() {
printf("%f",PI);
Output:
3.140000
#include <stdio.h>
Output:
C #undef
The #undef preprocessor directive is used to undefine the constant or macro defined by #define.
Syntax:
#undef token
#include <stdio.h>
#define PI 3.14
#undef PI
main() {
printf("%f",PI);
Output:
The #undef directive is used to define the preprocessor constant to a limited scope so that you
can declare constant again.
Let's see an example where we are defining and undefining number variable. But before being
undefined, it was used by square variable.
number 15 int
square=number*number;
main() {
printf("%d",square);
Output:
225
C #ifdef
Syntax:
#ifdef MACRO
//code
#endif
#ifdef MACRO
//successful code
#else
//else code
#endif
C #ifdef example
#include <stdio.h>
NOINPUT
a=0;
a=2; #else
printf("Enter
a:");
scanf("%d", &a);
#endif
getch();
Output:
Value of a: 2
#include <stdio.h>
#include
<conio.h> void
#ifdef NOINPUT
a=2; #else
printf("Enter
a:");
scanf("%d", &a);
#endif
getch();
Output:
Enter a:5
C #ifndef
The #ifndef preprocessor directive checks if macro is not defined by #define. If yes, it executes
the code otherwise #else code is executed, if present.
Syntax:
#ifndef MACRO
//code
#endif
#ifndef MACRO
//successful code
#else
//else code
#endif C
#ifndef example
#include <stdio.h>
#include
<conio.h>
#define INPUT
a=0; #ifndef
INPUT
a=2; #else
printf("Enter
scanf("%d", &a);
#endif
getch();
Output:
Enter a:5
Value of a: 5
#include <stdio.h>
#include
<conio.h> void
#ifndef INPUT
a=2; #else
printf("Enter
a:");
scanf("%d", &a);
#endif
getch();
Output:
Value of a: 2
C #if
Syntax:
#if expression
//code
#endif
#if expression
//if code
#else
//else code
#endif
#if expression
//if code
#elif expression
//elif code
#else
//else code
#endif
C #if example
#include <stdio.h>
#include <conio.h>
#define NUMBER 0
void main() {
getch();
Output:
#include <stdio.h>
NUMBER 1
void main() {
clrscr();
#endif
#endif
getch();
Output:
C #else
The #else preprocessor directive evaluates the expression or condition if condition of #if is false.
It can be used with #if, #elif, #ifdef and #ifndef directives.
Syntax:
#if expression
//if code
//else code
#endif
#if expression
//if code
#elif expression
//elif code
#else
//else code
#endif
C #else example
#include <stdio.h>
NUMBER 1
void main() {
#if NUMBER==0
#else
#endif
getch();
Output:
C #error
C #error example
#include<stdio.h>
#ifndef __MATH_H
#else void
main(){
float a;
a=sqrt(7);
printf("%f",a);
#endif
Output:
#include<stdio.h>
#include<math.h>
#ifndef __MATH_H
#else
void main(){
float a;
a=sqrt(7);
printf("%f",a);
#endif
2.645751
C #pragma
The #pragma preprocessor directive is used to provide additional information to the compiler.
The #pragma directive is used by the compiler to offer machine or operating-system feature.
Syntax:
#pragma token
#pragma argsused
#pragma exit
#pragma hdrfile
#pragma hdrstop
#pragma inline
#pragma option
#pragma saveregs
#pragma startup
#pragma warn
#include<stdio.h>
#include<conio.h>
void func() ;
void main(){
printf("\nI am in main");
getch();
am in func"); getch();
Output:
I am in func
I am in main
I am in func
1. Source program is converted into executable code through different processes like
precompilation, compilation, assembling and linking.
preprocessor Syntax/Description
Syntax: #define
This macro defines constant value and can be any of
the basic data types.
Macro
The following section lists down all the important preprocessor directives −
Directive Description
1 : macro substitution.
2 : file inclusion.
Ex : #define PI 3.142
#define MIN_MARKS 35
Ex :
#include <stdio.h>
: %c \n", backslash_char);
OUTPUT:
of number : 3.140000
backslash_char : ?
#include<stdio.h> #define PI
scanf(“%d”,&r); area=PI*r*r;
#define B (200-100)
void main()
void main()
int a=100,b=50;
IFCONDITION
PRINT;
Where identifier is the name of macro function with the list of macro formal parameters
var1,var2,var3,…varn like the formal parameters in a function definition. Ex : #define
PROD(x) (x*x)
void main()
numbers%d”,mul);
#include<stdio.h>
main()
void add()
{ int a,b,c;
scanf(%d%d”,&a,&b);
is:%d”,c);
These are used to select a particular segment of code for compilation depending on the
condition.
• “#ifdef” directive checks whether particular macro is defined or not. If it is defined, “If”
clause statements are included in source file.
• Otherwise, “else” clause statements are included in source file for compilation and
execution.
Ex:
RAJU 100
int main()
"this C file\n");
#else
#endif
return 0;
OUTPUT:
• #ifndef exactly acts as reverse as #ifdef directive. If particular macro is not defined, “If”
clause statements are included in source file.
• Otherwise, else clause statements are included in source file for compilation and
execution.
Ex:
#endif
return 0;
}
OUTPUT:
• Otherwise, else clause statement is included in source file for compilation and execution.
Ex:
#include <stdio.h>
#define a 100 int
main()
{
#if (a==100)
printf("This line will be added in this C file since " \
"a \= 100\n");
#else
printf("This line will be added in this C file since " \
"a is not equal to 100\n");
#endif
return 0;
}
OUTPUT:
This line will be added in this C file since a = 100
EXAMPLE PROGRAM FOR UNDEF IN C LANGUAGE:
Ex:
OUTPUT:
Pragma is used to call a function before and after main function in a C program.
Ex:
#include <stdio.h>
function2( );
main function" ) ;
return 0; }
void function1( )
call");
function2( )
"\
OUTPUT:
Ex : #define TEST 1
void main()
#ifdef TEST
{ printf(“This
is compiled”); }
#else
{ printf(“This is
not compiled”);
#endif
char ch;
void main()
#if FLAG
{ ch=‟t‟;
printf(“This is compiled”);
#else {
compiled”);
#endif
POINTERS:
Introduction Definition:
Pointer is a variable that stores/hold address of another variable of same data type/ t is
also known as locator or indicator that points to an address of a value. A pointer is a
derived data type in C
pointer_variable_name;
int* p;
float a;
int *ptr;
As you can see in the above figure, pointer variable stores the address of number variable i.e.
fff4. The value of number variable is 50. But the address of pointer variable p is aaa3.
By the help of * (indirection operator), we can print the value of pointer variable p.
& is called reference operator. It gives you the address of a variable. There is another operator
that gets you the value from the address, it is called a dereference operator (*).
Dereferencing of Pointer
Once a pointer has been assigned the address of a variable. To access the value of variable,
pointer is dereferenced, using the indirection operator *.
• Normal variable stores the value whereas pointer variable stores the address of the
variable.
• * symbol is used to get the value of the variable that the pointer is pointing to.
• Two pointers can be subtracted to know how many elements are available between these
two pointers.
Example:
#include <stdio.h>
#include <conio.h>
void main(){
int number=50;
int *p;
clrscr();
getch(); }
Output
Value of p variable is 50
Example:
#include <stdio.h>
int main() {
int *ptr, q;
q = 50;
ptr = &q;
Output
50
Example: #include
<stdio.h> int
%u", &p);
printf( "\n Value of pointer p is: %u", p); printf ( "\n Value of
var is: %d", var); printf ( "\n Value of var is: %d", *p); printf
Output:
NULL Pointer
A pointer that is not assigned any value but NULL is known as NULL pointer. If you don't have
any address to be specified in the pointer at the time of declaration, you can assign NULL value.
Or
It is always a good practice to assign a NULL value to a pointer variable in case you do not have
an exact address to be assigned. This is done at the time of variable declaration. A pointer that is
assigned NULL is called a null pointer.int *p=NULL;
Note: The NULL pointer is a constant with a value of zero defined in several standard libraries/
in most the libraries, the value of pointer is 0 (zero)
Example:
Pointers to Pointers
Pointers can point to other pointers /pointer refers to the address of another pointer.
pointer can point to the address of another pointer which points to the address of a value.
**p2;
Let's see an example where one pointer points to the address of another pointer.
#include <stdio.h>
#include <conio.h>
void main(){
int number=50;
**p2;//pointer to pointer
clrscr();
p2=&p;
getch();
Output
int arr[5]={ 1, 2, 3, 4, 5 };
Assuming that the base address of arr is 1000 and each integer requires two byte, the five
element will be stored as follows
Here variable arr will give the base address, which is a constant pointer pointing to the element,
arr[0]. Therefore arr is containing the address of arr[0] i.e 1000.
int arr[5]={ 1, 2, 3, 4, 5 };
Now we can access every element of array arr using p++ to move from one element to another.
NOTE : You cannot decrement a pointer once incremented. p-- won't work. Pointer to
Array we can use a pointer to point to an Array, and then we can use that pointer to access
the array. Lets have an example,
i<5; i++)
{ printf("%d",
*p); p++;
In the above program, the pointer *p will print all the values stored in the array one by one. We
can also use the Base address (a in above case) to act as pointer and print all the values.
arr[4];
In C programming, name of the array always points to address of the first element of an array.
In the above example, arr and &arr[0] points to the address of the first element.
Since, the addresses of both are the same, the values of arr and &arr[0] are also the same.
Similarly,
..
Example: Program to find the sum of six numbers with arrays and pointers
{ int i, classes[6],sum = 0;
printf("Enter 6 numbers:\n");
scanf("%d",(classes + i));
return 0; }
Output
Enter 6 numbers:
Sum = 21
o Increment(++) o
Decrement(--) o
Addition(+) o
Subtraction(-)
Increment pointer:
Address + 1 = Address
Address++ = Address
++Address = Address
Pictorial Representation :
Note :
32 bit
64 bit
Example:
PPS Page 198
#include <stdio.h>
void main(){
int number=50;
of p variable is %u \n",p);
Output
Decrement(--)
Example:
\n",p); p=p-1;
Output
Addition(+)
size_of(data type))
Note:
32 bit
64 bit
Example:
\n",p);
Output
Subtraction (-)
Like pointer addition, we can subtract a value from the pointer variable. The formula of
subtracting value from pointer variable.
Example:
\n",p); }
Output
If you want to pass a single-dimension array as an argument in a function, you would have to
declare a formal parameter in one of following three ways and all three declaration methods
}
Example1: pass an entire array to a function argument
#include <stdio.h> /* function
declaration */ double getAverage(int
arr[], int size); int main () {
/* an int array with 5 elements */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
int i;
double avg;
return avg;
}
Output
Average value is: 214.400000
int main() {
int var_arr[] = {11, 22, 33, 44, 55, 66, 77};
myfuncn(&var_arr, 7);
return 0; }
Output
Value of var_arr[0] is: 11
Value of var_arr[1] is: 22
Value of var_arr[2] is: 33
Value of var_arr[3] is: 44
Value of var_arr[4] is: 55
Value of var_arr[5] is: 66
Value of var_arr[6] is: 77
return 0; }
Output:
abcdefghij
In this method of calling a function, the actual arguments gets copied into formal
arguments. In this example actual argument(or parameter) is arr[x] and formal parameter
is ch.
Example:
Call by reference method: Using pointers
#include <stdio.h> disp(
int *num)
{ printf("%d ",
*num);
i++)
disp (&arr[i]);
PPS Page 204
}
return 0;
Output:
1234567890
Array of Pointers
An array of pointers would be an array that holds memory locations. An array of pointers is an
indexed set of variables in which the variables are pointers (a reference to a location in memory).
Syntax: data_type_name *
variable name Example int
*ptr[MAX];
alpha[0] *a
alpha[1] *(a+1)
alpha[2] *(a+2)
alpha[3] *(a+3)
alpha[n] *(a+n)
Example1:
i, *ptr[MAX]; for ( i = 0; i
of integer. */
return 0; }
Output
Value of var[0] = 10
return 0; }
Example3:
#include <stdio.h>
*names[] = {
"Zara Ali",
"Hina Ali",
"Nuha Ali",
names[i] );
return 0;
Output:
Example4: #include
*fruit[] = { "watermelon",
"banana",
"pear",
"apple",
"coconut",
"grape",
"blueberry"
};
int x;
for(x=0;x<7;x++)
puts(fruit[x]); return(0);
Pointers to Void
Note:
1. Suppose we have to declare integer pointer, character pointer and float pointer then we
need to declare 3 pointer variables.
2. Instead of declaring different types of pointer variable it is feasible to declare single
pointer variable which can act as integer pointer,character pointer.
variables of other data types. It is invalid and will result in a compilation error. Ex:- char *ptr;
pointer variable.
Here comes the importance of a “void pointer”. A void pointer is nothing but a pointer
variable declared using the reserved word in C „void‟.
Void pointer: A void pointer is a pointer that has no associated data type with it. A void pointer
can hold address of any type and can be typcasted to any type. Special type of pointer called void
pointer or general purpose pointer. Declaration of void pointer void * pointer_name; Void
pointer example
1) malloc() and calloc() return void * type and this allows these functions to be used to allocate
Note:
1) void pointers cannot be dereferenced. For example the following program doesn‟t compile.
#include<stdio.h>
&a; printf("%d",
*ptr); return 0;
}
Output:
Compiler Error: 'void*' is not a pointer-to-object type The
following program compiles and runs fine.
#include<stdio.h> int
main() { int a = 10;
void *ptr = &a;
printf("%d", *(int *)ptr);
return 0;
Output:
10
Summary : Void Pointer
Scenario Behavior
In this declaration, f is interpreted as a function that takes an int as argument, and returns a
pointer to an int.
Example:
#include<stdio.h> int sum
(int num1, int num2)
{ return
sum1+sum2;
} int main() { int (*f2p) (int, int); f2p = sum; int op1
= f2p (10, 13); int op2 = sum (10, 13); printf("Output 1
– for function call via Pointer: %d",op1); printf("Output2
– for direct function call: %d", op2); return 0;
}
Output:
Output 1 – for function call via Pointer: 23
Output2 – for direct function call: 23
You would have noticed that the output of both the statements
is same – f2p(10, 13) == sum(10, 13) which means in generic sense you can write it out
as:
pointer_name(argument list) == function(same argument list)
Note: Dynamic memory allocation related function can be applied for any data type that's why
dynamic memory allocation related functions return void*.
Memory Allocation Process
Global variables, static variables and program instructions get their
memory in permanent storage area whereas local variables are stored in area called Stack. The
memory space between these two region is known as Heap area. This region is used for dynamic
memory allocation during execution of the program. The size of heap keep changing.
Example
int *x;
x = (int*)malloc(100 * sizeof(int)); //memory space allocated to variable x free(x);
//releases the memory allocated to variable x
This statement will allocate either 200 or 400 according to size of int 2 or 4 bytes respectively
and the pointer points to the address of first byte of memory.
Example
Example
struct employee
{ char
*name; int
salary;
};
typedef struct employee emp; emp
*e1;
e1 = (emp*)calloc(30,sizeof(emp));
Example
#include <stdio.h> #include <stdlib.h>
int main() { int num, i, *ptr, sum =
0; printf("Enter number of elements:
"); scanf("%d", &num); ptr =
(int*) calloc(num, sizeof(int)); if(ptr
== NULL)
{
printf("Error! memory not allocated.");
exit(0);
}
printf("Enter elements of array: ");
for(i = 0; i < num; ++i)
free()
When your program comes out, operating system automatically release all the memory allocated
by your program but as a good practice when you are not in need of memory anymore then you
should release that memory by calling the function free().
The memory occupied by malloc() or calloc() functions must be released by calling free()
function. Otherwise, it will consume memory until program exit.
Or
Dynamically allocated memory created with either calloc() or malloc() doesn't get freed on its
own. You must explicitly use free() to release the space.
Syntax:
free(ptr);
}
printf("Sum = %d", sum);
free(ptr); return 0;
}
Example1
#include <stdio.h>
int main( int argc, char *argv[] ) {
if( argc == 2 ) {
printf("The argument supplied is %s\n", argv[1]);
} else if( argc > 2 ) { printf("Too many
arguments supplied.\n");
} else { printf("One argument
expected.\n");
}
}
Output
Example2
#include <stdio.h> void main(int argc, char *argv[] ) {
printf("Program name is: %s\n", argv[0]); if(argc <
2){ printf("No argument passed through command
line.\n");
} else{ printf("First argument is:
%s\n", argv[1]);
}
}
Output program.exe hello
Program name is: program
First argument is: hello
Note
Example3
#include<stdio.h>
#include<conio.h> void
main(int argc, char* argv[])
{
int i; clrscr(); printf("Total number of
arguments: %d",argc); for(i=0;i< argc;i++)
{ printf("\n %d argument:
%s",i,argv[i]); getch();
}
}
Output
C:/TC/BIN>TCC mycmd.c
C:/TC/BIN>mycmd 10 20
Number of Arguments: 3
0 arguments c:/tc/bin/mycmd.exe
1 arguments: 10
2 arguments: 20
Note: In above output we passed two arguments but is show "Number of Arguments: 3" because
argc take Number of arguments in the command line including program name. So here two
arguments and one program name (mycmd.exe) total 3 arguments.
UNIT IV
STRUCTURES, UNIONS, ENUMERATIONS AND TYPEDEF
Structure Definition
Structure is a user defined data type which hold or store heterogeneous/different types data item
or element in a single variable. It is a Combination of primitive and derived data type.
or
A structure is a collection of one or more data items of different data types, grouped together
under a single name.
struct keyword is used to define/create a structure. struct define a new data type which is a
collection of different type of data. Syntax
{ data_type
member1; data_type
member2;
data_type member n;
};
Example
struct employee
{ int id;
char name[50];
float salary;
};
tagname/structure_name variable;
We can declare variable for the structure, so that we can access the member of structure easily.
There are two ways to declare structure variable:
1st way:
Let's see the example to declare structure variable by struct keyword. It should be declared within
the main function.
struct employee
{ int id;
char name[50];
float salary;
};
Let's see another way to declare variable at the time of defining structure.
struct employee
{ int id;
char name[50];
float salary;
}e1,e2;
But if no. of variable are not fixed, use 1st approach. It provides you flexibility to declare the
structure variable many times.
If no. of variables are fixed, use 2nd approach. It saves your code to declare variable in main()
function.
Structure Initialization
structure variable can also be initialized at compile time.
struct Patient
{ float
height; int
weight; int
age;
};
When the variable is normal type then go for struct to member operator.
When the variable is pointer type then go for pointer to member operator.
structure_variable_name.member_name Example
struct book
char name[20];
pages;
};
struct book b1; for accessing the structure members from the
above example
Example
struct emp
{ int id;
char name[36];
int sal;
Example of Structure in C
#include<stdio.h>
#include<conio.h>
id;
char name[36];
float sal;
};
void main() {
struct emp e;
clrscr();
scanf("%f",&e.sal);
printf("Id: %d",e.id);
printf("\nName: %s",e.name);
Output
Id : 05
Name: Spidy
Salary: 45000.00
#include <stdio.h>
#include <string.h>
struct employee
{ int id;
char name[50];
main( )
return 0;
Output:
Nested Structures
structure can have another structure as a member. There are two ways to define nested structure
in c language:
1. By separate structure
2. By Embedded structure
1) Separate structure
We can create 2 structures, but dependent structure should be used inside the main structure as a
member. Let's see the code of nested structure.
struct Date
{ int
dd; int
mm;
int yyyy;
};
struct Employee
int id;
char name[20];
}emp1;
Employee
int id;
char name[20];
struct Date
{ int
dd; int
mm;
int yyyy;
}doj;
}emp1;
e1.doj.dd e1.doj.mm
e1.doj.yyyy
Arrays of Structures
Array of structures to store much information of different data types. Each element of the array
representing a structure variable. The array of structures is also known as collection of structures.
Ex : if you want to handle more records within one structure, we need not specify the number of
structure variable. Simply we can use array of structure variable to store them in one structure
variable.
Example of structure with array that stores information of 5 students and prints it.
#include<stdio.h>
#include<conio.h>
#include<string.h>
int rollno;
char name[10];
};
void main(){
int i;
printf("Enter Records of 5
students");
for(i=0;i<5;i++){
printf("\nEnter Rollno:");
scanf("%d",&st[i].rollno);
printf("\nEnter Name:");
scanf("%s",&st[i].name);
for(i=0;i<5;i++){ printf("\nRollno:%d,
Name:%s",st[i].rollno,st[i].name);
getch();
Output:
Enter Rollno:1
Enter Name:Sonoo
Enter Rollno:2
Enter Rollno:3
Enter Name:Vimal
Enter Rollno:4
Enter Name:James
Enter Rollno:5
Enter Name:Sarfraz
Rollno:1, Name:Sonoo
Rollno:2, Name:Ratan
Rollno:3, Name:Vimal
Rollno:4, Name:James
Rollno:5, Name:Sarfraz
The general format of sending a copy of a structure to the called function is:
----------
----------
return(exp);
#include <stdio.h>
student
int id;
char name[20];
float percentage;
};
record; record.id=1;
strcpy(record.name, "Raju");
record.percentage = 86.5;
func(record); return 0;
record) {
Output
Id is: 1
<string.h>
struct student
int id;
char name[20];
float percentage;
};
record; record.id=1;
strcpy(record.name, "Raju");
record.percentage = 86.5;
func(&record);
*record)
<string.h>
struct student
int id;
char name[20];
float percentage;
record.id=1;
strcpy(record.name
, "Raju");
record.percentage
= 86.5;
structure_demo();
void structure_demo()
clrscr();
a.no=12;
a.avg=13.76;
fun(a); getch(); }
{ printf("number
is%d\n",p.no); printf("average
is%f\n",p.avg);
<string.h>
struct student {
int id;
char name[30];
main()
int i;
return 0;
OUTPUT:
Records of STUDENT1:
Id is: 1
Name is: Raju
A self-referential structure is one of the data structures which refer to the pointer to (points) to
another structure of the same type. For example, a linked list is supposed to be a self-referential
data structure. The next node of a node is being pointed, which is of the same struct type. For
example,
type member1;
type membere2;
: :
: :
typeN memberN;
Ex: struct
emp
{ int
code;
Unions are conceptually similar to structures. The syntax of union is also similar to that of
structure. The only difference is in terms of storage. In structure each member has its own storage
location, whereas all members of union use a single shared memory location which is equal to the
size of its largest data member.
We can access only one member of union at a time. We can‟t access all member values at the
same time in union. But, structure can access all member values at the same time. This is because,
Union allocates one common storage space for all its members. Where as Structure allocates
storage space for all its members separately.
{
data_type member1;
data_type member2;
data_type memeberN;
};
Example
union employee
{ int id;
char name[50];
float salary;
};
Example
#include <string.h>
union employee
{ int id;
char name[50];
main( )
return 0;
Output: employee 1 id :
Sonoo Jaiswal
As you can see, id gets garbage value because name has large memory size. So only name will
have actual value.
Example
#include <stdio.h>
item
float b;
char ch; };
int main( )
it.ch='z'; clrscr();
printf("%d\n",it.a);
printf("%f\n",it.b);
printf("%c\n",it.ch);
getch(); return 0; }
Output
-26426
20.1999 z
As you can see here, the values of a and b get corrupted and only variable c prints the expected
result. Because in union, the only member whose value is currently stored will have the memory.
1 For defining structure use For defining union we use union keyword
struct keyword.
2 Structure occupies more Union occupies less memory space than Structure.
memory space than union.
4 Structure allocates separate Union allocates one common storage space for its all
storage space for its every members. Union find which member need more memory than
members. other member, then it allocate that much space
Bit‐Fields Syntax
struct {
};
type An integer type that determines how a bit-field's value is interpreted. The
type may be int, signed int, or unsigned int.
width The number of bits in the bit-field. The width must be less than or equal
to the bit width of the specified type.
The variables defined with a predefined width are called bit fields. A bit field can hold more than
a single bit; for example, if you need a variable to store a value from 0 to 7, then you can define a
bit field with a width of 3 bits as follows − struct { unsigned int age : 3;
} Age;
The above structure definition instructs the C compiler that the age variable is going to use only 3
bits to store the value. If you try to use more than 3 bits, then it will not allow you to do so. Let us
try the following example –
PPS Page 245
#include <stdio.h> #include
<string.h>
age : 3;
} Age;
Age.age );
return 0; }
Output
Sizeof( Age ) : 4
Age.age : 4
Age.age : 7
Age.age : 0 typedef
The typedef is a keyword that allows the programmer to create a new data type name for an existing
data type. So, the purpose of typedef is to redefine the name of an existing variable type. Syntax
Example of typedef
#include<stdio.h> #include<conio.h>
main()
%d",s); getch();
Output
Sum: 20
Advantages of typedef :
#include<stdio.h>
#include<conio.h>
void main() {
digits a,b,sum;
clrscr();
scanf("%d%d",&a,&b);
is:%d",sum);
getch();
Application of typedef
typedef can be used to give a name to user defined data type as well. Lets see its use with structures.
typedef struct
type member1;
member3;
} type_name ;
Here type_name represents the stucture definition associated with it. Now this type_name can be
used to declare a variable of this stucture type. type_name t1, t2 ;
#include<conio.h>
#include<string.h>
{ char
name[50];
int salary;
} emp ;
void main( )
record\n"); printf("\nEmployee
name\t"); scanf("%s",e1.name);
scanf("%d",&e1.salary);
typedef can be used to give an alias name to pointers also. Here we have a case in which use of
typedef is beneficial during pointer declaration.
x, y ;
By this declaration statement, we are actually declaring x as a pointer of type int, whereas y will
be declared as a plain integer.
IntPtr x, y, z;
NOTE : If you do not have any prior knowledge of pointers, do study Pointers first.
Enumerations
An enum is a keyword, it is an user defined data type. All properties of integer are applied on
Enumeration data type so size of the enumerator data type is 2 byte. It work like the Integer.
It is used for creating an user defined data type of integer. Using enum we can create sequence of
integer constant value. Syntax
• In above syntax tagname is our own variable. tagname is any variable name.
It is start with 0 (zero) by default and value is incremented by 1 for the sequential identifiers in the
list. If constant one value is not initialized then by default sequence will be start from zero and
next to generated value should be previous constant value one.
Example of Enumeration in C
#include<stdio.h>
#include<conio.h> enum
main()
clrscr();
a=x+y+z; //0+1+2
Output
Sum: 3
Example of Enumeration in C
#include<stdio.h>
today=tue; printf("%d
day",today+1); getch(); }
Output
3 day
Example of Enumeration in C
{ printf("%d
",i);
getch();
Output
UNIT – V
FILE
Why files are needed?
• When a program is terminated, the entire data is lost. Storing in a file will preserve your
data even if the program terminates.
• If you have to enter a large number of data, it will take a lot of time to enter them all.
However, if you have a file containing all the data, you can easily access the contents of
the file using few commands in C.
• You can easily move your data from one computer to another without any changes.
File I/O:-
Sometimes it is necessary to store the data in a manner that can be later retrieved and displayed
either in a part or in whole. This medium is usually a “file” on the disk. File I/O can be handled
by using different functions.
a) Formatted functions:- The file input function fscanf( ) and the file output function fprintf( )
are called formatted file I/O functions.
b)Unformatted functions:- The input functions like getc( ), getw( ), and fread( ) are called
unformatted file input functions and putc( ), putw( ), and fwrite( ) functions are unformatted file
output functions. Each and every function is having its own syntax and meaning.
File streams:- Stream is either reading or writing of data. The streams are designed to allow the
user to access the files efficiently. A stream is a file or physical device like key board, printer,
monitor, etc., The FILE object uses these devices. When a C program is started, the operating
system is responsible for opening three streams: standard input stream (stdin), standard output
stream (stdout), standard error(stderr).Normally the stdin is connected to the keyboard, the
stdout and stderr are connected to the monitor.
Files
File is a collection of bytes that is stored on secondary storage devices like Hard disk.
OR
A file represents a sequence of bytes on the disk where a group of related data is stored. File is
created for permanent storage of data. It is a ready made structure.
Note:
When dealing with files, there are two types of files you should know about:
1. Text files
2. Binary files
1. Text files
Text files are the normal .txt files that you can easily create using Notepad or any simple text
editors.
When you open those files, you'll see all the contents within the file as plain text. You can easily
edit or delete the contents.
They take minimum effort to maintain, are easily readable, and provide least security and takes
bigger storage space.
2. Binary files
Binary files are mostly the .bin files in your computer.
Instead of storing data in plain text, they store it in the binary form (0's and 1's).
They can hold higher amount of data, are not readable easily and provides a better security than
text files.
File Operations
In C, you can perform four major operations on the file, either text or binary:
• Naming a file/Creation of new file
• Opening an existing file
• Reading data from file
• Writing data into file
• Closing a file
Steps for processing a file
➢ Declare a file pointer
➢ open a file using fopen() function
➢ Process the file using suitable file functions.
➢ close the file using fclose() function.
Declaration of a file
string”, list);
Note:
➢ fscanf is used to read list of items from a file ➢
fprintf is used to write a list of items to a file.
Note:
EOF – End of file (when EOF encountered the reading / writing should be terminated)
4 fscanf() To read set of data from file. fscanf(fp, "control string", list)
file1.txt a
fgetc() function
The fgetc() function returns/read a single character from the file. It gets a character from the
stream. It returns EOF at the end of file.
getc ( ): getting a character from the file, or reading the file information character by character at
a time, upto the end of the file by using this function.
Example:
#include<stdio.h>
#include<conio.h>
FILE *fp;
char c;
clrscr();
fp=fopen("myfile.txt","r");
while((c=fgetc(fp))!=EOF){ printf("%c",c);
fclose(fp);
getch();
myfile.txt this is
fputs()
Example:
#include<stdio.h>
#include<conio.h>
void main(){
FILE *fp;
clrscr();
fp=fopen("myfile2.txt","w"); fputs("hello
c programming",fp);
fclose(fp);
getch();
programming
fgets()
Example:
#include<stdio.h>
#include<conio.h
text[300];
clrscr();
fp=fopen("myfile2.txt","r");
printf("%s",fgets(text,200,fp));
fclose(fp);
getch();
Output:
hello c programming
These are integer oriented functions. These are similar to above functions and are used to read
and write integer values. These are useful when we deal with only integer data. The general
format is putw ( ): putting or writing of an integer value to a file.
Ex: int x = 5;
PPS Page 260
putw(x,fp);
Ex: int x;
x = getw (fp);
The fseek() function is used to set the file pointer to the specified offset. It is used to write data
into file at desired location. syntax:
The first parameter stream is the pointer to the file. The second parameter is the position of the
record to be found, and the third parameter specifies the location where the offset starts.
Whence Meaning
SEKK_CUR Starts the offset from the current location of the cursor in the file.
or
• Position is a n integer number and it specifies from which position the file pointer to be
moved. Position can take one of the following three values.
0 beginning of file
1 current position
2 end of file
Eg: fseek (fp, 0L,0); - go to the beginning of the file. (Similar to rewind).
fseek (fp, 0L,1); - Stay at current position (Rarely used) fseek (fp,
0L,2); -go to the end of the file, past the last character of the file.
Example:
fp =
fopen("myfile.txt","w+")
; fputs("This is
javatpoint", fp);
); fputs("sonoo
jaiswal", fp);
fclose(fp);
myfile.txt
This function places the file pointer to the beginning of the file, irrespective of where it is present
right now. It takes file pointer as an argument.
Syntax: rewind(
fp); Example:
File: file.txt
Example:
#include<stdio.h>
#include<conio.h>
void main(){
FILE *fp;
char c; clrscr();
fp=fopen("file.txt","r")
while((c=fgetc(fp))!=EOF){ printf("%c",c);
while((c=fgetc(fp))!=EOF){ printf("%c",c);
fclose(fp);
getch();
Output:
As you can see, rewind() function moves the file pointer at beginning of the file that is why "this
is simple text" is printed 2 times. If you don't call rewind() function, "this is simple text" will be
printed only once.
ftell()
The ftell() function returns the current file position of the specified stream. We can use ftell()
function to get the total size of a file after moving file pointer at the end of file. We can use
SEEK_END constant to move the file pointer at the end of file.
syntax:
offset(in bytes).
Example:
#include <stdio.h>
fp = fopen("file.txt", "r");
fseek(fp, 0, SEEK_END);
length = ftell(fp);
fclose(fp);
getch();
Output:
keyboard.