C programming for Computing Techniques

Problem SolvingProblem Solving
andand
C ProgrammingC Programming
Knowledge Level:Knowledge Level:
BasicBasic

Icons used
Questions References
Key Concepts
A Welcome Break
Demo
Brain Teasers

Module Information
Module
Description
After completing this Module participants will be able
to ,
• Understand the concepts of problem solving and
program design
• Understand the need of programming languages
and its features
• Appreciate program design and components of
program design
• Understand the various elements of C
programming language
• Write effective programs using C Programming
Language
Level Basic
Prerequisites N/A

Module Objective & Outline
Module Objective:
After completing this Module participant will be able to,
– Understand the concepts of problem solving and program
design
– Understand the need of programming languages and its features
– Appreciate program design and components of program design
– Understand the various elements of C Programming language
– Write effective programs using C Programming Language

Module Objective & Outline
Module Flow:
4.
Selection
Structure
2.
Programming
Language
3.
Introduction
to C
Programming
6.
Arrays
And
Strings
1.
Introduction
to
Problem
Solving
7.
Introduction
to
Pointers
8.
Functions
9.
Structures
And
Union
5.
Control
Statements
10.
Files

1.0 Introduction to Problem Solving
Introduction:
Designing a program means defining the logical flow of a program, what the
program will take as input and what it will produce as output
Objective:
After completing this Topic, you will be able to,
1. Understand various steps in program development
2. Acquire problem solving skills
3. Learn the techniques of modular programming

Program Development
The various steps involved in program development are,
– Analyzing or Defining the problem
– Developing a solution technique (Algorithm)
– Coding
– Documenting the problem
– Compiling and Running the program
– Testing and Debugging
– Maintenance

Analyzing or Defining the problem
Defining the problem, also known as program analysis, involves
the following tasks.
– Specifying the input requirements
– Specifying the output requirements
– Specifying the processing requirements

Specifying the Input requirements:
Specifying the input requirements is used to determine the inputs required
and the source of the data.
Specifying the output requirements:
Specifying the output requirements is used to describe in detail the output
that will be produced.

Specifying the processing requirements:
Specifying the processing requirements is used to determine the processes
for converting the input data in to output data.
Example for problem definition:
1. Compute the Area of a rectangle
Write a program, which will input the width and length of a rectangle and
then calculate and output its area.
Compute the Area of a rectangle:
Input : Width and Length
Output : Area of rectangle
Process: Find solution technique, which converts input to
output.

Example for problem definition:
2. Compute Sum of N numbers:
• Write a program, which will input a list of numbers until it encounters 0
and then output the sum.
• The above problem definitions very clearly and precisely defines what
the problem are. The input, output and process for the above problem
definitions can be as follows:
Compute Sum of N numbers:
Input : List of numbers until 0 is encountered
Output : Sum of all the input numbers
Process: Find solution technique, which converts input to
output.

Modular Design
Once the problem is defined clearly, several design methods can be
considered. An important approach is Top-down program design.
Top-Down program design is a structured design technique.
It consists of the following steps.
• Take a problem, divide it into smaller logical sub-problems, called as
Modules.
• Each module can have only one entry point and one exit point, so that
the logic flow of the program is easy to follow.
• When the program is executed, it must be able to move from one
module to the next in sequence, until the last module has been
executed.
• Each module should be independent and should have a single function.
• Each module should be of manageable size, in order to make the design
and testing of the programmer easier.

Developing a Solution technique( Algorithm)
An Algorithm is a step-by-step description of the solution to a problem.
Def: An algorithm is defined as an “ordered sequence of well-defined and
effective operations that, when executed, will always produce a result and
terminate in a finite amount of time”.
An algorithm must be,
– Precise and unambiguous.
– Give the correct solution in all cases.
– Eventually end.

Example for an algorithm:
The algorithm for the problem “Compute the Sum of N numbers”.
Algorithm: Compute Sum
• Step1: Initialize Sum to be 0.
• Step2: Input New Number
• Step3: If new number is 0 go to step 6.
• Step4: Add the next number to sum.
• Step5: Go to Step2.
• Step6: Report the Sum.

Testing an Algorithm:
• The Boundary (or Extreme) Cases.
How does the algorithm perform at the extremes of the valid cases, for
example, finding elements at the very beginning or end of the list.
• The Unusual Cases.
What happens when we input data that violate the normal conditions of
the problem or represent unusual condition? For example what happens
if the key cannot be found in the list or we have given a list of length 0?
• The Invalid Cases.
How does the algorithm react for data are patently illegal are completely
meaningless, such as list of length –1? An algorithm should work
correctly and produce meaningful results for any data. We call this
foolproof programming.

Developing a Solution technique( Flow Chart)
Flow Chart
A Flow Chart is a blue print or a logical diagram of the solution to a
Problem.
The Symbols used in drawing a flow chart is given below

Developing a Solution technique( Flow Chart)
START, END
INPUT / OUTPUT
COMPUTATION &
ASSIGNMENT
DECISION MAKING
CONTROL FLOW
CONTINUOUS
PURPOSES

Coding
• Writing the program is called Coding.
• In this step, the logic that has been developed in the algorithm is
used to actually write the program.
• Using any programming language, the algorithm can be
converted to coding.

Documenting the program
• Documentation exists to assist in the understanding or use of a program.
• Documentation comes in two forms
- External documentation, which includes such things as
reference manuals, algorithm descriptions, flowcharts, and project
workbooks
- Internal documentation, which is part of the source code itself
(essentially, the declarations, statements, and comments).

Compiling and Running the program
• Compiling is a process in which the source program instructions
are translated into a form that is suitable for execution by the
computer.
• The compiler does the translation after examining each instruction
for its correctness. The translation results in the creation of object
code. If necessary, Linking is also done.
• Linking is the process of putting together other program files and
functions that are required by the program.
• After compilation, the program can be executed. During
execution, the executable object code is loaded into the computer
memory and the program instructions are executed.

Testing
• Testing is the process of executing a program with the deliberate
intent of finding errors.
• Some programmers use the terms “testing” and “debugging”
interchangeably, but careful programmers distinguish between the
two activities.
• Testing is a means of detecting errors. Debugging is a means of
diagnosing and correcting their root causes.

Debugging
• Debugging is the process of identifying the root cause of an error
and correcting it.
• On some projects, debugging occupies as much as 50 percent of
the total development time.
• For many programmers, debugging is the hardest part of
programming.

Maintenance
• Programs require a continuing process of maintenance and
modification to keep pace with changing requirements and
implementation technologies.
• Maintainability and modifiability are essential characteristics of real
programs.
• A program’s ability to be read and understood is an important
prerequisite to its maintainability and modifiability.
• You can make your program maintainable by:
– dividing the program into modules
– making sure that the program is well-documented
– using symbolic constants

Summary
• Program development life cycle involves analysis, algorithm
development, coding, documenting, compiling and running, testing
and debugging and maintenance.
• An algorithm is a step-by-step description of the solution to a
problem. Development of an algorithm involves many refinement
process.
• Top-Down program design involves dividing the problem into
smaller logical sub-programs known as modules.

Test your understanding
1. Write an algorithm to find all numbers in fibonacci sequences less
than 200.
2. Draw a flow chart for the above problem
3. Write an algorithm to find the total number of even integers in a
given list.

2.0 Programming Language
Introduction:
A programming language is a vocabulary and set of grammatical rules for
instructing a computer to perform specific tasks.
Objective:
After completing this Topic, you will be able to,
1. Define Programming Language
2. Appreciate Programming Language
3. Understand types of Programming Language
4. Appreciate the development of Early Languages

What is a programming language?
• It is a vocabulary and set of grammatical rules for instructing a computer to
perform specific tasks.
• Usually refers to high-level languages, such as BASIC, C, C++, COBOL,
FORTRAN, Ada, and Pascal

Why study Programming Language?
• To improve a one’s ability to use programming languages
effectively & efficiently
• To improve one’s ability to develop better & smarter
algorithms
• To improve one’s knowledge on useful programming
constructs
• To enable a better choice of programming languages which
would tailor to one’s specific requirement.
• To make it easier to learn & design a new language

Types & Features
• Types
– Numerical
– Business
– AI
– System
• Features of a Good Programming Language
– Clarity, Simplicity & Unity
– Orthogonality
– Support for abstraction
– Portability
– Cost of creation, execution and maintenance

Target Environments
– Batch
– Interactive
– Embedded
– Portability
– Development

Summary
• The choice of which language to use depends on the type of computer
the program is to run on, what sort of program it is, and the expertise of
the programmer.
• The external environment supporting the execution of a program is
termed its operating or target environment.
• The environment under which a program is designed, coded, tested &
debugged is called the host environment.
• Target environments can be classified into 4 categories –
- Batch processing
- Interactive
- Embedded systems and Programming environment

1.0 Evolution of Computer
Introduction:
This Topic gives an overview on computer evolution and and its history.
Objective:
After completing this Topic, you will be able to understand,
1. Types of Computer
2. History of Computer
3. Typical Computer System

Types of Computer
• Types of Computers (based on size, speed and cost)
– Mainframe Computer :
– 1. A huge.
2. As Computer size decreases power increases.
3. Still used in large companies to describe the huge M/C processing millions
of transactions.
– Desktop Computer:
– A pc that is not designed for portability, set in a permanent location.
Offers more power, storage and versatility.
– Portable (notebook) Computers :
– Note books, Laptops, Portable computer.
That integrates the display, keyboard, a pointing device, processor, memory
and hard drive in battery operated package.
Size of hard cover book.

– Workstations:
– Desktop computer - Powerful cpu.
Additional memory - Capabilities for performing special group of task
like 3D graphics, game development.
– Supercomputer :
– Single computer systems or comprised of multiple high performance
computers working in parallel as a single system. E.g. Cray super
computers.

History of computers
• History of Computers – Generation – Milestone.
• The history of computer development is referred to as generation of
computers.
• Each generation – Characterized by major technological development
that fundamentally changed the way the computers operate, resulting in
smaller, cheaper, more powerful, more efficient and reliable devices.
– The First Generation (1945-55): Vacuum Tubes
– The Second Generation (1955-65): Transistors
– The Third Generation (1965-75): Integrated Circuits
– The Fourth Generation (1975 - ): VLSIs
– Beyond the Fourth Generation

History of Computer
• Zeroth Generation:(1642- )
- Mechanical computers.
- French scientist Pascal – built the first calculating m/c –
mechanical using gears and powered by a hand operated crank.
- Could only do addition and subtraction.
- 30 years later Baron Goltfried (Mathematician) – built another
mechanical m/c – Multipy and divide as well.
- 150 years – Charles Babbage (Professor of mathematics) – Designed
and built
Difference Engine (since it used method of finite differences using
polynomials).
- Mechanical device which adds and subtract and also designed to
compute tables of numbers for naval navigation.

- O/P method – results punched into copper engraver’s plate with a steel die –
foreshadowing – punched cards – CD ROMS.
- It could run only one algorithm.
• Successor of this Babbage built (Entirely mechanical general purpose) –
Analytical Engine.
• Contains four components:
- The Store (Memory) – 1000 words of decimal digits, each used
to hold variables and results.
- The Mill (Computation unit) - Could accepts operands from
store and then add, subtract, multiply or divide and finally
returns the result to store.
- Input section – Punched cards.
- Output section – Punched cards and printers.
. Analytical Engine – Software – Ada Aeigusta Lovelace (worlds first
programmer) – Programming language Ada is name in her honor.

First Generation(1945 – 1955)
– Programs and data located in same memory.
– Assembly language was used to write programs.
– Vacuum Tube Technology for performing basic processing.
– Mercury delay line memory was used.
– Type writers as I/O devices.
– ENIAC – 18000 Vacuum tubes – 1500 relays – 30 tones – 140 kilowatts of
power – 20 registers - 10 digit decimal number.
– EDSAC – 1949 – Von new man – Genius – Stored program concept –
Memory 4096 words – 40 bits/word – 0’s & 1’s.

History of Computer
• History of Computer
Main Memory
(Programs and
data for
execution)
Instruction
Data
Central Processing
Unit (CPU)
Program
Control
Data
Processing
Programs, data,
operator
commands
Input-output
equipment
Secondary
memory,
keyboard,
printer etc.

History of Computer
• Second Generation (1955 – 1965)
– Transistor replaced vacuum tubes.
– Magnetic core memories and magnetic storage devices were more widely
used.
– High level language such as FORTRAN was developed.
– Compilers were developed.
– Separate I/O processors were developed along with CPU.
– IBM became major manufacturer.
E.g. PDP1 – 4k of 18 bit words – 5 microseconds – cycle time.
IBM 7090 – fastest at that time – 2 micro seconds – cycle time.

History of Computer
• Third Generation ( 1965-1975)
– Many transistors on a single chip (IC) enabled lower cost , faster processors
and memory elements.
– IC memories replaced magnetic core memories.
– Introduction of micro-programming (flexibility) , parallelism , pipelining.
– Pipeline – multiple instructions – are at varies stages of instructions of
instruction cycle - simultaneously in different sections of the processor.
– Parallelism - multiple units operate simultaneously.
– Effective time sharing in operating system.
– Development of Cache & Virtual memory.

History of computer
• Fourth Generation (1975-1996)
– Still advancement in IC technology (VLSI) that is Very Large Scale
Integration.
– Microprocessor concept - Motorola, Texas Instruments were the major
companies.
– Parallelism, Pipelining , Cache , Virtual Memories evolved to produce high
performance.
– Computing systems of today.

Video
Monitor
Secondary
Memory
Keyboard
Communi
cation
Network
Video
Control
Hard Disk
Control
Keyboard
Control
Network
Control
IO expansion
slots
IO Devices
IO (local) Bus
Peripheral (IO) interface control unit
CPU
Cache
Microprocessor
M
a
i
n
M
e
m
o
r
y
System Bus
Bus Interface
Unit
A Typical Computer System

Evolution of Computer : Summary
 The types of Computers are determined based on size, speed and
cost.
 The First Generation computer had Vacuum Tubes.
 The Second Generation computers had Transistors.
 The Third Generation computers had Integrated Circuits.
 The Fourth Generation computers had VLSIs.

3.0 Introduction to C Language
• Objectives
After completing this session you will be able to
– Understand the structure of C Program
– Understand the concepts of variables, constants and expressions
– Understand the functions of Arithmetic, Relational and Logical Operators

Overview of C Language
• C is a programming language that allows a software engineer to
efficiently communicate with a computer.
• It’s been used for a wide variety of programs including firmware for
micro-controllers, operating systems, applications, and graphics
programming.

Overview of C Language
Some of the features of C Language are listed below:
– Designed for top-down programming – Programs will be easier to
design.
– Designed for structure - Programs will be easier to read and
understand.
– Allows modular design – Makes it easier for you to debug.
– C is much more flexible.
– Low level (Bitwise) programming readily available
– Pointer implementation - extensive use of pointers for memory, array,
structures and functions.

History of C Language
• ALGOL60 was developed by an International committee in year the1960
• Combined Programming Language was developed at Cambridge
University in the year 1963.
• Basic Combined Programming language was developed by Martin
Richards at Cambridge University in 1967.
• In 1970, B language was developed by Ken Thompson at Bell Labs.
• In 1972, C language was developed by Dennis Ritchie at AT & T Bell
labs.

Structure of C Program
Preprocessor Area
- This section is used to include files and define constants and macro functions.
Function prototype
- User defined functions prototype specification.
Global Variables Declaration
- This section is used to declare global variables
main function
- Starting and ending point of execution
User defined functions
- This section contains many user defined functions
The structure of the User defined and main function is as follows:
Return-type function-name(list of parameters)
{
Local Variables Declaration;
Set of statements;
return statement;
}

Sample Program
Example:1
/* This program accepts four integers from the keyboard as input and calculate
and print the average */
#include <stdio.h>
#define SIZE 4
int main( )
{ int n1,n2,n3,n4;
float total, avg;
printf(“n Please input 4 integer numbers”);
scanf(“%d%d%d%d”, &n1,&n2,&n3,&n4);
total = (n1+n2+n3+n4);
avg = total / SIZE;
printf(“nThe following data was input: %d %d %d %d ”, n1, n2, n3, n4);
printf(“n The mean of the data is = %10.2f”, avg);
return 0;
}

Sample Program
• Example:2
/* Sample program */
main( )
{
printf( “I Like C n'' );
}
– C requires a semicolon at the end of every statement.
– printf is a standard C function -- called from main.
– n signifies new line character for formatted output.

The C Compilation Model
The C Compilation model describes the program development process
in terms of language

The Preprocessor
• The Preprocessor
– The Preprocessor accepts source code as input and is responsible for
– Removing comments
– Interpreting special preprocessor directives denoted by #.
• For example
– #include -- includes contents of a named file. Files usually called header files.
e.g
• #include <math.h> -- standard library math file.
• #include <stdio.h> -- standard library I/O file
– #define -- defines a symbolic name or constant. Macro substitution.
• #define MAX_ARRAY_SIZE 100

System Softwares
• C Compiler
The C compiler translates source code (user written program) to
assembly code (Machine understandable code). The source code is
received from the preprocessor.
• Assembler
The assembler creates object code. On a UNIX system you may see
files with a.o suffix (.OBJ on MSDOS) to indicate object code files.
• Link Editor
If a source file references library functions or functions defined in
other source files the link editor combines these functions (with
main( )) to create an executable file. External Variable references
resolved here also.

Character set and Keywords
Character Set
- C uses the uppercase letters A-Z, the lowercase letters a-z, the digits 0-9 and
special characters.
- Some of the special characters are
! * + “ <
# ( = | { >
% ) ~ ; } / etc.
Keywords
Keywords have standard, predefined meanings in C. These keywords can be
used only for their intended purpose; They cannot be used as programmer-
defined identifiers.
Some of the keywords are :
auto extern sizeof
break float static etc.

Identifier
Identifier
• Identifier is a name given to any programming element like variables,
constants, functions, statements.
• It should start with a alphabet followed by the combinations of alphabets
and digits. No special character is allowed except underscore( _ ).
Valid identifiers : sum01 net_pay
Invalid identifiers: 25Mark Student number #totalsalary

Variable and Data types
Variable
– A variable is an identifier that represents a value. The value
represented by the identifier may be changed during the
execution of the program.
Data and Data Types
– Data represent raw facts.
– Data type indicated the type of value represented or stored.
Data Type Defines
– It also specifies the number of bytes to be reserved in memory
– The range of value can be represented
– Type of operation to be performed on data

Data Types
Data types may be broadly classified into two types.
– Primitive or Primary or Basic data types
– Compound or Derived or User defined data types
There are four basic primitive data types:
char - used to declare variables for storing character (textual) data.
int - used to declare variables that store integer values.
Float - used to declare variables that store real ( floating point ) values.
double - used to declare variables that store double precision values.

Derived Data Types
• Derived data types
Derived data types are a combination of primitive data types. They are
used to represent a collection of data.
They are
– Arrays
– Structure
– Unions
– Typedef
– Enumerated
– Pointers

Size of the Data types
• Size of each data types (Machine Dependent)
sizeof(int) = 2 bytes
sizeof(char) = 1 byte
sizeof(long) = 4 bytes
sizeof(short) = 2 bytes
sizeof(float) = 4 bytes
sizeof(double) = 8 bytes
sizeof(long double) = 10 bytes

Type Qualifiers
• Type Qualifiers
– Data Types can be augmented by additional information.
– A number of qualifiers or modifiers may be assigned to these basic types to
represent the number of bits utilized in memory
• Some simple “type qualifiers” are listed below:
– short
– long
– unsigned
– signed

Declaring and Initializing variables
• Declaring a Variable
To declare a variable in C, do:
var_data_type list variables;
Examples:
int i,j,k;
float x,y,z;
char ch;
• Initializing a Variable
You can initialize a variable when you declare it.
int total_score = 0;

Expression
Expressions
Expression is a combinations of language keywords, function calls,
operators, and operands that evaluate to a value. There are three types
of expressions,
– Arithmetic Expressions
– Relational Expressions
– Logical Expressions

Arithmetic Expressions
Arithmetic Expressions
An expression which involves arithmetic operators, is Arithmetic Expression.
The arithmetic operators available in C are,
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulus

Relational Expression
• Relational Expression
An expression which involves relational operators, is Relational
Expression.
The Relational operators available in C , are
< Less than
> Greater than
< = Less than or equal to
> = Greater than or equal to
= = Equal to
! = Not equal to

Logical Operators
• Logical Expression
An expression which involves logical operators, is Logical Expression.
Logical operators are usually used with conditional statements.
The logical operators are,
&& logical AND
|| logical OR
! logical NOT
• Logical Operators && and || are binary operators(Which requires two
Operands)
• ! is a Unary Operator(Which requires one operand).

Order of Precedence
Order of Precedence
– It is necessary to be careful of the meaning of such expressions as
a+ b * c.
– We may want the effect as either (a + b) * c or a + (b * c). All
operators have a priority, and high priority operators are evaluated
before lower priority ones. Operators of the same priority are
evaluated from left to right, so that
a - b – c is evaluated as ( a - b ) – c as you would expect.

Order of Precedence
From high priority to low priority the order for all C operators is:
• ( ) [ ] -> . (Association left->right)
• ! -(unary minus) sizeof (type cast) ++ - - ( Association right->left)
• * / % (Association left->right)
• + - (Association left->right)
• < <= >= > (Association left->right)
• == != (Association left->right)
• && (Association left->right)
• || (Association left->right)
• ?: (Association right->left)
• = += -= (Association right->left)
• , (comma) (Association right->left)

Assignment Statements
Assignment Statements
• Assignment Statement is used to assign a value to a variable. In C, the
assignment operator is “=”.
• The left side of the “=” is always a variable whose address specifies
where to store the data on the right side.
e.g. x = y + z;
this means, compute the value of y+z and store the result in the variable
x.
• However, x + 3 = y is not legal. x + 3 is an arithmetic expression; not a
storage location. Here, x is a location value (storage location), y and z
are the read values (right hand side variables values).

Multiple Assignment Statements
C allows multiple assignment statements using =,
for example:
a = b = c = d = 3;
...which is the same as, but more efficient than:
a = 3;
b = 3;
c = 3;
d = 3;
This kind of assignment is only possible if all the variables types in the
statement are the same.

Printing Out and Inputting Variables
• Printing Out and Inputting Variables:
C uses formatted output. The printf function has a special formatting
character (%) -- a character following this defines a certain format for a
variable:
– %c -- characters
– %d -- integers
– %f – floats
– %s - string
e.g. printf(“%c %d %f”,ch, i, x);
• scanf( ) is the function for inputting values to a data structure: Its
format is similar to printf:
e.g. scanf(“%c %d %f”, &ch, &i, &x);

Constants
Constant it is a bit like a variable declaration except the value cannot
be changed.
• There are two types of constants.
– Symbolic constants
– Constant variables, also called read-only variables.
• A symbolic constant is defined in the preprocessor area of the program and is
valid throughout the entire program. The preprocessor #define is more flexible
method to define constants in a program. A symbolic constant is defined as
follows.
For e.g. #define max 100
#define pi 3.14
Each reference to max in program will cause the value of 100 to be applied.
This value cannot be changed by the program. Because there is no memory
allocated for the symbolic constants.

Constants
A constant variable is declared and initialized in the variable declaration
section of the program and cannot be modified thereafter.
The type of value stored in the constant must also be specified in the
declaration. In C, we are using const as a keyword to declare constant
variables.
For example, an integer and float constants can be declared as follows:
const int size = 100;
const float pi=3.14;

Typecasting
• Typecasting:
C provides a mechanism which allows the programmer to change the
default data type of a given arithmetic expression. This is called
typecasting.
For e.g.
float sum;
sum = (int) (1.5 * 3.8);
The type cast (int) tells the C compiler to interpret the result of (1.5 * 3.8) as the
integer 5, instead of 5.7. Because sum is of type float, the value stored will
therefore be 5.0.

Typecasting
C provides two types of typecasting:
• implicit - C compiler can converts the value of one data type into
another by default.
• explicit - User has to enforce the compiler to convert the one data type
value to another data type value by using typecasting operator. [ (data
type) expression ]
Another two terms associated with type casting are :
• Narrowing: Converting the higher data type value to lower data type
value.
• Widening : Converting the lower data type value to higher data type
value.
e.g. float to (int or char) - narrowing
(char or int) to float - widening

Summary
Summary
– C is a highly structured middle level language.
– C program consists of collection of functions.
– C supports four basic primitive data types int,char,float,double.
– C has a rich set of operators namely arithmetic, relational and logic.

4.0 Selection Structure
• Objectives
After completing this session you will be able to
– Know the syntax of if statement and switch statement
– Understand the function of ternary operator ?:
– Write efficient programs using selection statements

if Statement
if statement
• The if statement allows us to put some decision-making into our
programs. The if statement has the same function as other
languages. It has three basic forms:
Form 1
if (expression)
statement ;
• If the expression is evaluated as true (nonzero), the statement will
be executed. If the expression is evaluated as false (0), the
statement will not be executed.
• If more than one statement are to be executed in the if condition,
such statement must be enclosed within the curly braces.

if Statement
Form 2
if (expression)
statement1;
else
statement2;
• If the condition is true (nonzero), the first statement is executed, else the
second statement is executed.
Form 3
if (expression)
statement1;
else if (expression)
statement2;
else
statement3;

if Statement
Example 1
int x, y, w;
main( )
{
if (x > 0)
{ z = w; }
else
{ z = y; }
}
Example 2
if(balance < 500)
service_charge = 10;
else
service_charge = 2;

if Statement and ?: Operator(Ternary)
Example 3
if( (student_cat = =’p’) && (age>21))
++mature_student;
Ternary Operator ( ? :)
• The ?: (ternary or conditional) operator is a more efficient form for
expressing simple if statements. It has the following form:
expression1 ? expression2: expression3
• It simply states:
if expression1 then expression2 else expression3

For example to assign the maximum of a and b to c:
c = (a>b) ? a : b;
which is the same as:
if (a>b)
c = a;
else
c = b;

Sample Program1 to illustrate nested if to find leap year.
#include<stdio.h>
main()
{
int year;
printf("Enter the year: ");
scanf("%d", &year);
if(year % 4 == 0)
if(year % 100 != 0)
printf("%d is a leap year",year);
else
if(year % 400 == 0)
printf("%d is a leap year",year);
else
printf("%d is not a leap year",year);
else
printf("%d is not a leap year",year);
return (0);
}

Sample program 2 Check a number for Armstrong
(A number is Armstrong if it equals the sum of cubes of its digits)
#include<stdio.h>
main()
{
int num, n, sum, r;
clrscr();
printf("Enter a number for armstrong checknn");
scanf("%d",&num);
n = num;
sum = 0;
while(n != 0)
{
r = n % 10;
sum += r * r * r;
n = n / 10;
}
if( sum == num)
printf("nn%d is an armstrong numbern",num);
else
printf("nn%d is not an armstrong numbern",num);
}

Sample program 3 to calculate commission
#include<stdio.h>
main()
{
float commission, value;
printf("Enter value of trade: ");
scanf("%f",&value);
if (value < 2500.00)
commission = 30.00 + 0.017 * value;
else if (value < 6250.00)

else
if ( commission < 39.00)
commission = 39.00;
printf("commission: $%.2fn",commission);
return 0;
}

switch statement
switch statement
• The C switch statement is a conditional control statement that allows some
particular group of statements to be chosen from several available groups.
switch (expression)
{
case item1: statement1;
break;
case item2: statement2;
break;
case itemn: statementn;
break;
default:statement;
}

switch Statement
Example
switch (letter)
{
case ‘A’:
case ‘E’:
case ‘I’:
case ‘O’:
case ‘U’: number_of_vowels++;
break;
case ‘ ’ : number_of_spaces++;
break;
default : number_of_consonants++;
}

Sample program 4 Print number of days in a month
#include<stdio.h>
main()
{
int month;
clrscr();
printf("Enter the month number 1 to 12n");
scanf("%d",&month);
switch(month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
/*This statement will be executed for
all the above cases*/
printf("n31 days in monthn");
break;

case 4:
case 6:
case 9:
case 11:
/*This statement will be executed for
all the above cases*/
printf("n30 days in monthn");
break;
case 2:
printf("n28 or 29 days in monthn");
break;
default:
printf("nWrong Choicen");
break;
}
}

Summary
• if statement is a condition based decision making statement.
• Ternary operator is more efficient form for expressing simple if
statements
• The C switch statement is a conditional control statement that
allows some particular group of statements to be chosen from
several available groups.

5.0 Control Statements
Objectives
After completing this chapter, you will be able to
• Know the syntax and functions of for, while, and do-while
statement
• Know the usage of break and continue statement
• Write Programs using control structures

for Statement
• Looping statements allow the program to repeat a section of code
any number of times or until some condition occurs. For example,
loops are used to count the number of words in a document or to
count the number of upper case characters in a line of text.
for statement
The C for statement has the following form:
for (expression1; expression2; expression3)
statement;
or {block of statements}
• expression1 initializes the counter variable; expression2 is the
terminate test condition; expression3 is the modifier (which may be
more than just simple increment);

for Statement
Example : for Statement
main()
{
int x;
for (x = 3; x > 0; x--)
{
printf("x=%d n",x);
}
}
Output is
x=3
x=2
x=1

for Statement
Different formats of for Statement
• for (x=0 ; ((x>3) && (x<9)); x++)
• for (x=0, y=4; ((x>3) && (y<9)); x++, y+=2)
• for (x=0, y=4, z=4000; z ; z/=10)

while Statement
while Statement
• The while statement is used when the program needs to perform
repetitive tasks.
The while statement has the form:
while (expression)
statement;

while Statement
Example
int x=3;
main()
{
while (x>0)
{
printf("x=%dn",x);
x--;
}
}
Output is
x=3
x=2
x=1

while Statement
• Because the while loops can accept expressions, not just conditions, the following
are all legal:-
while (x--);
while (x = x+1);
while (x += 5);
• Using this type of expression, only when the result of x--, x=x+1, or x+=5, evaluates
to 0 will the while condition fail and the loop be exited.
• We can go further still and perform complete operations within the while expression:
while (i++ < 10);
while ( (ch = getche( )) != ‘q’)
putchar(ch);

do while Statement
The do-while statement
C's do-while statement has the form:
do
statement;
while (expression);

/* sin_series.c*/
# include <stdio.h>
# include <math.h>
# define PI 3.14159
void main()
{
int I,j,k;
float fangle,fproduct,fsum,fradians;
printf(“Enter the Angle :”);
scanf(“%f”,&fangle);
fradians =fangle*PI/180;
fsum=fradians;
for(i=3,k=1; i<=21; i+=2)
{
fproduct=1;
for(j=1; j<=i; j++)
fproduct=fproduct*j;
fsum=fsum+(pow(-1,k)*pow(fraduans,i))/fproduct;
k+=1;
}
printf(“Sine Value of %5.2f=%8fn”,fangle,fsum);
}

/*Reverse.c*/
# include <stdio.h>
# include <math.h>
void main()
{
int n,d,s=0,t;
clrscr();
printf(“Enter a number : ”);
scanf(%d”,&n);
t=n;
while(n!=0)
{
d=n%10;
s=(s*10)+d;
n=n/10;
}
printf(“n The Revers pf %d is %d”,t,s)
getch();
}

/*Determines the length of a message */
#include<stdio.h>
main()
{
char ch;
int len=0;
printf(“Enter a message : ”);
ch=getchar();
while (ch!=‘n’) {
len++;
ch=getchar();
}
printf(“Your message was %d character(s) long. n”, len);
return 0;
}

/*Determines the length of a message */
#include <stdio.h>
main()
{
int len=0;
printf(“Enter a message : ”);
while (getchar() != ‘n’)
len++;
printf(“Your message was %d character(s) long. n”, len);
return 0;
}

BREAK
for (d=2; d<n; d++)
if (n%d==0) break;
if (d<n)
printf(“%d is divisible by %d n”, n, d);
else
printf(“%d is primen”, n);
for (;;) {
printf(“Enter a number (enter 0 to stop) : ”);
scanf(“%d”, &n);
if (n==0) break;
printf(“%d cubed is %dn”, n, n*n*n);
}
while (. . . ) {
switch (. . . ) {
. . .
break;
. . .
}
}

CONTINUE
n=0;
sum=0;
while (n<10) {
scanf(“%d”, &i);
if (i==0) continue;
sum += I;
n++;
/* continue jumps to here */)
}
n=0;
sum=0;
while (n<10) {
scanf(“%d”, &i);
if (i==0) {
sum += I;
n++;
}
}

• Flowchart
statement
expression
false
Exit
True
Entry

do while Statement
Example:
int x = 3;
main( )
{
do
{
printf("x=%dn",x--);
}while (x>0);
}
Output is
x=3
x=2
x=1

• Examples
• #include<stdio.h>
• Main()
• {
• Int digit =0;
• Do
• Printf(“%dn”,digit++);
• While(digit<=9);
• }
• Do
• {
• printf(“x=“);
• Scanf(“%s,&x);
• Sum+=x;
• ++count;
• } while(count<=n)
• Average = sum/n;
• Printf(“n the average is %f n”,average);
• }

break and continue Statements
break and continue
• C provides two commands to control how we loop:
break - exit form loop or switch.
continue - skip 1 iteration of loop.
• Consider the following example where we read in integer values
and process them according to the following conditions. If the
value we have read is negative, we wish to print an error message
and abandon the loop. If the value read is great than 100, we wish to
ignore it and continue to the next value in the data. If the value is
zero, we wish to terminate the loop.

break and continue Statements
while (scanf( “%d”, &value ) = = 1 && value != 0)
{
if (value < 0)
{
printf(``Illegal valuen'');
break;
/* Abandon the loop */
}
if (value > 100)
{
printf(``Invalid valuen'');
continue;
/* Skip to start loop again */
}
/* Process the value read */
/* guaranteed between 1 and 100 */
....;
....;
} /* end while value != 0 */

Summary
Summary
• Looping allows the program to repeat a section of code any
number of times or until some condition occurs
• for statement is used to repeat a set of statements specified
number of times
• while and do..while statements are repetitive control structures,
that are used to carry out conditional looping

6.0 Arrays and Strings
Objectives
• Give a brief overview of arrays and strings
• Explain the memory layout of single and multi dimensional arrays
• List the merits and de-merits of arrays

Arrays
Introduction
• Array is one of the simplest data structure in computer programming.
• Arrays hold a fixed number of equally sized data elements, generally of
the same data type.

Introduction to Arrays
• Arrays are a data type that are used to represent a large number of
homogeneous values, that is values that are all of the one data type.
• The data type could be of type char, in which case we have a string.
• The data type could just as easily be of type int, float or even
another array.
• Array declaration int A[5] where int – data type, A – array
name, [5] – size of array.
• Array indices begin with ‘0’.
• The elements in the Array are always stored in consecutive memory
locations.

Memory Organization for an array
The Memory organization of an integer array A of 5 elements is
Shown below
A[0] A[1] A[2] A[3] A[4]
1 2 3 4 5
100 102 104 106 108
A

Array initialization :
int A[5]=[100,102,104,106,108];
Size can be omitted if the no of initializations are know.
Accessing array elements:
To access an array element, specify the array name followed by the
square brackets enclosing an integer called array index.
A[0] – access first element.
A[1] – access second element.

Warning:
“c” does not check the validity of subscript when you use arrays.
Main()
{
int A[40];
A[50] = 11;
A[50]++;
}
No error message is generated but incorrect result is obtained.

• Name of the array:
Float lan[50];
Name of the array ‘lan’.
When used without subscript it refers to the first element of array.
• Array subscripts can be expressions too, which evaluate to a
constant.
e.g. A[c+30];

“For “ loops used extensively for array processing
example 1: write a program to read an array and print.
#include<stdio.h>
Void main()
{
int I,a[10];
For(i=0;i<10;i++)
scanf(“%d”,&a[i]);
For(i-0;i<10;i++)
Printf(“n %d”,a[i]);
}

Example2: write a program to read integer number and copy it another
array.
Void main()
{
Int I,a[10],b[10];
For(i=0;i<10;i++)
/* copying into array b */
For(i=0;i<10;i++)
b[i]=a[i];
For(i=0;i<10;i++)
Printf(“%d %d n”,a[i],b[i]);
}

Example3: write a program to read 10 values and sum these 10 values
and print.
Void main()
{
Int I,a[10],sum=0;
/* reading */
For(i=0;i<10;i++)
{
sum=sum+a[i]; }
Printf(“sum of the 10 values %d”,sum);
}

Example4: write a program to read 10 values and store it in another
array in reverse order.
Void main()
{
Int I,a[10],b[10];
For(i=0;i<10;i++)
For(i=0;i<10;i++)
B[i]=a[9-i];
For(i=0;i<10;i++)
printf(“n a[%2d]=%2d b[%2d]= %2d”,i+1,a[i],i+1,b[i]);
}

Two dimensional array
Example : A class of 10 students scoring marks in 10 subjects.
Subjects
Student sub1 sub2 sub3 ……… sub10
S1
S2
S3
.
.
S10
Int mark[10][10]
The mark of s2 in sub1 can be represented as mark[2][1].
‘C’ allows us to define such table items using two dimensional arrays.
Horizontal line is called ‘row’ and vertical line is called ‘column’.

Matrix processing using arrays:
A value in a matrix is represented using two subscripts
Ai,j - refers to the value of ith
row, jth
column
Example: Write a program to add tw0 matrics.
Void main()
{
Int I,j,a[10][10],b[10][10],c[10][10];
Printf(“enter the values of the matrix A”);
For(i=0;i<10;i++)
for(j=0;j<10;j++)
{
scanf(“%d”,&a[i][j]);
scanf(“%d”,&b[i][j]);}

For(i=0;i<10;i++) {
for(j=0;j<10;j++)
{
c[i][j]=a[i][j]+b[i][j];
printf(“%d”,c[i][j]);
}
Printf(“n”); }
}
Example write a program to multiply two matrices.
#include<stdio.h>
#include<conio.h>
void main()
{
int m=0,n=0,o=0,p=0,i,j,k,a[10][10],b[10][10],c[10][10];
clrscr();

printf("enter the size of a");
scanf("%d%d",&m,&n);
printf("enter the size of b");
scanf("%d%d",&o,&p);
printf("enter the elements of A");
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&a[i][j]);
}
}
printf("enter the elements of B");

for(i=1;i<=n;i++)
{
for(j=1;j<=p;j++)
{
scanf("%d",&b[i][j]);
}
}
for(i=1;i<=n;i++)
{
for(j=1;j<=p;j++)
{
c[i][j]=0;
for(k=1;k<=n;k++)
{
c[i][j]+=a[i][k]*b[k][j];
}
}
}

for(i=1;i<=n;i++)
{
for(j=1;j<=p;j++)
{
printf("%dt",c[i][j]);
}
printf("n");
}
getch();
}

Multi Dimensional Arrays
• The elements of an array can themselves be arrays.
• The following example declares and creates a rectangular integer
array with 10 rows and 20 columns
int a[][] = new int[10][20];
for (int i = 0; i < a.length; i++)
{
for (int j = 0; j < a[i].length; j++)
{
a[i][j] = 0;
}
}
• The elements are accessed as a[i][j]. This is a consistent notation
since a[i][j] is element j of the array a[i].

Advantages & Limitations
Advantages
• Arrays are,
– Simple and easy to understand
– Contiguous allocation
– Fast retrieval because of its indexed nature
– No need for the user to be worried about the allocation and de-allocation of
arrays
Limitations
• If you need m elements out of n locations defined,
– n-m locations are unnecessarily wasted if n>m
or
– an error occurs if m>n named out of bounds error.

Strings
• Strings are sequences of characters.
. Strings are just character arrays with a few restrictions. One of these
restrictions is that the special character ‘0’ (NULL) is used to indicate the
end of a string.
• String constant does not have an integer value
‘A’- A – 65
“A” = A 0 – no integer value.
• For example, the following defines a string of 5 characters:
char name[5];
int main( )
{
name[0] = ‘A’;
name[1] = ‘R’;
name[2] = ‘U’;
name[3] = ‘N’;
name[4] = ‘0’;
return 0;
}

Declaring string:
Generate form or syntax of declaration
Char variable-name[size];
Datatype identifier sizeof the identifier
Eg.
Char acname[10],acbook[20];
Acname ---array size is 10 , 9 characters and a null character.
Initializing string:
Char acname [7] = “gandhi”;
This is equivalent to
Char acname[] = {‘g’,’a’,’n’,’d’,’h’,’i’,’0’};
This first method 0 is automatically inserted where as in the second
method user has to specify it.

Strings
• C doesn’t allow one array to be assigned to another, so we can’t
write an assignment of the form.
name = “ARUN”; /* illegal*/
• Instead we must use the standard library function strcpy to copy
the string constant into the string variable.
strcpy(name,“ARUN”);
• To print a string we use printf with a special %s control character:
printf(“%s”,name);

The standard character string input functions are,
scanf(“%s”, string_name);
gets(string);
• Ampersand (&) is not needed.
• It is an error to use an ampersand.
• The %s option uses a blank space as a delimiter,since it considers
character seperated by a blank space as two strings.
• Gets() for reading string from user,it overcomes the disadvantage
of scanf().
• Gets() can read any length of string with any number of blank
spaces and tabs. It terminates when an enter key is pressed.
The standard character string output functions are,
printf(“%s”,string);
puts(string);

Strings
There are several standard routines that work on string variables.
Some of the string manipulation functions are,
strcpy(string1, string2); - copy string2 into string1
strcat(string1, string2); - concatenate string2 onto the end
of string1
strcmp(string1,string2); - 0 if string1 is equals to string2,
< 0 if string1 is less than string2
>0 if string1 is greater than string2
strlen(string) - get the length of a string.
strrev(string) - reverse the string and result is stored
in same string.

Using putchar and puts function:
Char ch = ‘A’;
Putchar(ch);
The function putchar() prints one character
Putchar(ch); == printf(“%c”,ch);
Puts() prints the value of string variable str and then moves the cursor
to the beginning of the next line on the screen.

String compare:
Strcmp(string1,string2);
It returns’0’ if equal.
It returns ’- ve’ value is string 1 is alphabetically above.
It returns ‘+ve’ value if string2 is alphabetically below.
String copy :
Strcpy(string1,string2)
String2 gets copied into string1.
String1 is overwritten.
String1 should be large enough to receive string2.

Program to copy string2 to string1.
#include<stdio.h>
#include<string.h>
Void main()
{
Char str1[25],str2[25];
Printf(“enter the string”);
Gets(str2);
Strcpy(str1,str2);
Printf(“source string is %s”,str2);
Printf(“copied string ios %s:,str1);
}

Program to count length of string excluding null character.
#include<stdio.h>
#include<string.h>
Void main()
{
Char acstr[25];
Printf(“enter a string”);
Gets(acstr);
Printf(“the length of the string is %d”,strlen(scstr));
}

Program to reverse a string.
#include<stdio.h>
#include<string.h>
Void main()
{
Char acstr[29];
Printf(“enter the string:”);
Gets(acstr);
Printf(“the reversed string is %s”,strrev(acstr);
}

Program to convert into lower case
#include<stdio.h>
#include<string.h>
Void main()
{
Char acstr[25];
Printf(“enter the string”);
Gets(acstr);
Printf(“the case changed string is %s”,strlwr(acstr));
• }

Program to sort a list of string alphabetically
#include<stdio.h>
#include<string.h>
Void main()
{
Int I,n=0;
Char x[10][12];
Printf(“enter a string on separate linesn n”);
Printf(“type END when finished nn”);
/* read in the list*/
Do
{
Printf(“string %d:”,n+1);
Scanf(“%s”,x[n]);
}while (strcmp(x[n++],”END”);

?* adjust value of n */
N--;
/*reorder list of strings*/
Reorder(n,x);
/*display the reorder list of strings*/
Printf(“nn reorder list of stringsn”);
For(i=0;i<n;++i)
Printf(“n string %d :%s”,i+1,x{i]);
}
Void reorder(int n,char x[][12])
{
Char temp[12];
Int I,item;
For(item=0;item<n-1;++item)
For(i=item+1;i<n;i++)
If(strcmp(x[item],x[i]>0) {
Strcpy(temp,x[item]);
Strcpy(x[item],x[i]);
Strcpy(x[i],temp); }
return;
}

Program to compare two strings.
#include<stdio.h>
#include<string.h>
Void main()
{
Char acstr[25],accmp[25];
Int inum;
Printf(“enter a string :”);
Gets(acstr);
Printf(“enter the second string”);
Gets(accmp);
Inum=strcmp(acstr,accmp);
If(inum == 0)
Puts(“strings are equal”);
Else if(inum>0)
puts(“string %s greater than string %s”,acstr,accmp);
Else
puts(“string %s is greater than string %s”,accmp,acstr);
}

Summary
Summary
• The simplest type of data structure is a linear array
• An array can be defined as a collection of homogenous elements, in
the form of index/value pairs, stored in consecutive memory
locations. An array always has a predefined size and the elements
of an array are referenced by means of an index / subscript.
• An array can be of more than one dimension. There are no
restrictions to the number of dimensions that we can have.
• Arrays of Characters are called as Strings

Introduction to Pointers
Objective
After completing this presentation you will be able to
• Understand Pointers
• Compare Pointers and Arrays
• Understand Character Pointers
• List the advantages and limitations of Pointers

Introduction to Pointers
• Every program and data occupies memory space.
• Every variable occupies one or more bytes. The address of the
first byte is the address of the variable.
• Although address are represented by numbers their range of
values may differ from that of integer.
• Hence they cannot be stored in ordinary integer variables and they
need to be stored in special variable called pointer variable.
• In other words pointers is nothing more than an address and
pointer variable is a just a variable that can store an address.

Declaring pointer variable
• int *p;
• Same as any other declaration except for the ‘*’ .
• This * indicates that p is a pointer variable capable of pointing to object
of type int.
• Pointer variable can appear alongside other variable.
• Example:
int I,j,a[10],*p,*q;
float a,b,*r;
char *w;
There are no restrictions on what the referenced type may be.

Address & indirection operators
• These are two operators designed specifically for use with pointers.
• & - address operator to find the address of variable.
• * - indirection operator helps to gain access to the object that the
pointer points to.
• If p is ppinter then *p represents object to which ‘p’ is currently pointing.
Address operator:
Like any other variable it is crucial to initialize a pointer variable before we
use it.
int I,*p;
p= &I;
int I,*p = &I; is also valid.

Indirection operator
• One pointer variable is initialized( points to an object) we can use
indirection operator to access what is stored in the object.
• int i = 10, *p = &I;
• printf(“%d n”, *p);
Eg j=*&i; same as j=i;
p=&i; i=10;
printf(“%dn),i);
printf(“%dn”,*p); prints 10
*p = 20;
printf(“%dn”,i);
printf(“%dn”,*p); prints 20

Pointer assignment
• C allows the use of assignment operator to copy pointers provided they
are of same type.
• Eg int i,j,*p,*q;
• p=&i; q=p; both p and q points to the same variable.
• *p=1; value can be assigned to i either *p or *q.
• *q = 2;
• p=&i; q=&j;
• *p=2;
• *q=*p;

Pointers as arguments
• A variable supplied as an argument in a function call is protected against
change when ‘c’ passes arguments by value.
• If we need the function to be able to modify the variable we should pass
by reference and this is accomplished using pointers.
• Eg decompose – A function which separates the integer and fractional
part of a floating pointer number.
• Void decompose(float x, int * ,float *);
• Main()
• { -----;
------;
decompose(3.14159, &i, &f);
----;
}

• Void decompose(float x,int *int-part,float *float-part)
• {
• * int-part = (int) x;
• * float-part = x - *int-part;
• }
Examples:
main()
{ int x = 7 ;
int *px ; /* px is a pointer to an integer */
px = &x ; /* px gets the address of x */
printf( "%dn" , x ) ; /* show the value of x */
printf( "%dn" , &x ) ; /* show the address of x */
printf( "%dn" , *px ) ; /* show the value of what px points to */
}

Pointer Arithmetic
• Pointer Addition or subtraction is done in accordance with the
associated data type.
– Integer => adds 4 for every increment
– Char => adds 1 for every increment
– float => adds 4 for every increment
• Example
int * ptr , i=5;
ptr= &i; let ptr = 1000 (location of i)
ptr ++; now ptr = 1001 but it is 1004 or +4 (integers)
++*ptr or (*ptr)++ => increments the value of i by 1
*ptr++ => increments the address of i by 1
• ++ptr and ptr++ are both equivalent to ptr + 1 (though the point in the
program when ptr is incremented may be different), incrementing a pointer
using the unary ++ operator, either pre- or post-, increments the address it
stores by the amount sizeof(type) where "type" is the type of the object
pointed to. (i.e. 4 for an integer)

Pointers and Arrays
• The address of the 1’st element of an array is represented by its
name
• Example
int a[5] ;
a => &a[0]
a+1 => &a[0] + 1
(a+i) ; i varies from 0 to 4 ; traverses through the address of each element in
the array ‘a’
a+i (i=0) => &a[0]
a+i (i=1) => &a[1]
a+i (i=2) => &a[2]
a+i (i=3) => &a[3]
a+i (i=4) => &a[4]

Finds the largest and smallest elements in an
array.
• include<stdio.h>
• define n 10
• void max-min(int a[], int n, int *max, int *min);
• main()
• {
• int b[n], i, big, small;
• printf(“enter %d numbers”,n);
• for(i=0;i<n;i++)
• scanf(“%d”,&b[i];
• max-min(b,n,&big,&small);
• printf(“largest : %d n”,big);
• printf(“smallest:%dn”,small);
• return 0;
• }

• Void max-min(int a[], int n, int * max, int *min)
• {
• int i;
• * max = * min = a[0];
• for(i=1;i<n;i++){
• if(a[i] > *max)
• * max = a[i];
• Else if(a[i] < * min)
• *min=a[i];
• }
• }

Pointers and Arrays
• In C, the standard states that wherever we might use &var_name[0]
we can replace that with var_name, thus in our code where we
wrote:
– int *ptr, my_array[]={10,20,30,40 };
– ptr = &my_array[0];
– we can write:
– ptr = my_array;
• ptr is a variable, my_array is a constant. That is, the location at
which the first element of my_array will be stored cannot be
changed once my_array[] has been declared
• We cannot write
– my_array = ptr;
– Or
– my_array++;

Pointers and 2-D Arrays
• In a 2-D array each row may be thought of as an 1-D array
• When a 2-D array is declared in the following way,
– my_array[10][5];
• The expression (my_array + 0) gives the address of the 0th
element
of the 2-D array
• The expression *(my_array + 0) gives the base address of 0th
1-D
array
• The expression *(*(my_array + 0) + 0) gives the value of the element
my_array[0][0]

Character Pointers
• Character pointer is a pointer, which is capable of holding the address of a
character variable. Suppose if we have a character array declared as
char name[30] = {“Data Structures”};
• If we need to store the address of this array we need a character pointer
declared as follows
char *p = NULL;
• Once the pointer is declared we need to assign the address of the array to
this pointer. i.e.
p = name;
• Now issue the following printf statements and check the output
printf(“character output = %cn”, *p);
printf(“String output = %s”, p);

Character Pointers
• We know that when we refer to a pointer with the indirection
operator we refer to the content of the address pointed by the
pointer. The above printf statements will product the output as
follows:
character output = D
String output = Data Structures
• The reason for the output produced by the second printf statement
is because of the %s format specifier, which will print the string till
it encounters a ‘0’ character.

malloc() function
• malloc( ) is the function used for memory allocation in C. malloc()
takes one argument that is the number of bytes to allocate.
Suppose P is a pointer then
int *p;
p = (int *)malloc(sizeof(int));
• The above assignment will allocate memory for holding an integer
value.
• The system allocates memory from the heap and not from the stack.
• For freeing the allocated memory the function used is,
free(<pointer variable>);

Advantages of Pointers
• It gives direct control over memory and thus we can play around
with memory by all possible means. For example we can refer to
any part of the hardware like keyboard, video memory, printer, etc
directly.
• As working with pointers is like working with memory it will provide
enhanced performance
• Pass by reference is possible only through the usage of pointers
• Useful while returning multiple values from a function
• Allocation and freeing of memory can be done wherever required
and need not be done in advance

Limitations of Pointers
• If memory allocations are not freed properly it can cause memory
leakages
• If not used properly can make the program difficult to understand
• its values need to be stored somewhere. It is the nature of the
pointers value that is new.

Summary
SUMMARY
• A pointer is a datatype whose value is used to refer to ("points to")
another value stored elsewhere in the computer memory. Obtaining
the value that a pointer refers to is called dereferencing the pointer.
• Pointers are variables that can hold the address of another variable
• Pointer addition and subtraction involves incrementing/
decrementing pointer depending upon the associated data type
• The difference between arrays and pointers is array name is a fixed
pointer, whereas a pointer can point to any element of an array

8.0 Functions
Objectives
After completing this chapter you will be able to
• Understand the utility of user-defined functions
• Define and Invoke functions
• Define Methods of passing data among Functions
• Define Function proto-types
• Pass arguments to main( ) functions through Command-line
arguments
• Understand the usage of auto, static, and extern storage qualifiers
• Understand the concept of Recursion
• Write Programs with efficient, concise functions

Need for functions
Need for the Functions
As, programs become more complex and large, several
problems arise. Most common are
• Algorithms for solving more complex problems become more
difficult and ,hence difficult to design
• Even if algorithms are known, its implementation becomes more
difficult because the size of the program is longer
• As programs become larger and complex, debugging and testing
becomes more difficult.
• As programs become larger and complex, more documentation is
required to make the program understandable for people who will
use and maintain the program

Functions
Defining a Function
In C, a program is a collection of well defined and interrelated
functions. The general form of a function is as follows
return-type function(type arg1, type arg2, …..)
{
local variables Declaration;
executable statement 1;
executable statement 2;
:
:
return(expression);
}

Functions
Example 1: Function for finding the biggest of two integers
int find_big(int a, int b)
{
if ( a > b) return a;
else return b;
}

Functions
Invoking a Function
• The user-defined functions are accessed from a function simply by
its name and actual arguments / parameters enclosed with in
parentheses.
• These actual arguments are used to pass values formal arguments
defined in the function.
• When the function call is encountered, the control is transferred to
the called function.
• The formal arguments are copied by actual arguments and the
execution of the function is carried out.
• When the return statement is executed or last statement has
finished its execution, the control is transferred back to the place of
function call in the calling function.

Functions
Example
Program for finding biggest of two integers using the function
void main( )
{
int num1, num2, big;
scanf(“%d%d”, &num1, &num2);
big=find_big(num1,num2);
printf(“ The biggest is : %d “, big);
}
int find_big(int a, int b)
{
if ( a > b) return a;
else return b;
}

Local and Global Variables
• The variables declared inside a function are local to that function. It
can be accessed only with in that function. Memories for the local
variables are allocated only when the function is invoked and
deallocated when the control returns to the calling function. These
variables are also known to be automatic variables.
• The variables declared outside of all function are global variables.
These global variables are visible to all functions.

Example : Usage of Global Variables
int a; /* Global variable */
float b; /* Global variable */
void main()
{
int c; /* Local variable*/
a=10;
b=1.2;
c= 20;
fun( );
printf(“ %d “, a); /* prints 20 */
}
void fun()
{
a+=10;
}

Passing arguments to a function
Passing arguments to a Function
• The mechanism used to pass data to a function is via argument list.
There are two approaches to passing arguments to a function.
These are
– Call by Value
– Call by Reference

Call by Value
Call by Value
Example Program that illustrates Call by Value mechanism
void main()
{
int a, b;
a=10;
b=20;
swap(a, b); /* passing the values of a and b to c and d of swap function*/
printf(“%d %d”, a, b); /* Prints 10 20 */
}
void swap(int c, int d) /* Function used to swap the values of variables c and d */
{
int temp;
temp = c;
c = d;
d = temp;
}

Call by Reference
Call by Reference
• In this approach, the addresses of actual arguments are used in the
function call. The formal arguments should be declared as Pointer
variables.
• This approach is of practical importance while passing arrays and
structures among functions and also for passing back more than
one value to the calling function.

Call by Reference
Example : Program that illustrates Call by Reference mechanism
void main()
{
int a, b;
a=10;
b=20;
swap(&a, &b); /* passing the addresses of a and b to c and d of
swap function*/
printf(“%d %d”, a, b); /* Prints 20 10 */
}
void swap(int *c, int *d)
{
int temp;
temp = *c;
*c = *d;
*d = temp;
}

Passing arrays to functions
• Passing one dimensional array : Length of array is left unspecified.
• Eg int f ( int a[]) /* no length specified*/
• {
• }
• Length is passed as an additional argument since function has no
way of knowing the size.
• int sum-array(int a[],int n)
• {
• int i,sum=0;
• for(i=0;i<n;i++)
• sum+=a[i];
• Return sum;
• }

• Protype:
• int sum-array( int [], int );
• Call:
• Main()
• {
• int b[len], total;
• ….
total = sum-array(b,len);
• ….
• }
• A function has no way to check the actual size of array we can
exploit this fact by telling the function to process lesser no of
elements in the array.
• B[100] – can hold 100.
• Still by specifying n to be 50 it can add first 50 elements and ignore
the rest.

• Two dimensional array only first dimension can be omitted out
second cannot be omitted.
• Int sum-array( int a[][len],int n)
• {
• int i,j,sum=0;
• for(i=0;i<n;i++)
• for(j=0;j<len;j++)
• sum+=a[i][j];
• return sum;
• }
• Here are observe than a two dimensional array cannot be passed
with an arbitrary number of column. This can be addressed using
pointers.

Function Prototyping
Function Prototyping
• Function prototype is a function declaration that specifies the
return type and data types of the arguments.
• A function prototype/declaration informing the compiler the number
and data types of arguments to be passed to the function, and the
data type of the value returned by the called function.
• Prototype for the function find_big
int find_big(int, int);
• Prototype for the swap function written
void swap(int *, int*);
• Usually prototypes appear at the beginning of a Program.

Storage Classes
Storage Classes
• Every variable in C possesses a characteristic called storage class.
The Storage class defines two characteristics of a variable.
Its Life time
Its visibility or scope
• Life time: The life time of a variable is the length of time, it retains a
value in memory
• Visibility: Visibility or Scope of a variable refers to those parts of a
program which will be able to recognize it.

Storage Classes
• The storage class precedes the variable’s declaration and tells the
compiler how the variable should be stored in memory. C supports
following four storage classes:
• Auto
• Static
• Extern
• Register
• If the storage class is omitted at declaration, it is assumed of type
auto storage class.

auto storage class
auto Storage Class
• Stored in Memory
• If not initialized in the declaration statement, their initial value is
unpredictable value often called garbage value
• Local (visible) to the block in which the variable is declared. If the
variable is declared with in a function, then it is only visible to that
function.
• It retains its value till the control remains in that block. As the
execution of the block/function is completed, it is cleared and its
memory destroyed.

auto Storage Class
Example: Program illustrating auto variables
void main( )
{
fun( );
fun( );
fun( );
}
void fun( )
{
auto int b = 20; /*Auto (Local) variable to fun() */
b++;
printf( “ Calling Fun( ) : %d n“, b);
}
The output of the above program is as follows
Calling Fun( ) : 21
Calling Fun( ) : 21
Calling Fun( ) : 21

Static Storage Class
• Stored in Memory
• If not initialized in the declaration, it is initialized to zero.
• Local(Visible) to the block in which the variable is declared. If the
variable is declared inside a function, then it is visible to that
function. But, if the variable is declared outside the function, then it
is visible to all functions following its declaration.
• It retains its value between different function calls. That is, when for
the first a function is called, a static variable is created with initial
value zero, and in subsequent calls it retains its present value.

Example : Program illustrating Static variables
void main( )
{
fun( );
fun( );
fun( );
}
void fun( )
{
static int b = 20; /*Static variable to fun( ) */
b++;
printf( “ Calling Fun( ) : %d n“, b);
}

• The output of the above program is as follows
Calling Fun( ) : 21
Calling Fun( ) : 22
Calling Fun( ) : 23

Register Storage Class
Register Storage Class
• Stored in Processor registers, if register is available. If no register
is available, the variable is stored in memory, and works as if its
storage class is auto.
• If not initialized in the declaration, the variable is initialized to zero.
• Local(Visible) to the block in which the variable is declared. If the
variable is declared inside a function, then it is visible to that
function. But, if the variable is declared outside the function, then it
is visible to all functions following its declaration.
• It retains its value till the control remains in that block. As the
execution of the block/function is completed, it is cleared and its
memory destroyed.

Extern Storage Class
• The Scope of external variables is global. External variables are
declared outside all functions, usually in the beginning of the
program file. As all the function will be defined after these variables
declaration, these variables are visible to all functions of the
program.
• This storage class is useful for a multi files program.
• Stored in memory
• If not initialized in the declaration, it is initialized to zero.

Example
Program File a.c
int val; /*Global */
void main( )
{
scanf(“ %d “, &val);
compute( );
printf(“ %d “, val);
}
Program File b.c
void compute( )
{
extern int val; /*This implies that, the variable val is defined in another
file*/
val++;
}

Recursion
Recursion
• If a function is having a self-reference, it is recursion. In order that
the function should not continue indefinitely, a recursive function
must have the following properties:
- There must be certain criteria, called base criteria, for which a
function does not call itself.
- Each time, when a function calls itself, it must be close to the
base criteria. That is, it uses an argument(s) smaller than the one it
was given at previous reference.

Recursion
Example Illustrative examples of Recursive function
Factorial Function : n! = n * (n-1)!
Base Criteria is 0! =1
int factorial( int n)
{
if(n <= 0)
return 1;
else
return( n* factorial(n-1));
}

Execution of the factorial
n = fact(3);
• Step1: fact(3) - finds that 3 is not less than or equal to 1, so it calls
fact(2).
• Step2: fact(2) – which finds that 2 is not less than or equal to 1, so
it calls fact(1).
• Step3: fact(1) – which finds that 1 is less than or equal to 1, so it
returns 1, causing
• fact(2) to return 2*1=2,causing
• fact(3) to return 3*2=6.

Write a program to generate fibonacci series using recursive function.
#include<stdio.h>
Void fibo(int,int,int);
Void main()
{
Int i=-1,j=1,k=0;
Printf(“n enter the number of terms in the fibonacci series”);
Scanf(“%d”,&k);
Printf(“n the fibonacci series is …n”);
Fibo(k,I,j);
}
Void fibo(int k,int I,int j)
{
If(k==0)
exit(0);
Printf(“%d”,i+j);
Fibo(--k,j,i+j);
}

Execution of the above program
k I j print
5 -1 1 0
4 1 0 1
3 0 1 1
2 1 1 2
1 1 2 3
0

Command Line Arguments
Command line arguments
• The main( ) function can receive arguments from the command line. These
arguments, which are used sent data to main( ) function are known as
command line arguments
• The command-line arguments are accepted by the main() function through
special parameters namely argc and argv. Their declarations are as
follows:
void main ( int argc, char *argv[])
{
:
}
• argc provides a count of the number of command line argument
• argv is an array of character pointer of undefined size that can be thought
of as an array of pointer to strings, which are command line strings.

• Example : Program illustrating command line arguments
void main( int argc, char* argv[])
{
int i;
printf(“n Total Number of Arguments = %d”,argc);
for( i = 0; i < argc; i++)
printf(“nArgument number %d = %s”,i , argv[i]);
}
• Assume that this program is stored in a file test.c and got compiled.
Now, in the operating system prompt if we type a command as
test one two three four

Then the result will be
Number of Arguments = 5
Argument number 0 = test
Argument number 1 = one
Argument number 2 = two
Argument number 3 = three
Argument number 4 = four

Functions and Arrays
Single dimensional arrays can be passed to functions as follows:-
float find_average(int size, float list[])
{ int i;
float sum=0.0;
for (i=0;i<size;i++)
sum+=list[i];
return(sum/size);
}
Here the declaration float list[] tells C that list is an array of float. Note
we do not specify the dimension of the array when it is a parameter of
a function.

Multi-dimensional arrays can be passed to functions as follows:
void print_table(int xsize,int ysize, float table[][5])
{ int x,y;
for (x=0;x<xsize;x++)
{ for (y=0;y<ysize;y++)
printf("t%f",table[x][y]);
printf("n");
}
}
Here float table[][5] tells C that table is an array of dimension N*5 of
float. Note we must specify the second (and subsequent) dimension of
the array BUT not the first dimension.

Function Pointer
• A function in C has an address and it can be pointed using a pointer
• A function pointer is declared in the following way,
int (*func_ptr) ();
• The address of a function is assigned to a function pointer in the
following way,
– int display();
– int (*func_ptr) ();
– func_ptr = display;
– (*func_ptr) (); // invokes the function display

Summary
Summary
• A function facilitates Reusability and Procedural abstraction
• Function Proto-type is a model of a function.
• The Command-line arguments argv and argc are used to pass
arguments to a main() function.
• The storage qualifiers auto, static, register and extern are used for
memory management of variables.
• Recursive functions are used to solve complex problems but
recursive in nature.

9.0 Structures and Unions
Learning Objectives
After the completion of this module, you will be in a position to
• Understand the concepts of Structures and Unions
• Understand the applications of Structure and Unions
• Write Programs for processing structures and Unions

Structures
Structure
• A Structure is a group of data items of different data types held
together in a single unit.
• It is used to represent an entity, which is described with a set of
attributes.
• For example, an employee is represented by the attributes
employee code (an Integer number), employee’s name (a character
array), Department Code ( an Integer number), Salary( a Floating
point number) and so forth.

Structures
Declaring a Structure and its Variables
The syntax for declaring a structure is as follows
struct struct-name
{
type variable-name, variable-name,........;
:
:
}struct-variable, struct-variable...... ;

Structures
Example
struct employee_type
{
int code;
char name[20];
int dept_code;
float salary;
} emp1, emp2;
• Here, employee_type is a Tag. The fields inside this structure are
code, name, dept_code and salary. The variables of the type
emplyee_type are emp1 and emp2.

Structures
• By using the structure tag, other variables, function arguments can
be declared as follows
struct struct-name var1, var2, .....;
• For example, we can define a variables of type employee_type as
follows
struct employee_type emp1, emp2;

Structures
Accessing Structure Elements
• The elements/fields of a structure variable are accessed using dot
operator ‘.’. The syntax for accessing a members of a structure variable
is
variable.field
• For example, to access a fields of a variable emp1, emp2 defined in
the above example , we can use the dot operator as follows
emp1.code
emp1.name
emp1.dept_code
emp1.salary
emp2.code
emp2.name
emp2.dept_code
emp2.salary

Structures
Initializing Structures
• Like simple variables and arrays, structure variables can also be
initialized at the time of declaration. The format used is quite similar
to initialize an array.
Example
struct stud_type
{
int rollnum;
char name[20];
int semester;
float avg;
};
struct stud_type stud1={1001,”Aldina”, 1, 90.78}, stud2={1002, “Raja”,
1,79.28};

Structures
Array of Structures
Example
struct stud_type
{
int rollnum;
char name[20];
int semester;
float avg;
};
struct stud_type stud[50];

Structures
• In the above example, stud is an array that consists of 50 structure
of type stud_type. To access the 0th structure, we can do it as
follows,
stud[0].rollnum
stud[0].name
stud[0].semester
stud[0].avg

Pointers and Structures
Pointers and Structures
• As we can use pointers with other types, we can also use pointers
for structure variables. We can declare pointer to a student
structure as follows
struct stud_type *ptr;
• In this declaration, ptr is a pointer type variable, which can hold an
address of a variable of the type stud_type.

Structures
Example
struct stud_type
{
int rollnum;
char name[20];
int semester;
float avg;
};
struct stud_type stud={1001,”Aldina”, 1, 98.23}, *ptr ;
• In this example a structure variable stud is defined and initialized. The pointer variable ptr is
declared.
• Now to make ptr to point to the structure stud, we can write as
ptr = &stud;
• After this assignment, the structure stud can be accessed through the pointer ptr. The notation
for referring a field of a structure pointed by a pointer is as follows
(*pointer).field (OR) pointer -> field
• So, We can access the fields of a stud through a pointer ptr as follows
Printf(“ %d %s %d %f “, ptr->rollnum, ptr->name, ptr->sem, ptr->avg);

Structures
Nested Structure
• Just as there can be arrays of arrays, there can be a structure that
contains other structures. This can be a powerful tool to create
complex data types.
Example
struct date
{
int day;
int month;
int year;
};

Structures
{
int code;
char name[20];
struct date doj;
int dept_code;
float salary;
}emp1,emp2;
• In this example, if we want to access the year of joining of an
employee of emp1, then we can do so by writing
emp1.doj.year

Unions
Unions
• As like structures, Union is also used to group data fields of
different type, but unlike structures all data fields are sharing a
common memory.
• That is, a union permits a section of memory to be treated as a
variable of one type on one occasion, and as a different variable of
a different type on a another occasion.
• The syntax for declaring a union, declaring variables of union type,
accessing elements of union is identical to that of structures. Union
differs from structure in storage and in initialization.

Unions
Example
union u_type
{
char var1;
int var2;
float var3;
double var4;
}u_var;

Union of Structures
Union of Structures
• There can be structures with in unions and unions with in
structures. The following block of code illustrates union of
structures.
Example
{
int code;
char name[20];
int dept_code;
float salary;
};

Union of Structures
struct stud_type
{
int rollno;
char name[20];
int age;
float avg;
};
union person
{
struct employee_type e1;
struct stud_type s1;
}ex;

Union of Structures
• In the above example, the union makes the structure variables e1
and s1 to share a common memory space.
• That is, the user can use either e1 or s1, but not both at the same
time. The elements of this union of structures are accessed using
dot operator as follows.
ex.e1.salary

typedef Statement
Defining New Data Types using typedef
• typedef can also be used with structures. The following creates a new type
agun which is of type struct gun and can be initialised as usual:
typedef struct gun
{
char name[50];
int magazinesize;
float calibre;
} agun;
agun arnies={"Uzi",30,7};
• Here gun still acts as a tag to the struct and is optional.
• agun is the new data type. arnies is a variable of type agun which is a
structure.

Enumerated types
Enumerated Types
• Enumerated types contain a list of constants that can be addressed
in integer values.
• We can declare types and variables as follows.
enum days {mon, tues, ..., sun} week;
enum days week1, week2;
• As with arrays first enumerated name has index value 0. So mon
has value 0, tues 1, and so on. week1 and week2 are variables.
• We can also override the 0 start value:
enum months {jan = 1, feb, mar, ......, dec};
Here it is implied that feb = 2 etc.

Summary
Summary
• Structures are used to group different types of data, and to
represent any real-time entity
• Union is similar to structures but, memory is shared by the
members
• typedef is used to define a new data type

Chapter 10. Files
Learning Objectives
• Understand the concepts of files
• Understand the basic operations of file
• Understand the functions of Preprocessor directives

Files
Overview of Files
• A file is collection of related data stored on hard disks or an
auxiliary storage device such as magnetic tape or disk. Files can be
accessed using Library Functions or System Calls of Operating
System.
• The files accessed through the library functions are called stream-
oriented files and the files accessed with system calls are known as
system oriented files.

Files
• Based on internal storage representation of files we can have two
types of files.
- Text file
- Binary file
Text File:
• The I/O stream can be a text stream or binary stream. A text
stream is a sequence of text. In a text stream, each line consists of
zero or more characters, terminated with new line character.
Binary File:
• A binary stream is a sequence of bytes. In a binary stream, it
represents raw data without any conversion. For example, the new
line character ‘n’ is not mapped to carriage return while using the
binary streams.

Files
• In C, FILE is a structure that holds the description of a file and is
defined in stdio.h.
Processing Files
The Processing of files involves the following steps :
- Opening a File
- Reading from or writing into a File
- Closing the File

Files
• Standard Input/output
• Standard I/O is the easiest and most commonly used way of
performing file I/O in C language. The Standard I/O in C provides
variety of functions to handle files. It supports the following ways of
reading from and writing into file.
- Character I/O
- String I/O
- Formatted I/O
- Block I/O

Files
Mode Purpose
r Open for reading, the file must already exist.
w Open for writing. If the file exists, the content will be vanished
a Opening for append. Writing at the end of file. If the file does
not exist, it will be created
r+ Open for both reading and writing. The file must exist already
w+ Open for both reading and writing. If the file exists already the
content will be vanished.
a+ Open for reading and appending. If the file does not exist, it
will be created
rb Same as mode “r”, but for binary file
wb Same as mode “w”, but for binary file.

Files
Example : Program segment that opens a file.
FILE *fptr;
fptr = fopen(“test.dat”, “w”);
if ( fptr = = NULL)
{
printf(“ n File open failed n”);
exit( 1);
}
else
printf(“n The file is opened successfully for Writingn”);

Files
Closing a File
• When a program has finished with reading/writing of a file, it must
be closed. This task is done by the library function fclose, which is
defined in stdio.h.
fclose(fptr);
where fptr is a file pointer associated with the file, which is to be
closed.

Files
Character I/O
• Using character I/O, one character(byte) can be written to or read from a
file at a time. The functions putc and getc are used to write and read a byte
respectively from/to a file. The syntax of putc is as follows
putc(ch, fptr);
• This function writes the character ch into a file pointed by the file pointer
fptr. This fptr may be stdout, which represents standard output device ,
Screen, as a file.
• The syntax of function getc is as follows
ch =getc(fptr);
where ch is a character variable and fptr is a file pointer. This function read a
next character from the file and it is returned. The fptr may be stdin, which
represents a standard input device, keyboard as a file. The EOF is end of file
status flag, which is true if end of file is reached, otherwise false.

Files
Example : Program for reading a line from the keyboard and writing
into a file.
#include <stdio.h>
main( )
{
FILE *fptr;
char ch;
fptr = fopen( “test.dat”, “w”);
while( (ch=getc(stdin))!=’r’)
putc( ch, fptr);
fclose(fptr);
}

Files
Example : Program for reading characters from a file and writing to
the screen until end of file.
#include <stdio.h>
main( )
{
FILE *fptr;
char ch;
fptr = fopen( “test.dat”, “r”);
while( (ch=getc(fptr))!=EOF)
putc( ch, stdout);
fclose(fptr);
}

Files
String Input/Output
• C language is also providing functions for reading and writing data in the
form of string from/to a file. The functions namely fgets( ) and fputs( ).
These functions are analogous to gets( ) and puts( ), which are used to
read a string from a keyboard and write a string into a screen. The syntax
for writing a string into a file is as follows
fputs(str, fptr);
where, str is a array of characters, fptr is file pointer. This function will write
the string str into a file pointed by fptr.
• The syntax for reading a string from the file is as follows
fgets(str, n, fptr);
where str is a array of characters, where the string read from a file is stored, n
is a maximum length of the string to be read, and fptr is a file pointer. This
function will read a string terminated by null, new line character or up to the
length of n, from a file pointed by fptr and stores it in the array str. This
function returns NULL when we reach end of file.

Strings
Formatted Input/Output
• We can read from or write to a file in a formatted manner using fscanf and
fprintf functions. These functions are analogous to scanf and printf
functions. The syntax for the fprintf which writes a formatted data into a file
is as follows.
fprintf( fptr, format-string, variable-list);
• This function will write the contents of the variables in the variable-list into
file pointed by fptr according to the format specifier specified in format
string. Each variable in the variable-list should have format specifier in the
format-string.
• The syntax for the fscanf which reads a formatted data from the file is as
follows
fscanf( fptr, format-string, addresses-list);
• This function will read the formatted data from the file pointed by fptr, as
specified by the format specifiers in format-string and stores in the
variables, whose addresses are given in addresses-list.

Files
Random Access
• In C, it is possible to directly access any byte or data item, which is stored
in any part of file directly. This is achieved by manipulating the file pointer.
File pointer is pointing a byte in the file.
• When the file is opened in read mode, the file pointer is pointing to the first
byte or data item. After reading a byte/data item the file pointer is moved to
next byte/data item.
• In order to read/write anywhere in a file, C is providing a function fseek( )
for placing a file pointer in a place where read/write operation need to be
done.
fseek( ) function
The syntax of fseek( ) function is as follows
fseek( fptr, offset, from_where)
• Where fptr is a file pointer, offset is a long integer that specifies the
number of bytes by which a file pointer is to be moved and third argument
from_where specifies from which position, the offset need to be measured.

Files
Statement Meaning
fseek(fp, 0L, 0); Move the file pointer to the beginning.
fseek(fp, 0L, 2); Move the file pointer to the end of file.
fseek(fp, 10L, 0); Move after 10 bytes from the beginning.
fseek(fp, 10L, 1); Move after 10 bytes from the current
fseek(fp, -10L, 1); Move backward 10 bytes from the
current
fseek(fp, -10L, 2); Move backward 10 bytes from the eof.
• The function fseek() returns 0, when the operation is successful,
otherwise returns -1.

Files
ftell( ) function
• This function will return a long integer that specifies the relative current
position of the file pointer. The syntax is as follows
ftell(fptr);
• The following program fragment is used to find the size of a file name
“test.dat”.
fptr = fopen(“test.dat”,”r”);
fseek(fptr, 0L, 2);
size = ftell(fptr);
• rewind( ) function
• This function will place a file pointer to the beginning of a file. The syntax
of this function is as follows
rewind(fptr);
• This is equivalent to a fseek( ) function with the arguments
fseek(fptr, 0L, 0);

C Preprocessor
The C Preprocessor
• The ``preprocessor'' is a translation phase that is applied to your
source code before the compiler proper gets its hands on it. Each
preprocessor directive is identified by the # (pound sign) at the
beginning of a line.
• File inclusion: inserting the contents of another file into your
source file, as if you had typed it all in there.
• Macro substitution: replacing instances of one piece of text with
another.
• Conditional compilation: Arranging that, depending on various
circumstances, certain parts of your source code are seen or not
seen by the compiler at all.

C Preprocessor
File inclusion
• It is also called header files.
• Examples:
• #include <stdio.h> #include "allconstants.h"

C Preprocessor
Macro substitution
• Macro substitution takes a fixed character sequence and
substitutes it with another character sequence
Example
#define MAX 1000
We use the string MAX in our source code, and we define it once
within the source code. The preprocessor substitutes the integer value
1000 for every instance of this string within the source code. It is
efficient (for code execution and for memory allocation).

• There are different forms of macro substitution. The most common
forms are
• -- Simple macro substitutions.
• -- Argumented macro substitution.
• -- Nested macro substitution.
Simple macro substitution:
# define COUNT 100
# define FALSE 0
# define Subjects 6
# define TEST if(x>y)
# define AND
# define PRINT printf (“very good”)
The preprocessor would translate this line to
if(x>y) printf(“very good”);

• Macros with arguments:-
Permit us to define more complex and more useful form of replacements
#define identifier(f1,f2,…,fn) string
Occurrence of a macro with arguments is known as macro call. A simple
macro with arguments is
#define CUBE(x) X*X*X
If the following statement appears in the program
Volume = CUBE(side) then the preprocessor would expand this
statement to be Volume= (side * side* side);
Consider the following statement Volume = CUBE(a+b); would be same
as Volume = (a+b *a+b * a+b); Which obviously produce incorrect
result.

• Nesting of macros:-
We can also use one macro in the definition of another macro. That is they
may be nested.
#define M 5
#define N M+1
#define square(x) (x * x)
#define CUBE(x) (square(x) * (x))
Un defining macro:-
A macro can be undefined using the statement #undef identifier Useful
when we want to restrict the definition only to appear in a particular part
of the program.

C Preprocessor
Conditional compilation
• It essentially provides a way of defining a variable, such that based
on the variable's value, a specific set of (source) code is or is not
compiled into the resulting object code.
• Code must often be different (do different things) to be correct
when executing under different operating systems.
• When compiled for a target system (meaning that the operating
system is defined) only the code intended specifically for that
system is compiled in.
• This makes the code more general, and able to be compiled for
more operating systems.

C programming for Computing Techniques

C programming for Computing Techniques

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (16)

Similar to C programming for Computing Techniques

Similar to C programming for Computing Techniques (20)

Recently uploaded

Recently uploaded (20)

C programming for Computing Techniques

Editor's Notes