Problem Solving and C Programming - Handout - v2 (1) .1

Handout: Problem Solving
and C Programming
Version: PSC/Handout/0307/2.1
Date: 05-03-07
Cognizant
500 Glen Pointe Center West
Teaneck, NJ 07666
Ph: 201-801-0233
www.cognizant.com
Problem Solving and C Programming
TABLE OF CONTENTS
Introduction ................................................................................................................................6
About this Document..................................................................................................................6
Target Audience.........................................................................................................................6
Objectives ..................................................................................................................................6
Pre-requisite ..............................................................................................................................6
Session 1: Introduction to Problem Solving and Programming Languages...........................7

Learning Objectives ...................................................................................................................7
Problem Solving Aspect .............................................................................................................7
Program Development Steps .....................................................................................................8
Introduction to Programming Languages .................................................................................14
Types and Categories of Programming Languages .................................................................15
Program Development Environments ......................................................................................18
Summary .................................................................................................................................19
Test your Understanding..........................................................................................................19
Session 2: Introduction to C Programming Language ...........................................................21

Learning Objectives .................................................................................................................21
Introduction to C Language......................................................................................................21
Evolution and Characteristics of C Language ..........................................................................21
Structure of a C Program .........................................................................................................23
C Compilation Model................................................................................................................24
C Fundamentals.......................................................................................................................25
Character Set...........................................................................................................................25
Keywords .................................................................................................................................26
Identifiers .................................................................................................................................26
Data Types ..............................................................................................................................26
Variables..................................................................................................................................28
Constants.................................................................................................................................29
Operators.................................................................................................................................30
Expressions .............................................................................................................................32
Type Casting............................................................................................................................33
Input and Output Statements ...................................................................................................35
Summary .................................................................................................................................39
Page 2
©Copyright 2007, Cognizant Technology Solutions, All Rights Reserved
C3: Protected
Session 4: Selection and Control Structures ..........................................................................41

Basic Programming Constructs................................................................................................41
Sequence.................................................................................................................................41
Selection Statements ...............................................................................................................42
‘if’ Statement ............................................................................................................................42
Conditional / Ternary / ?: Operator...........................................................................................44
Switch Statement .....................................................................................................................45
Iteration Statements.................................................................................................................46
‘for’ statements.........................................................................................................................46
‘while’ statement ......................................................................................................................47
‘do - while’ statement ...............................................................................................................48
Break, Continue Statements ....................................................................................................49
Summary .................................................................................................................................50
Session 6: Arrays and Strings ..................................................................................................52

Need for an Array.....................................................................................................................52
Memory Organization of an Array ............................................................................................52
Declaration and Initialization ....................................................................................................53
Basic Operation on Arrays .......................................................................................................54
Multi-dimensional Array............................................................................................................55
Strings......................................................................................................................................57
String Functions .......................................................................................................................59
Character Functions.................................................................................................................60
Summary .................................................................................................................................60
Session 8: Pointers....................................................................................................................62
Introduction ..............................................................................................................................62
Pointer Arithmetic.....................................................................................................................64
Pointers and Arrays .................................................................................................................65
Dynamic Memory Allocation.....................................................................................................71
Summary .................................................................................................................................73
Page 3
C3: Protected
Session 10: Functions...............................................................................................................75

Need for Functions...................................................................................................................75
Function Prototype...................................................................................................................76
Function Definition ...................................................................................................................77
Function Call ............................................................................................................................79
Passing Arguments..................................................................................................................80
Functions and Arrays ...............................................................................................................83
Functions and Pointers ............................................................................................................85
Storage Classes.......................................................................................................................87
Command Line Arguments ......................................................................................................90
Summary .................................................................................................................................91
Session 12: Structures and Unions..........................................................................................94

Introduction ..............................................................................................................................94
Structures and Arrays ..............................................................................................................98
Structures and Pointers............................................................................................................98
Structures and Functions .......................................................................................................100
Unions....................................................................................................................................101
Union of Structures ................................................................................................................102
Enumeration ..........................................................................................................................103
Typedef Statement.................................................................................................................104
Summary ...............................................................................................................................105
Test your Understanding........................................................................................................105
Session 14: Files and Preprocessors.....................................................................................107

Learning Objectives ...............................................................................................................107
Introduction ............................................................................................................................107
File Operations.......................................................................................................................108
Character I/O .........................................................................................................................110
String I/O................................................................................................................................112
Numeric I/O............................................................................................................................112
Formatted I/O.........................................................................................................................113
Block I/O ................................................................................................................................114
Random File Operations ........................................................................................................116
Preprocessor Directives .........................................................................................................117
Page 4
C3: Protected
Summary ...............................................................................................................................123
Test your Understanding........................................................................................................123
Syntax Summary......................................................................................................................125
References ...............................................................................................................................138
Websites ................................................................................................................................138
Books.....................................................................................................................................138
STUDENT NOTES ....................................................................................................................139
Page 5
C3: Protected
Introduction
About this Document

This document provides the following topics:
Problem solving concepts
An introduction to C programming language
Basic concepts of C programming language
Target Audience
In-Campus Trainees
Objectives
Explain the concepts of problem solving
Explain the concepts of C programming language
Write effective programs using C programming language
Pre-requisite
This module does not require any pre-requisites
Page 6
C3: Protected
Session 1: Introduction to Problem Solving and

Programming Languages
Learning Objectives
After completing this chapter, you will be able to:
Explain the basic concepts of problem solving
List the steps involved in program development
List the advantages of top-down programming
Describe programming languages, their types, and features
Problem Solving Aspect

Problem solving is a creative process. It is an act of defining a problem, determining the cause of
the problem, identifying, prioritizing, and selecting alternatives for a solution and implementing a
solution.
A problem can be solved successfully only after making an effort to understand the problem. To
understand the problem, the following questions help:
What do we know about the problem?
What is the information that we have to process in order the find the solution?
What does the solution look like?
What sort of special cases exist?
How can we recognize that we have found the solution?
It is important to see if there are any similarities between the current problem and other problems
that have already been solved. We have to be sure that the past experience does not hinder us in
developing new methodology or technique for solving a problem. The important aspect to be
considered in problem-solving is the ability to view a problem from a variety of angles.
There is no universal method for solving a given problem. Different strategies appear to be good
for different problems. Some of the well known strategies are:
Divide and Conquer
Greedy Method
Dynamic Programming
Backtracking
Branch and Bound
Page 7
C3: Protected
Program Development Steps

The various steps involved in Program Development are:
Defining or Analyzing the problem
Design (Algorithm)
Coding
Documenting the program
Compiling and Running the Program
Testing and Debugging
Maintenance
Analyzing or Defining the Problem

The problem is defined by doing a preliminary investigation. Defining a problem helps us to
understand the problem clear. It is also known as Program Analysis.
Tasks in defining a problem:

Specifying the input requirements
Specifying the output requirements
Specifying the processing requirements
Specifying the input requirements

Determine the inputs required and source of the data. The input specification is obtained by
answering the following questions:
What specific values will be provided as input to the program?
What format will the values be?
For each input item, what is the valid range of values that it may assume?
What restrictions are placed on the use of these values?
Specifying the output requirements

Describe in detail the output that will be produced. The output specification is obtained by
answering the following questions:
What values will be produced?
What is the format of these values?
What specific annotation, headings, or titles are required in the report?
What is the amount of output that will be produced?
Specifying the Processing Requirements

Determine the processing requirements for converting the input data to output. The processing
requirement specification is obtained by answering the following questions:
What is the method (technique) required in producing the desired output?
What calculations are needed?
What are the validation checks that need to be applied to the input data?
Page 8
C3: Protected
Example 1.1 Find the factorial of a given number

Input: Positive valued integer number
Output: Factorial of that number
Process: Solution technique which transforms input into output. Factorial of a number can be
calculated by the formula n! = 1*2*3*4….*n
Design
A design is the path from the problem to a solution in code. Program Design is both a product and
a process. The process results in a theoretical framework for describing the effects and
consequences of a program as they are related to its development and implementation.
A well designed program is more likely to be:

Easier to read and understand later
Less of bugs and errors
Easier to extend to add new features
Easier to program in the first place
Modular Design
Once the problem is defined clearly, several design methodologies can be applied. An important
approach is Top-Down programming design. It is a structured design technique which breaks up
the problem into a set of sub-problems called Modules and creates a hierarchical structure of
modules.
While applying top-down design to a given problem, consider the following guidelines:
A problem is divided it into smaller logical sub-problems, called Modules
Each module should be independent and should have a single task to do
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 is executed
Each module should be of manageable size, in order to make the design and testing
easier
Top-down design has the following advantages:

Breaking up the problem into parts helps us to clarify what is to be done
At each step of refinement, the new parts become more focussed and, therefore,
easier to design
Modules may be reused
Breaking the problem into parts allows more than one person to work on the solution
simultaneously
Page 9
C3: Protected
Algorithm (Developing a Solution technique)

An algorithm is a step-by-step description of the solution to a problem. It is defined as an ordered
sequence of well-defined and effective operations which, when carried out for a given set of initial
conditions, produce output, and terminate in a finite time. The term “ordered sequence” specifies,
after the completion of each step in the algorithm, the next step must be unambiguously defined.
An algorithm must be:

Definite
Finite
Precise and Effective
Implementation independent ( only for problem not for programming languages)
Developing Algorithms
Algorithm development process is a trial-and-error process. Programmers make initial attempt to
the solution and review it, to test its correctness. The errors identified leads to insertions, deletions,
or modifications to the existing algorithm.
This refining continues until the programmer is satisfied that, the algorithm is essentially correct
and ready to be executed. The more experience we gain in developing an algorithm, the closer our
first attempt will be to a correct solution and the less revision will be required. However, a novice
programmer should not view developing algorithm as a single-step operation.
Example 1.2: Algorithm for finding factorial of a given number

Step 1: Start
Step 2: Initialize factorial to be 1, i to be 1
Step 3: Input a number n
Step 4: Check whether the number is 0. If so report factorial is 1 and goto step 9
Step 5: Repeat step 6 through step 7 n times
Step 6: Calculate factorial = factorial * i
Step 7: Increment i by 1
Step 8: Report the calculated factorial value
Step 9: Stop
Pseudo Code
Pseudo code is an informal high-level description of an algorithm that uses the structural
conventions of programming languages, but omits language-specific syntax. It is an outline of a
program written in English or the user's natural language.
Example 1.3: Pseudo Code for finding factorial of a given number

Step 1: START
Step 2: DECLARE the variables n, fact, i
Step 2: SET variable fact =1 and i =1
Step 3: READ the number n
Step 4: IF n = 0 then
Page 10
C3: Protected
Step 4.1: PRINT factorial = 1

Step 4.2: GOTO Step 9
Step 5: WHILE the condition i<=n is true, repeat Step 6 through Step 7
Step 6: COMPUTE fact = fact * i
Step 7: INCREMENT i by 1
Step 8: PRINT the factorial value
Step 9: STOP
Flowchart
Flowchart is a diagrammatic representation of an algorithm. It uses different symbols to represent
the sequence of operations, required to solve a problem. It serves as a blueprint or a logical
diagram of the solution to a problem. Typical flowchart symbols are given below:
Represents Start, End
Represents Input, Output data
Represents Process (actions, calculations)
Represents Decision Making
Represents Pre-defined Process / module
Represents off page connector which are used to indicate that the flow chart
continues on another page. Page numbers are usually placed inside for easy
reference.
Connector Symbol represents the exit to, or entry from, another part of the
same flow chart. It is usually used to break a flow line that will be continued
elsewhere.
The Document Symbol is used to represent any type of hard copy input or
output (i.e. reports).
Represents control flow
Page 11
C3: Protected
Example 1.4: Flow Chart for finding factorial of a given number
START
Declare the variables

n, fact, i
Initialize fact =1,i =1
Read n
True
If n=0 0 Print 1
False
False
If i<=n
True
fact = fact * i
i=i+1
Print fact
STOP
Page 12
C3: Protected
Coding
An algorithm expressed in programming languages is called Program. Writing a program is called
Coding. The logic that has been developed in the algorithm is used to write the program.
Documenting the Program

Documentation explains how the program works and how to use the program. Documentation can
be of great value, not only to those involved in maintaining or modifying a program, but also to the
programmers themselves. Details of particular programs, or particular pieces of programs, are
easily forgotten or confused without suitable documentation.
Documentation comes in two forms:

External documentation, which includes things such 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 Executing the Program

Compilation is a process of translating a source program into machine understandable form. The
compiler is system software, which does the translation after examining each instruction for its
correctness. The translation results in the creation of object code.
After compilation, Linking is done if necessary. Linking is the process of putting together all the
external references (other program files and functions) that are required by the program. The
program is now ready for execution.
During execution, the executable object code is loaded into the computer’s memory and the
program instructions are executed.
Testing
Testing is the process of executing a program with the deliberate intent of finding errors. Testing is
needed to check whether the expected output matches the actual output. Program should be
tested with all possible input data and control conditions.
Testing is done during every phase of program development. Initially, requirements can be tested
for its correctness. Then, the design (algorithm, flow charts) can be tested for its exactness and
efficiency. Structured walk through is made to verify the design.
Programs are tested with several test criteria and the important ones are given below:
Test whether each and every statement in the program is executed at least once
(Basic path testing)
Test whether every branch in the program is traversed at least once (control flow)
Test whether the input data flows through the program and is converted to an output
(data flow)
The probability of discovering errors through testing can be increased by selecting significant test
cases. It is important to design test cases for abnormal input conditions.
The Boundary (or Extreme) Cases

How does the algorithm perform at the extremes of the valid cases?
Page 13
C3: Protected
The Unusual Cases

What happens when the input data violates the normal conditions of the problem or represent
unusual condition?
The Invalid Cases

How does the algorithm react for data which are patently illegal or completely meaningless?
An algorithm should work correctly and produce meaningful results for any data. This is called
foolproof programming.
Debugging
Debugging is a process of correcting the errors. Programs may have logical errors which cannot
be caught during compilation. Debugging is the process of identifying their root causes. One of the
ways to ensure the correctness of the program is by printing out the intermediate results at
strategic points of computation.
Some programmers use the terms “testing” and “debugging” interchangeably, but careful
programmers distinguish between the two activities. Testing means detecting errors. Debugging
means diagnosing and correcting the root causes.
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 because of improper
documentation.
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 every program. Maintainability of the program is achieved by:
Modularizing it
Providing proper documentation for it
Following standards and conventions (naming conventions, using symbolic constants
etc)
Introduction to Programming Languages
What is a Programming Language?
Computer Programming is an art of making a computer to do the required operations, by means of

issuing sequence of commands to it.
A programming language can be defined as a vocabulary and set of grammatical rules for
instructing the computer to perform specific tasks. Each programming language has a unique set
of characters, keywords and the syntax for organizing programming instructions.
The term programming languages usually refers to high-level languages, such as BASIC, C, C++,
COBOL, FORTRAN, Ada, and Pascal.
Page 14
C3: Protected
Why Study Programming Languages?

The design of new programming languages and implementation methods have been evolved and
improved to meet the change in requirements. Thus, there are many new languages.
The study of more than one programming language helps us:

to master different programming paradigms
to enhance the skills to state different programming concepts
to understand the significance of a particular language implementation
to compare different languages and to choose appropriate language
to improve the ability to learn new languages and to design new languages
Types and Categories of Programming Languages
Types of Programming Languages

There are two major types of programming languages:
Low Level Languages
High Level Languages
Low Level Languages

The term low level refers closeness to the way in which the machine has been built. Low level
languages are machine oriented and require extensive knowledge of computer hardware
architecture and its configuration. Low Level languages are further divided in to Machine language
and Assembly language.
(a) Machine Language

Machine Language is the only language that is directly understood by the computer. It does not
need any translator program. The instructions are called machine instruction (machine code) and it
is written as strings of 1's (one) and 0’s (zero). When this sequence of codes is fed in to the
computer, it recognizes the code and converts it in to electrical signals.
For example, a program instruction may look like this: 1011000111101
Machine language is considered to be the first generation language. Because of it design, machine
language is not an easy language to learn. It is also difficult to debug the program written in this
language.
Advantage
The program runs faster because no translation is needed. (It is already in machine
understandable form)
Disadvantages
It is very difficult to write programs in machine language. The programmer has to know
details of hardware to write program
It is difficult to debug the program
(b) Assembly Language
In assembly language, set of mnemonics (symbolic keywords) are used to represent machine
codes. Mnemonics are usually combination of words like ADD, SUB and LOAD etc. In order to
execute the programs written in assembly language, a translator program is required to translate it
Page 15
C3: Protected
to the machine language. This translator program is called Assembler. Assembly language is
considered to be the second-generation language.
Advantages:
The symbolic keywords are easier to code and saves time and effort
It is easier to correct errors and modify programming instructions
Assembly Language has utmost the same efficiency of execution as the machine level
language, because there is one-to-one translation between assembly language
program and its corresponding machine language program
Disadvantages:
Assembly languages are machine dependent. A program written for one computer
might not run in other computer.
High Level Languages

High level languages are the simple languages that use English like instructions and mathematical
symbols like +, -, %, /, for its program construction. In high level languages, it is enough to know
the logic and required instructions for a given problem, irrespective of the type of computer used.
Compiler is a translator program which converts a program in high level language in to machine
language.
Higher level languages are problem-oriented languages because the instructions are suitable for
solving a particular problem.
For example, COBOL (Common Business Oriented Language) is mostly suitable for business
oriented applications. There are some numerical & mathematical oriented languages like
FORTRAN (Formula Translation) and BASIC (Beginners All-purpose Symbolic Instruction Code).
Advantages of High Level Languages

High level languages are easy to learn and use
Categories of programming languages
Numerical Languages
Early computer technology dates from the era just before World War 2 in the late 1930s to the
early 1940s. These early machines were designed to solve numerical problems and were thought
of as ELECTRONIC CALCULATORS. Numerical calculations were the dominant form of
application for these early machines.
Page 16
C3: Protected
Business Languages
Business data processing was an early application domain developed after numerical applications.
In 1959, the US department of Defense sponsored a meeting to develop COMMON BUSINESS
LANGUAGE (CBL), which would be a business-oriented language that used English as much as
possible for its notation. This, in turn, led to the formation of a Short Range Committee to develop
COBOL.
Artificial Intelligence Languages (AI)

The first step towards the development of AI languages commenced with the evolution of IPL
(Information Processing Language) by the Rand Corporation. The major breakthrough occurred,
when John McCarthy of MIT designed LISP (List Processing) for the IBM 704. Later, more AI
languages like SNOBOL & PROLOG were designed.
Systems Languages
Because of the need of efficiency, the use of assembly language held on for years in the system
area long after other application domains started to use higher-level languages. Many systems
programming languages such as CPL & BCPL were designed, though not widely used. The major
landmark here is the development of UNIX, where high level languages also proceed to work
effectively.
What makes a Good Language?
Every language has its strengths and weaknesses.
For example, FORTRAN is a particularly good language for processing numerical data, but it does
not lend itself very well to organize large programs. PASCAL is very good for writing well-
structured and readable programs, but it is not as flexible as the C programming language. C++
embodies powerful object-oriented features, but it is complex and difficult to learn. The choice of
which language to use depends on the type of computer used, type of program, and the expertise
of the programmer.
Following are the most important features that would make a programming language efficient and
easy to use:
Clarity, Simplicity and Unity: A programming Language provides, both a conceptual framework
for thinking about algorithms and a means for expressing these algorithms. The syntax of a
language should be such that programs may be written, tested and maintained with ease.
Orthogonality: This refers to the attribute of being able to combine various features of a language
in all possible combinations, with every combination being meaningful. Orthogonality makes a
language easy to learn and write programs, because there are fewer exceptions & special cases to
remember.
Naturalness for the application: A language needs syntax that when properly used allows the
program structure to reflect the underlying logical structure of the algorithm. The language should
provide appropriate data structures, operations, control structures and natural syntax for the
problem to be solved.
Page 17
C3: Protected
Support for abstraction: Even with the most natural programming language for an application,
there is always a substantial gap remaining between the abstract data structures & operations that
characterize the solution to a problem and the particular data structures and operations built into a
language.
Portability of Programs: Portability is an important criterion for many programming projects which
essentially indicates the transportability of the resulting programs from the computer on which they
are developed to other computer systems. A language whose definition is independent of the
features of a particular machine forms a useful base for the production of transportable programs.
Cost of use: Cost of use is measured on different languages like:

Cost of program execution: Optimizing compilers, efficient register allocation, design
of efficient run-time support mechanisms are all factors that contribute towards cost of
program execution. This is highly critical for large programs that will be executed
continuously.
Cost of Program creation, testing & use: This implies design, coding, testing, usage
& maintenance solutions for a problem with minimum investment of programmer time &
energy.
Cost of Program Maintenance: The highest cost involved in any program is the total life-cycle
costs including development costs & the cost of maintenance of the program while it is in
production use.
Program Development Environments

The environment under which a program is designed, coded, tested & debugged is called Host
Environment. The external environment which supports the execution of a program is termed as
Operating or Target Environment. Host and Target environment may be different for a program or
application.
Programming Environments (Host Environment)

It is the environment in which programs are created and tested. It tends to have less influence on
language design than the operating environment in which programs are expected to be executed.
The production of programs that operate reliably and efficiently is made much simpler by a good
programming environment and by a language that allows the use of good programming tools and
practices.
Target Environments
Target environments can be classified into 3 categories – Batch Processing Environment,
Interactive Environment, and Embedded System Environment. Each poses different requirement
on languages adapted for those environments.
Batch-Processing Environments
In batch-processing environments, the input data are collected in ‘batches’ on files and are
processed in batches by the program. For example, the backup process on an organization. The
transaction details of all the departments are collected for backup at one place and the backup is
done at a time at the end of the day.
Page 18
C3: Protected
Interactive Environments
In interactive environment, a program interacts directly with a user at a display console, by
alternately sending output to the display & receiving input from the keyboard or mouse. Examples
include database management systems, word processing systems etc.
Embedded System Environments

An embedded computer system is used to control part of a larger system such as an industrial
plant (computerized machineries) or an aircraft. The computer system will be an integral part of the
larger system, failure of which would imply failure of the larger system as well.
Summary
Program development life cycle involves analysis, algorithm development, coding,
documenting, compiling and running, testing, debugging, and maintenance.
Top-down program design, divides the problem into smaller logical sub problems,
called Modules.
An algorithm is a sequence of unambiguous instructions for solving a problem.
A programming language is a vocabulary and set of grammatical rules for instructing a
computer to perform specific tasks.
Two major types of programming languages are Low Level Languages and High Level
Languages.
The environment under which a program is designed, coded, tested & debugged is
called Host environment (programming environment)
The environment under which a program is executed is called Target environment.
Target environments can be classified into 3 categories.
o Batch processing environment
o Interactive environment
o Embedded System environment
Test your Understanding

1. Represent the following problem in top-down design.
Planning a tour.
2. Give the algorithm, pseudo code and flowchart for the following problem:
Sort a list of numbers in ascending order.
3. Distinguish between testing and debugging.
4. State whether the following is True or False :

a. Assembly language is a second generation language.
b. Programs written in high Level languages needs translation for executing them.
Page 19
C3: Protected
5. What is meant by portability of programs?

a. Easy to carry from place to place
b. Transportability of resulting program within machine folders
c. It can run on any machine
d. The program needs to be compiled in every machine
Answers:
3. Testing is to find errors in programs and debugging is to correct their root causes
4. True, True
5. c (it can run on any machine)
Page 20
C3: Protected
Session 2: Introduction to C Programming Language
Learning Objectives
Explain the evolution of C language
List the features of C language
Explain the basic elements of C language
Explain the structure of a C program
Introduction to C Language
C is a general purpose high level programming language. Because of its flexibility and efficiency it
is widely used for software development. Its features allow the development of well-structured
programs. The data types and control structures are directly supported by most computers,
resulting in the construction of efficient programs.
Evolution and Characteristics of C Language
Evolution of C Language
ALGOL was the first computer language to use a block structure. In 1967, Martin Richards
developed a language called BCPL (Basic Combined Programming Language) primarily, for
writing system software. In 1970, Ken Thompson created a language using many features of
BCPL and called it ‘B’. ‘B’ was used to create early versions of UNIX operating system at Bell
Laboratories. Both BCPL and B were “typeless” system programming languages.
C was developed by Dennis Ritchie at Bell Laboratories in 1972. It was evolved from ALGOL,
BCPL, and B. C uses many concepts of these languages and new features like data types. UNIX
operating system was coded almost entirely in C.
During 1970s, C had evolved into what is now known as “traditional C”. The popularity of C led to
the development of different versions of the language that were similar but often incompatible.
To assure that the C language remains standard, in 1973, American National Standards Institute
(ANSI) appointed a technical committee to define a standard for C. The committee approved a
version of C in 1989 which is now known as ANSI C. It was then approved by the International
standards Organization (ISO) in 1990. The standard was updated in 1999.
Prior to C, there are two broad types of languages:

Applications languages: Basic and COBOL, which are portable but inefficient.
Systems languages: Low Level and Assembly language, which are efficient but non-
portable.
Page 21
C3: Protected
‘C‘ is developed in such a way that it is efficient and portable.

C++, Java, C# conserve C syntax.
The following figure depicts the history of languages:
Page 22
C3: Protected
Characteristics of C Language
The increasing popularity of C is due to its various desirable qualities:
C language is well suited for structured modular programming
C is a robust language with rich set of built-in functions and operators
C is smaller which has minimal instruction set and programs written in C are efficient
and fast
C is highly portable (code written in one machine can be moved to other)
C is highly flexible
C allows access to the machine at bit level (Low level (Bitwise) programming)
C supports pointer implementation - extensive use of pointers for memory, array,
structures and functions
Structure of a C Program
A C program can be viewed as a group of building blocks, called functions. A function is a
subroutine that includes one or more statements designed to perform a specific task.
preprocessor directives
global declaration section
main()
{
:
}
user-defined function definitions;
The preprocessor directives provide instructions to the preprocessor, to include functions from the
system library, to define the symbolic constants and macro. The prototype of the user-defined
functions (function declaration) is specified after the preprocessor directives. The variables that are
used in common by more than one function are called Global Variables and are declared in global
declaration section. This section can have declarations for all the user-defined functions.
Every C program must have one main() function. This function contains two parts: declaration part
and executable part. The declaration part declares all the variables used in the executable part.
These two parts must appear between the opening and the closing braces. The program execution
begins at the opening brace and ends at the closing braces. The closing brace of the main function
is the logical end of the program. The executable portion of the main function will have three types
of statements: Input, Output and Processing statements. All the statements in the declaration and
executable parts end with a semicolon.
C program can have any number of user-defined functions and they are generally placed
immediately after the main() function, although they may appear in any order.
All sections except the main() function may be absent when they are not required. C is a case
sensitive language. Comments are enclosed within /* and */. C program can be documented using
these comment lines.
Page 23
C3: Protected
Example 2.1
/* Program to accept 2 integers from the keyboard as input, calculate
and print their sum */
#include <stdio.h>
main( )
{
int num1,num2,sum;
printf (“\n Program to find the sum of two numbers\n”);
printf(“\n Please enter 2 integer numbers”);
scanf(“%d%d”, &num1,&num2);
sum = num1+num2;
printf (“\n The following data was input: %d & %d ”, num1, num2);
printf(“\n The sum of two numbers is = %d”, sum);
}
C Compilation Model
The C Compilation model describes the program development process in terms of language. The
key features of the C compilation model are as follows:
The Preprocessor
The preprocessor accepts source code as input and interprets preprocessor directives denoted
by #. It removes comments and empty lines in the program.
Page 24
C3: Protected
Example 2.2
#include -- includes contents of a named file. These files are usually called header files.
#include <math.h> -- standard library maths file.
#include <stdio.h> -- standard library I/O file
#define -- defines a symbolic name or constant, macro definition
#define MAX_ARRAY_SIZE 100
C Compiler
The C compiler translates the preprocessed code (user written program) to assembly code
(machine understandable code).
Assembler
The assembler creates the object code. [On UNIX, file with a.o suffix and on MSDOS files with
.OBJ indicates 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 are
resolved here.
C Fundamentals
Basic elements of C language constitute Character set, Identifiers, Operators and Expression.
Character Set
Character set defines the characters that are used to form words, numbers and expressions. The
characters in C are grouped into the following categories:
Letters
o Uppercase A….Z
o Lowercase a….z
Digits
o All decimal digits 0…9
Special characters
o =, +, - , % , ? , Blank spaces etc.
Escape Sequences: Escape sequences are non printable characters, which begin
with backward slash and followed by one or more special characters. The frequently
used escape sequences are given below:
o Horizontal tab ( \t )
o Vertical tab ( \v )
o Carriage return (\r )
o New line ( \n )
o Form feed (\f )
o Back Space ( \b )
o Back Slash ( \\ )
o Null ( \0 )
Page 25
C3: Protected
Keywords
Keywords have standard, predefined meanings in C. These keywords can be used only for their
intended purpose and they cannot be used as programmer-defined identifiers. Keywords serve as
basic building blocks for program statements. All keywords must be written in lowercase. ANSI C
supports 32 keywords. The following table shows the list of keywords.
auto double int Long
break else long Switch
case enum register typedef
char extern return Union
const float short unsigned
continue for signed Void
default goto sizeof volatile
do if static While
Identifiers
Identifiers are names given to various programming elements such as variables, constants, and
functions. It should start with an alphabet, followed by the combinations of alphabets and digits. No
special character is allowed except underscore (_). An Identifier can be of arbitrarily long. Some
implementation of C recognizes only the first eight characters and some other recognize first 32
characters.
Example 2.3
Valid identifiers : sum_2_nos basic_pay _amount
Invalid identifiers: 5subjects emp name #ofstudents
Data Types
Data types are used to indicate the type of value represented or stored in a variable, the number of
bytes to be reserved in memory, the range of values that can be represented in memory, and the
type of operation that can be performed on a particular data item.
ANSI C supports two classes of data types:

Primary / Fundamental / Basic / Primitive data types
Derived / Compound data types
Primary / Fundamental / Basic / Primitive data types
C uses the following basic data types:

int integer quantity
char character (stores a single character)
float single precision real (floating point) number
Page 26
C3: Protected
double double precision real (floating point) number

Typical memory requirements for these data types are given below:
int 2 bytes
The actual number of bytes used in the
char 1 byte
internal storage for these data types
float 4 bytes depends on the machine being used.
double 8 bytes
The basic data types can be augmented by the use of data type qualifiers.
Type Qualifiers
Data type qualifiers add additional information to the data types. They are,
short
long
signed
unsigned
A number of qualifiers or modifiers may be assigned to any basic data type to vary the number of
bits utilized and the range of values represented by that data type.
Here, short int may require less space than an int or it may require the same amount of memory.
Similarly, a long int may require the same amount of memory as an int or it may require more
memory, never less than int.
For example, int = 2 bytes, short int may be 1 byte or 2 bytes

int = 2 bytes, long int may be 2 bytes or 4 bytes
Range of values represented by data types on 16-bit machine
Type Meaning Size Range
Unsigned character
unsigned char 8 bits 0 to 255
(positive)
signed char
Represents single character. 8 bits -128 to 127
char
unsigned int Represents positive

16 bits 0 to 65,535
unsigned short int integer numbers
Short
signed short represents both positive and
16 bits -32,768 to 32,767
short int negative integer quantity
signed short int
Page 27
C3: Protected
Type Meaning Size Range

int
represents positive long

unsigned long 32 bits 0 to 4,294,967,295
integer
long
signed long Represents both positive
32 bits -2,147,483,648 to 2,147,483,647
long int and negative long integer
signed long int
Float Floating Point Number. 32 bits 3.4 * (10-38) to 3.4 * (10+38)
A more accurate floating-

Double 64 bits 1.7 * (10-308) to 1.7 * (10+308)
point number than float
long double Increases the size of double. 80 bits 3.4 * (10-4932) to 1.1 * (104932)
void Defines an empty data type

which can then be
associated with some data
types. It is useful with
pointers.
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
Structures
Unions
Enumerated
Pointers
Variables
A variable is an identifier that represents a value. The value represented by the identifier may be
changed during the execution of the program. Variable names must be chosen in such a way that
it should be a valid identifier satisfying all the basic conditions.
Variable names are case sensitive (ex: variable EMPNAME is different from variable empname).
The variable name can be chosen by the programmer in a meaningful way so as to reflect its
function or nature in the program.
Declaration of a variable
Declaration is used to specify the variable names used in the program and the type of data that the
variable can hold.
Page 28
C3: Protected
General form:
var_data_type list variables;
Example 2.4
int i, j, k;
float x, y, z;
char ch;
Initialization
Variables can be initialized in the declaration statement itself or within the program using
assignment statement.
General Form:
[data type] variable name = value;
Example 2.5
int total=0, ct=1;
float sum = 0.0;
int tot, ct=1;
tot = 0;
Constants
A constant in C refers to the fixed values that do not change during the execution of a program.
There are two types of constants:

Symbolic constants
Constant variables, also called read-only variables.
Symbolic Constants
A symbolic constant is defined in the preprocessor area of the program and is valid throughout the
program. The preprocessor directive #define is used to define symbolic constants in a program.
Symbolic constants are usually represented in upper case letters.
A symbolic constant is defined as follows:

#define MAX 100
#define PI 3.14
Each reference to ‘MAX’ in program will cause the value of 100 to be substituted. This value
cannot be changed by the program.
Page 29
C3: Protected
Constant Variables
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 be specified in
the declaration. Keyword ‘const’ is used to declare constant variables.
Example 2.6
const int size = 100;
const float pi=3.14;
const char ch = ‘a’;
const long a = 50000L; or const long a = 50000l;
const int a = 0567; (Octal representation – prefix 0)
const int a = 0Xa92 (Hexadecimal representation – prefix 0x or 0X)
Operators
C supports a rich set of operators. An operator is a symbol that tells the computer to perform
mathematical or logical operations. Operators are used in programs to manipulate data. C
operators can be classified into a number of categories. They include:
Arithmetic operators
+ Addition
- Subtraction
* Multiplication
/ Division (second operand must be nonzero)
% Modulus (both operands must be integer and second operand must be non zero)
Relational operators
< Less than

<= Less than or equals to
> Greater than
>= Greater than or equals to
== Equals to
!= not equals to
These operators are used to form relational expressions, which evaluates to either true or false.
(true – 1, false – 0)
Logical operators
&& Logical AND (true only if both the operands are true)
|| Logical OR (true if either one operand is true)
! Logical NOT (negate the operand)
Expressions which use logical operators are evaluated to either true or false.
Page 30
C3: Protected
Assignment operators
= Assignment operator which assign a value to an identifier.
+=, *=, -=, /=. %= Compound assignment operators are used whenever, left hand side identifier is
used in the right hand side expression. (a = a+b equals to a+=b)
Unary operators
+ Unary plus
- Unary minus
Increment and decrement operators

++ may be in the form of pre increment or post increment (++ k: pre increment, k++: post
increment)
Example:
int i=5;
printf(“%d”, ++i); /*prints 6 - pre increment */
printf(“%d”, i++); /* prints 6 - post increment */
printf(“%d”, i); /* prints 7 */
-- may be in the form of pre decrement or post decrement (-- k: pre increment, k--: post
increment)
Conditional operator (ternary operator)

?: used to carry out simple conditional checking
Example: big = (a>b)? a: b
In the above statement, if condition is evaluated to true, the value of variable a will be assigned to
variable big else b will be assigned.
Bitwise operators
& Bit wise AND
| Bit wise OR
<< Left shift
>> Right shift
These operators are used to access machine at bit level.
Special operators
& Address operator
* Indirection operator
comma Comma operator
sizeof() Size of operator (sizeof(int) = 2 bytes)
Page 31
C3: Protected
Order of Precedence
All the operators have its own precedence and associativity. High priority operators are evaluated
prior to lower priority ones. Operators of the same priority group are evaluated from left to right
fashion. The expression a + b – c is evaluated as (a + b) – c.
It is necessary to be careful of the meaning of expressions such as a - b / c because we may want

the effect as either (a - b) / c or a - (b / c).
From high priority to low priority the order for all C operators is given below:
Operator Name Association
( ) [ ] -> . Parentheses, Index, member access operators Left to Right
! – sizeof()
Logical NOT, unary minus, indirection, address Right to Left
(Typecast) * &
++ -- Increment and decrement operators. Right to Left
*/% Multiplicative operators. Left to Right
+- Additive operators. Left to Right
< > <= >= Inequality comparators. Left to Right
== != Equality comparators Left to Right
&& Logical AND. Left tot Right
|| Logical OR. Left to Right
?: Conditional. Right to Left
= op= Assignment. Right to Left
, Comma Left to Right
Example 2.7: Operators

Let a=1, b=2, c=3
(1) a* b%c+1
is equivalent to ((a*b) %c)+1 which is equal to 3
(2) ++a*b – c--
is equivalent to ((++a)*b) - (c--) which is equal to 1
Expressions
Expression is a combination of operands, operators, function calls that evaluates to a value. The
three types of expressions are Arithmetic expression (uses arithmetic operators), Relational
expression (uses relational operators), and Logical expression (uses logical operators).
Page 32
C3: Protected
Assignment Statement
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.
For example, the statement x = y + z; computes the value of y+z and store the result in the
variable x. However, x + 3 = y; is not legal because x + 3 is an arithmetic expression (i.e.) not a
storage location.
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;
Example 2.8
(1) a = (b = 2, c=3, b+c); 5
(2) a = (b=2, c=3, b+c, b-c); -1
(3) int a; float b;
a=b=3.5; a= 3 b=3.5
(4) int c, a=3, b=4;
c= a>b; c=0
d = a == b; d=0
e = a != b; e=1
Type Casting
C provides a mechanism for allowing the programmer to change the default data type of a given
expression. This is called Typecasting. Typecasting allows a variable to behave like a variable of
another type.
C provides two types of type conversions: Implicit and Explicit type conversions.
In implicit type conversion, if the operands of an expression are of different types, the lower data
type is automatically converted to the higher data type before the operation evaluation. The result
of the expression will be of higher data type. The final result of an expression is converted to the
type of the variable on the LHS of the assignment statement, before assigning the value to it.
For example,
float to int assignment causes truncation of the fractional part.
double to float causes round of digits.
long int to int causes dropping of the excess higher order bits.
Page 33
C3: Protected
In explicit type conversion, the user has to enforce the compiler to convert one data type to
another data type by using typecasting operator. This method of typecasting is done by prefixing
the variable name with the data type enclosed within parenthesis. The original value of the variable
is not altered.
General Form:
(data type)variable/expression/value;
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.
Example 2.9
float sum;
sum = (int) (1.5 * 3.8);
The typecast (int) tells the C compiler to interpret the result of (1.5 * 3.8) as the integer 5, instead
of 5.7. Then, 5.0 will be stored in sum, because the variable sum is of type float.
Example 2.10
float to (int or char) - narrowing
(char or int) to float - widening
The following examples show different kinds of expressions:
Example 2.11
int a, b, c, d, e, f;
float x, y, z;
a=14; b=4;
c = a/b; /*c=3 */
d = a % b; /*d=2 */
x = a / 10.0; /*x=1.4 (Mixed-mode expression)*/
y = a / 10; /*y=1.0 */
e = -a % -b;
/*-2 (Modulus operation retains the sign of the first operand)*/
f = a % -b; /*f=2*/
Page 34
C3: Protected
Example 2.12
a b c
int a=0, b=0, c=0; 0 0 0
a=++b + ++c; 2 1 1
a=b++ + c++; 2 2 2
a=++b + c++; 5 3 3
a=b-- + --c; 5 2 2
c = a>b; 5 2 1 (Relational expression evaluated to true)
c = a && b 5 2 1 (Logical expression evaluated to true.
Non zero value is true and Zero is false)
Input and Output Statements

Reading, processing, and printing of data are the three essential functions of a computer program.
There are two methods of providing data to the program variables. One method is to assign values
to variables through the assignment statements. Another method is to use input functions, which
can get data from the keyboard (standard input-stdin).
There are two types of Input and Output (I/O) statements: Unformatted I/O statements and
Formatted I/O statements.
Unformatted Input statements
Character Input
There are several functions available to input a character from the console.
getchar ()
This function accepts a single character from the stream stdin (keyboard buffer). This single
character includes alphabets, digits, punctuations, return, and tab.
General form:
char-variable = getchar();
Example 2.13
char ch;
ch = getchar();
getch (); - character input from console & doesn’t echo the character.
getche(); - character input from console & echoes the character.
Page 35
C3: Protected
String Input
gets ()
This function accepts a string terminated by a new line character. Blank space is also considered
as a character. To get a line of text, this function serves the purpose.
General Form:
gets(stringvariable); /* string is represented as character array */
Example 2.14
char ch[5];
gets(ch);
Unformatted Output statements
Character Output
putchar()
This function displays a single character in the standard output (stdout), monitor.
General Form:
putchar(char variable);
Example 2.15
char ch;
ch = getchar();
putchar(ch);
String Output
puts()
This function displays the string in the standard output.
General Form:
puts(str);
Example 2.16
char ch[5];
gets(ch);
puts(ch);
Page 36
C3: Protected
Formatted I/O Statements

Formatted input refers to an input data that has been arranged in a particular format. C has a
special formatting character (%). A character following this defines the format for a value.
Some of the format specifiers are given below:

%c – character
%d – integer
%f, %e, %g – float
%s – string
%ld – long integer
%o – octal
%x – hexadecimal
%hd – short integer
%[..] – string of specified characters
%u – unsigned
General Form:
“%-+s0w.pmc”
Where:
- left justify
+ print with sign
s print space with no sign
0 pad with leading zero
w field width
p precision
m conversion character ( h, l, L)
c conversion character (d, f, u, o, x, g, e)
Formatted Input Statement
scanf()
scanf () function is used to read formatted data items.
General Form:
scanf (“format string”, list of variables);
Format string specifies the field format in which the data is to be entered.
List of variables specify the address of memory locations where the data is to be stored. Address
operator (&) is used before the variables.
Format string and variables are separated by comma. Format string, also known as control string
contains field specifications, which directs the interpretation of input data. By default, the delimiter
while reading the values is space. Delimiter can be user-defined. To read a string using ‘%s’, ‘&’
need not be used.
Page 37
C3: Protected
Example 2.17
scanf (“%c %d %f”, &ch, &i, &x);
scanf (“%[^\n]s”, str);
/*accepts all inputs including space. Stops when it encounters new
line.*/
scanf (“%d=%d”, &a, &b);
/*delimiter between two input is = (10=20)*/
scanf (“%2d%5d”,&a,&b);
/*if the input is 12345 & 10, a=12 & b=345 if the input is 12 & 3456,
a= 12 & b=3456*/
scanf (“%d%d”, &a,&b);
/*if the input is 12345 & 10, a=12345 & b=10*/
sscanf()
sscanf() function to read values from a string. This functions returns the number of inputs read
successfully.
General Form:
sscanf (str, “format string”, list of variables);
Formatted Output Statement
printf()
printf () function is used to output the values. This function returns the number of characters
printed.
General Form:
printf (“format string”, list of variables);
Example 2.18
printf (“char=%c, int=%3d, floating point=%6.2f”,ch, i, x);
printf (“sum = %*.*f”, w, p, sum);
/* width & precision can be user defined*/
printf (“name = %10.4s”, name);
/* column width 10, first 4 characters printed.*/
sprintf()
sprintf() function is used to output values to a string.
General Form:
sprintf (str, “format string”, list of variables);
Page 38
C3: Protected
Summary
C is a structured programming language.
C program is a collection of functions.
C supports four basic primitive data types: int, char, float, double.
C has a rich set of operators.
C has Unformatted and Formatted Input / Output statements.

1. Which of the following are valid identifiers?
a. Emp_name
b. “total”
c. main
d. total-marks
2. a = (b = 2) + (c=3); Is the statement valid?
3. What will be the value of the variables x and s after the following piece of code is
executed?
float x, s, y=7.5;
x= (int) y;
s= (int) y + 3.5;
4. What is ternary operator in C?
5. What is the difference between getche() and getch()?
6. If, the scanf() statement contains the following control :

“%d \n %d”
Which of the following set of inputs will successfully read ?
a. 4 5
b. 4
5
7. What is the output of the following code?

int a , b = printf (“welcome”);
printf (“%d “,b);
Page 39
C3: Protected
Answers:
1. a,c ( “ “ , - are not the valid characters to form an identifier)
2. valid
3. x = 7.0 , s = 10.5
4. ?: is called ternary operator (conditional operator) used to carry out simple decision
making.
5. getche() echoes the input character on screen, but getch() will not echo the character.
6. All are valid.
7. welcome7
Page 40
C3: Protected
Session 4: Selection and Control Structures
Learning Objectives
Apply selection statements in your programs
Apply control structures in your programs
Basic Programming Constructs

The basic programming constructs are sequence, selection, and iteration (looping). In a sequence
construct, the instructions are executed in the same order in which they appear in the program. In
a selection structure, the control flow can be altered by evaluating conditions. In an iterative
structure, a group of instructions is executed repeatedly, until some condition is satisfied.
Statements in C
Simple Statement (expression statement)

An expression terminated by a semicolon (;) is termed to be a simple statement (or expression
statement).
Example 4. 1
a=8;
c=a+b;
; Null statement
Compound Statements / Blocks

Compound statements are used to group the statements into a single executable unit. It consists
of one or more individual statements enclosed within the braces { }.
Example 4. 2
{ { {
a=10; a=1;
b=10; x=a*b; {
c=a + b; y = x * b – k; b=2; c=3;
} } }
}
Sequence
A program, which consists of declaration statements, input-output statements, and one or more
simple expression statements, is executed in a sequential manner.
Page 41
C3: Protected
Selection Statements
Selection statements are used to alter the normal sequential flow of control. It provides the ability
to decide the order of execution. The following are the selection constructs available in C:
“ if ” statement
Conditional / Ternary operator statement (? :)
“switch” statement
‘if’ Statement
The if statement, allows us to establish decision-making in the programs. Programs may require
certain logical tests to be carried out at some particular points. The tests and subsequent decisions
are made by evaluating a given expression as either True (non zero) or False (zero). An
expression involves arithmetic, relational, and/or logical operators. Depending on the result of the
expression the statements are executed.
The if statement has three basic forms:

Simple if-else
Nested if
if-else if ladder
Simple “if-else”
General Form:
if (expression)
{
statements1;
}
[ else
{
statements2;
} ]
statements3;
[ ] is used to represent the optional usage of ‘else’ block.
Expression can be arithmetic, logical, and/or relational expression. If the expression is evaluated to
true (nonzero), the statements1 are executed and the control is transferred to the statements
(statements3) next to the if construct is executed. If the expression is evaluated to false (zero), the
statements1 will be skipped and the else part statements (statements2) are executed. If the else
part is not specified, the statements (statements3) next to the if construct is executed.
Page 42
C3: Protected
Example 4.3: Program to find maximum of two numbers.

if (a<b)
max = b;
else
max = a;
printf(“ max = %d” ,max);
Short-circuit Evaluation
Whenever the expression with the operators && and || are evaluated, the evaluation process stops
as soon as the outcome, true or false is known. For example:
expr1 && expr2
If the value of expr1 is zero, the evaluation of expr2 will not occur [ 0 AND anything is 0]
expr1 || expr2
If expr1 has non-zero value, the evaluation of expr2 will not occur [ 1 OR anything is 1]
Nested ‘if’ Statement

Body of an ‘if’ statement contains another ‘if’ statement.
General Form:
if (expression)
{
statements1;
if (expression)
statements-1;
}
else
{
statements2;
if (expression)
statements-2;
}
Example 4.4
Program to find the maximum of 3 numbers.
if (a>b)
if (a>c)
printf(“largest = %d”, a);
else
printf (“largest = %d”,c);
else
if (c>b)
printf (“largest = %d”,c);
else
printf (“largest = %d”,b);
Page 43
C3: Protected
‘if… else if’ Ladder Statement
General Form:
if (expression)
statements1;
else if (expression)
statements2;
else if(expression)
statements3;
else
statements4;
Each condition is evaluated in order and if any condition is true the corresponding statement is
executed and the remainder of the chain is skipped. The final ‘else’ statement is executed only if
none of the previous conditions are satisfied. Final ‘else’ serves as a default case and is useful in
detecting an impossible or error condition.
Example 4.5
if (mark >= 75)
printf(“Honours\n”);
else if (mark >=60)
printf(“First Class\n”);
else if (mark >=50)
printf(“Second Class\n”);
else if (mark >=45)
printf(“Third Class\n”);
else
printf(“Fail\n”);
Conditional / Ternary / ?: Operator

This operator takes 3 expressions / operands. It is a more efficient form for expressing simple if
statements.
General form:
[variable = ]expr1? expr2: expr3;
This simply states:

if (expr1 is true) then expr2 else expr3
Where:
expr2 is evaluated, if the value of expr1 is non-zero (true part).
expr3 is evaluated, if the value of expr1 is zero (false part).
Page 44
C3: Protected
Example 4.6
max = (a>b) ? a : b;
which is similar to the following if-else statement.
if (a>b)
max = a;
else
max = b;
Switch Statement
This is a conditional control statement that allows some particular group of statements to be
chosen from several available groups. It is a multi-way conditional statement generalizing the ‘if-
else’ statement. A switch statement allows a single variable to be compared with several possible
case labels, which are represented by constant values. If the variable matches with one of the
constants, then an execution jump is made to that point. A case label can not appear more than
once and there can only be one default expression.
General Form:
switch (expression)
{
case item1: statement 1;
break;
case item2: statement 2;
break;
case itemn: statement n;
break;
default : statement;
}
Expression in the switch statement, must be an integer valued expression. Expression may be a
constant value, variable, array variable, pointer variable, relational expression, logical expression,
and/or arithmetic expression. Items which represent the case labels must be an integer constant or
character constant. Default case is optional and if specified, default statements will be executed, if
there is no match for the case labels.
The break is needed to terminate the switch after the execution of particular choice. Otherwise the
next cases get evaluated.
Page 45
C3: Protected
Example 4.7
switch (op)
{
case ‘+’:
c=a+b;
break;
case ‘-’:
c=a-b;
break;
case ‘*’:
c=a*b;
break;
case ‘/’:
c=a/b;
break;
default:
printf (“Invalid operator”);
}
Iteration Statements
Most of the real world applications require some set of instructions to perform repetitive actions on
a stream of data. There are several ways to execute loops in C. The statements used for looping
are: ‘for’, ‘while’, ‘do- while’.
‘for’ statements
This statement is used to repeat a statement or a set of statements for a specified number of times
or until a condition satisfied.
General Form:
for (expression1; expression2; expression3)
{
statement / block of statements;
}
Where:
expression1 initializes the counter/index variable. The initialization is usually an
assignment statement that is used to set the index variable or loop control variable.
expression2 is to set a terminating condition. It is evaluated at the beginning of every
iteration. If the test condition is True, the statements inside the loop are executed. If the
test condition is False, the control is transferred to the statement, which follows the
loop.
expression3 is the loop variant/modifier (increment / decrement), which is evaluated at
the end of every iteration.
Page 46
C3: Protected
These three expressions are separated by semicolons.
Example 4.8
(1) for (x=0; ((x>3) && (x<9)); x++)
(2) for (x=0, y=4; ((x>3) && (y<9)); x++, y+=2)
(3) for (x=0, y=4, z=4000; z ; z/=10)
(4) c=2;
for (;c<=20;c=c+2)
(5) for (c=2;;++c) infinite loop
(6) c=2;
for (;c<=20;)
{
printf (“%d”, c);
c++;
}
(7) int c=0;
for(;;) infinite loop
{
c+=1;
printf (“c=%d”, c);
}
Nested ‘for’ statement

There are many situations in which a loop statement contains another loop statement. Such loops
are called nested loops.
Example 4.9
for (i=1;i<=3;i++)
{
printf(“\n i = %d”,i);
for (j=1;j<=3; j++)
printf (“\n j = %d”,j);
}
In the above example, the loop controlled by the value of ‘i’ is called the outer loop. The second
loop, controlled by the value of ‘j’, is called inner loop. All statements in the inner loop are within
the boundaries of the outer loop. Different variables must be used to control each loop. For each &
every iteration through the outer loop, the inner loop runs completely.
‘while’ statement
The while is an entry controlled loop statement. The conditional expression is evaluated at the
beginning and the result of the expression decides on the execution of the body of loop. If the
result is True, the body of the loop is executed,
Page 47
C3: Protected
General Form:
while (expression)
{
Statements;
}
Expression can be a constant value, variable or any expression. If the expression evaluates to
True, the body of the loop is executed, otherwise statements after the while block is executed.
After executing the body of the loop, the expression is checked again. The body of the loop is
executed repeatedly until the expression is False. If the expression is initially False, the body of
loop is not executed at all.
The body of the loop may have one or more statements. The braces are needed only if the body
contains two or more statements.
Example 4.10
Different ways to use while loops
(1) while(x--){ };
(2) while(x = x+1){ };
(3) while(x) { };
(4) while(1);
(5) while ( (ch = getche ( )) != ‘q’)
putchar(ch);
(6) c=1;
while (c<=10)
{
printf (“%d”,c);
++c;
}
‘do - while’ statement

The do... while is an exit controlled loop statement.
General Form:
do
statement (s);
while (expression);
On reaching the do statement, the program proceeds to evaluate the body of the loop first. At the
end of the loop, the expression in the while statement is evaluated. If the expression is evaluated
to True, the program continues to evaluate the body of the loop once again. This process
continues as long as the expression evaluates to True. When the condition becomes False, the
loop will be terminated and control is transferred to the next statement following the do..while.
Since the expression is tested at the end of the loop, the body of the loop is executed at least
once.
Page 48
C3: Protected
Example 4.11
int d=1;
do
{
printf (“%d\n”,d);
++d;
} while (d<=10);
Break, Continue Statements
Break Statement
The break statement can appear in the switch statement and the loop statements. It causes the
execution of the current enclosing switch case or the loop to terminate.
General Form:
break;
Example 4.12
for(loop=0;loop<50;loop++)
{
If (loop==10)
break; /* control will come out of the loop. */
printf("%d\n",loop);
}
Only numbers 0 through 9 are printed.
Continue Statement
The continue statement can only appear in the loop statements. It is used to terminate the current
iteration. It skips rest of the statements in the body of the loop and begins the next iteration.
General Form:
continue;
Example 4.13
for(loop=0;loop<100;loop++)
{
if (loop==50)
continue;
printf("%d\n",loop);
}
The numbers 0 through 99 are printed except 50.
Page 49
C3: Protected
Summary
if statement is a condition based decision making statement.
Ternary operator is more efficient form for expressing simple if statements.
Switch statement is a conditional control statement that allows some particular group of
statements to be chosen from several available groups.
Looping allows a program to repeat a section of code any number of times or until
some condition occurs.
for, while, and do-while statements are repetitive control structures available in C
, that are used to carry out conditional looping.
break statement is used to terminate the loop but continue statement skips the current
iteration and continues the loop with the next iteration.

1. Which of the following statements are true?
a. An if statement must always include an else clause.
b. An if statement may include only simple statements.
c. if clause can contain another if statement.
2. When will the default case in switch statement be executed?
3. What is the output of the following piece of code?

main( )
{
int i=3;
switch(i)
{
default : printf(“0”);
case 1 : printf(“1”);
break;
break;
break;
}
}
4. What is the difference between a while and do..while statements?
Page 50
C3: Protected

while(1)
{
if (printf (“%d”, printf (“%d”)))
break;
else
continue;
}
Answers:
1. c
2. Default case is executed, whenever evaluated expression does not matches with any of the
case labels.
3. 3
4. While is an entry controlled loop (condition is checked in the beginning) and do..while is exit
controlled loop (condition is checked at the end). The loop statements of do..while will get
executed at least once.
5. 01
Page 51
C3: Protected
Session 6: Arrays and Strings
Learning Objectives
Understand the concept of array and its memory organisation
Know how arrays are declared and initialized in C
Use multi dimensional arrays
Know about various character and string functions
Need for an Array

Many applications require the processing of multiple data items that have common characteristics
(e.g., set of numbers, set of names). Array is a derived data type which is used to store similar
data items in contiguous memory locations under a single name. It holds a fixed number of equally
sized data elements, of the same data type. The individual elements are accessed by specifying
the subscript.
Memory Organization of an Array

The elements in an array are always stored in consecutive memory locations. If an array of 5
integers elements is created, totally 10 contiguous bytes will be allocated in memory.
Note: size of an integer is assumed to be 2 bytes
Starting address is assumed

as 1000 and totally 10 bytes
are created.
1000 1002 1004 1006 1008
Individual memory location is referred by index. [index 0 refers first location , index 1 refers
second location, etc.]. Address of an array element is calculated as below:
Address of ith location = base address + (size of the individual data element * index i )
Address of 0th element = 1000 + (2 * 0) = 1000
Address of 1st element = 1000 + (2 * 1) = 1002 …
In C, the name of the array refers to the base address of the array.
Page 52
C3: Protected
Declaration and Initialization
Array Declaration
Arrays are declared with appropriate data type and size. Arrays can be of single dimension or of
multi dimensions. Array declaration reserves space in memory.
General Form:
datatype arrayname[size] ;
Arrays are defined by appending an integer encapsulated in square brackets at the end of a
variable name. Each additional set of brackets defines an additional dimension to the array (multi
dimensional arrays). When addressing an element in an array, indexing begins at 0 and ends at 1
less than the defined size of an array.
Example 6.1
int x[5];
Defines an integer array x of 5 integers, starting at x[0], and ending at x[4].
char str[16]="qwerty";
Defines a character array, which is represents a string of maximum of 16 characters.
float sales_amt[10];
Defines a floating point array sales_amt of 10 floating point numbers, starting at sales_amt[0] and
ending at sales_amt[9].
int matrix[2][2];
Defines a 2*2 matrix (totally 4 elements) of integers.
Accessing Array Elements

The array elements are accessed by specifying the subscript / index.
General Form:
arrayname[index or subscript]
Example 6.2
x[0] to access the 1st element in array
x[4] to access the 5th element in array
str[2] to access the 3rd character in the string (character array)
sales_amt [8] to access the 9th sales amount in the array
Page 53
C3: Protected
Array Initialization
Array elements can be initialized during declaration or can be initialized in the program. When
arrays are initialized during declaration, partial initialization is allowed. In partial initialization, the
uninitialized array elements are initialized to Zero or Null depending on the data type of the array.
Zero is initialized for numeric array and Null for character array.
If initialized, array can be declared without specifying the exact size. In such cases, size of the
array equals the number of elements initialized.
General Form:
datatype arrayname[size] = {value(s)};
OR
datatype arrayname[ ] = {value(s)};
Example 6.3
int a[5]={1,2,3,4,5};
/*a[0] = 1, a[1] = 2 , a[2] = 3 , a[3] = 4 and a[4] = 5*/
int a[5]={0};
/*all the array elements are initialized to zero*/
int a[5]={1,2,3,4};
/*a[4] = 0*/
int a[ ] = {1,2,3,4};
/*a[0]=1, a[1]=2, a[2]=3, a[3]=4 (if size not specified, size depends
upon the number of values initialized. ) */
float b[2]={10.2,45.34};
/* b[0] = 10.20 , b[1] = 45.34 */
Basic Operation on Arrays

Basic operations allowed on arrays are storing, retrieving, and processing of array elements.
rd
Insertion and deletion can be done by moving the array elements to the appropriate places. (ex. 3
th rd th th
element can be deleted by moving 4 element to 3 location, 5 element to 4 location and so on)
Array name is a constant pointer (pointer is a variable which holds address of another variable) to
the base address of the array. Thus, the base address can not be changed. The following
expressions are illegal:
a++ (base address of array ‘a’ is modified by adding one)
a+=2 (base address of array ‘a’ is modified by adding two)
Page 54
C3: Protected
Getting the value for Arrays

Input statement is used to get the values for an array.
Example 6.5
int a[3];
(1) scanf(“%d”, &a[0]); /*gets value for 1st location*/
scanf(“%d”, &a[1]); gets value for 2nd location*/
scanf(“%d”, &a[2]); gets value for 3rd location*/
(2) scanf(“%d%d%d”, a, a+1, a+2);

/* gets value for first 3 locations (array name has the base
address - pointer)*/
(3) for(i=0;i<3;i++)
scanf(“%d”,&a[i]);
/* usually loop statement is used to get the array elements*/
Printing out the array elements
Example 6.6
int a[3];
(1) printf(“%d”, a[0]); /*prints value of 1st location*/
printf(“%d”,a[1]); /*prints value of 2nd location*/
printf(“%d”, a[2]); /*prints value of 3rd location*/
(2) printf(“%d%d%d”,a[0],a[1],a[2]);
/* prints value of first 3 locations*/
(3) for(i=0;i<3;i++)
printf(“%d”,a[i]);
/*loop statement is used to print the array elements */
Multi-dimensional Array
The elements of an array can themselves be arrays. Multidimensional arrays will also occupy the
contiguous memory locations. Two dimensional arrays can be viewed as set of one dimensional
array (rows & columns) and 3 dimensional arrays can be viewed as set of two dimensional arrays.
Two-dimensional array – Declaration

Two-dimensional arrays are defined in the same way as one dimensional array, except that a
separate pair of square brackets is required for second dimension.
General Form:
datatype arrayname [row ][column]
Page 55
C3: Protected
Example 6. 7
int a[2][2]; creates 8 bytes of contiguous memory locations. (2*2 = 4 elements).
Elements are stored in row major order. Elements of 1st row are stored first and then the elements
of next row. It is necessary to specify the size of the column in declaration.
Assume that array starts at location 1000,
a[0][0] will be in location 1000 - row 0 & column 0
Two-dimensional array Initialization

Two-dimensional arrays can also be initialized in the declaration statement. In partial initialization,
the uninitialized array elements are initialized to Zero.
Example 6.8
int num[2][3] = {1,2,3,4,5,6};
int num[2][3] = {1,2,3,4,5}; /*num[1][2] = 0*/
int num[2][3] = {{1,2,3},{1,2,3}};
/*row elements are initialized separately*/
int num[2][3] = {{1,2},{4}};
/*num[0][2] = 0 num[1][1]=num[1][2]=0*/
Example 6.9: 4-dimensional array

sales [year ] [month ] [area ] [salesperson]
Advantages
Simple and easy to use
Stored in Contiguous locations
Fast retrieval because of its indexed nature
No need to worry about the allocation and de-allocation of arrays
Limitations
Conventional arrays are static in nature. Memory is allocated in the beginning of the
execution. If m elements are needed, out of n locations defined, n-m locations are
unnecessarily wasted
No automatic array bounds checking during compilation
Page 56
C3: Protected
Strings
Strings are sequence of characters. In C, there is no built-in data type for strings. String can be
represented as a one-dimensional array of characters. A character string is stored in an array of
character type, one ASCII character per location. String should always have a NULL character
(‘\0’) at the end, to represent the end of string.
String constants can be assigned to character array variables. String constants are always
enclosed within double quotes and character constants are enclosed within single quotes.
Example 6.10
(1) char c[4]={‘s’,’u’,’m’,’\0’);
(2) char str[16]="qwerty"; /*Creates a string. The value at str[5] is
the character ‘y’. The value at str[6] is
the null character. The values from str[7]
to str[15] are undefined.*/
(3) char name[5];
int main( )
{
name[0] = ‘G’;
name[1] = ‘O’;
name[2] = ‘O’;
name[3] = ‘D’;
name[4] = ‘\0’;
return 0;
}
(4) char name[5] = “INDIA” /* Strings are terminated by the null
character, it is preferred to allocate one
extra space to store null terminator */
Array of Strings
Two dimensional character arrays are used to represent array of strings.
Declaration
General Form:
char arrayname [no. of strings] [max no. of chars in strings];
Example 6.11
char studname[50][15];
/* 50 student names each with 15 characters at the maximum */
Page 57
C3: Protected
Initialization
General Form:
char arrayname [ r ] [ c ]={“values”};
Example 6.12
char name[3][5] = {“bata” ,”cat” ,”at”}
char name[3][5] = {{‘b’,’a’,’t’,’a’,’\0’}, {‘c’,’a’,’t’,’\0’},
{‘a’,’t’,’\0’}}
String can be read either character-by-character or as an entire string (using %s format specifier).
Array name itself specifies the base address and %s is a format specifier which will read a string
until a white space character is encountered.
[Note: no need to use & operator while reading string using %s]
Example 6.13
(1) char name[20];
int i=0;
while((name[i] = getchar ()) != ‘\n’ )
i++;
(2) scanf( “%s“ , name);
(3) printf(“%s” , name);
Illegal operations on Strings
C does not allow one array to be assigned to another, thus statements of the following form are
illegal”
name = “GOOD”; Or name1 = name; assignment not allowed
name1 = name + “to c “ concatenation is not allowed
if (name1 == name) two strings cannot be compared with the ‘equal to’ operator
Page 58
C3: Protected
String Functions
C does not provide any operator, which manipulates the entire string at once. Strings
are manipulated either via pointers or via special routines available from the standard
string library string.h.
The following is the list of string functions available in string.h:

String Functions Functionality
strcpy(string1, string2) Copy string2 into string1
strcat(string1, string2) Concatenate string2 onto the end of string1
strcmp(string1,string2) Lexically compares the two input strings (ASCII comparison)
returns 0 if string1 is equal to string2
< 0 if string1 is less than string2
> 0 if string1 is greater than string2
strlen (string) Gives the length of a string
strrev (string) Reverse the string and result is stored in same string.
strncat(string1, string2, n) Append n characters from string2 to string1
strncmp(string1, string2, n) Compare first n characters of two strings.
strncpy(string1,string2, n) Copy first n characters of string2 to string1
strupr (string) Converts string to uppercase
strlwr (string) Converts a string to lowercase
atoi (string) Converts the string to integer number
atof (string) Converts the string to floating point number
atol (string) Converts the string to long integer number
strchr (string, c) Find first occurrence of character c in string.
strrchr (string, c) Find last occurrence of character c in string.
strstr(s1,s2) Locates the first occurrence of s2 in s1.
strpbrk(s1, s2) Returns a pointer to the first occurrence in s1 of any character from
s2
strspn(s1, s2) Returns the number of characters at the beginning of s1 that match
s2.
strcspn(s1, s2) Returns the number of characters at the beginning of s1 that do not
match s2.
Page 59
C3: Protected
Character Functions
C provides the following collection of character functions, which can manipulate a single character.
The header file, ctype.h, is used for the character functions.
Functions Functionality
int isalnum (c) True if c is alphanumeric.
int isalpha (c) True if c is a letter.
int isascii( c) True if c is ASCII .
int iscntrl (c) True if c is a control character (\n,\f,\r,\a)
int isdigit (c) True if c is a decimal digit
int isgraph (c) True if c is a graphical character (all characters, except space)
int islower (c) True if c is a lowercase letter
int isprint (c) True if c is a printable character (all characters including white space)
int ispunct (c) True if c is a punctuation character (, . ,‘, ‘, “,:,)
int isspace( c) True if c is a space character (\n,\f,\r,\t,\v,’ ‘)
int isupper (c) True if c is an uppercase letter
int isxdigit (c) True if c is a hexadecimal digit
toupper (x) Converts lowercase letter to uppercase
tolower (x) Converts uppercase to lowercase
toascii (x) Converts the char to ASCII value
Summary
An array can be defined as a collection of homogenous elements stored in consecutive
memory locations.
Array name is a constant pointer to the base address of the array.
Conventional 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 is no restriction on the number of
dimensions.
String is represented as an array of characters.
C supports a number of in-built string functions to manipulate strings.
Page 60
C3: Protected

1. Is it possible to declare an array x containing 50 integer elements followed immediately by
50 floating point numbers?
2. Why array index should always start with 0?
3. How entire array, x[100] with value 0, is initialized in declaration statement?
4. When a one dimensional array is being declared, under what condition may the size be
omitted, with array name followed by an empty pair of square brackets?

main()
{
int a[5]={2,3};
printf(""\n %d %d %d"",a[2],a[3],a[4]);
}
6. List few library functions for string operations.
Answers:
1. No, array can contain only similar data items.
2. Array elements are accessed by relative addressing method (base address + index), in
order to access the first element, which is in base address, index must be 0.
3. int x[100] = {0} ( partial initialization)
4. If an entire array is being initialized within the declaration.
5. 0 0 0
6. strlen(), strcmp(), strcat(), strrev(), strcpy()
Page 61
C3: Protected
Session 8: Pointers
Learning Objectives
Explain the significance of pointers
Declare pointer
Initialize pointers
Use pointers with arrays
Implement dynamic memory allocation
List the advantages and disadvantages of pointers
Introduction
Pointer is a variable that contain the memory address of another variable. Pointers are one of the
powerful and frequently used features of C, as they have a number of useful applications.
Variables contain the values and pointer variables contain the address of variables that has the
value. Variable directly references the value and Pointer variable indirectly references the value.
Referencing a value through a pointer is called Indirection.
Whenever a variable is declared, memory is allocated for the variable according to the data type
specified.
int a = 5 ; 2 bytes of memory is allocated for variable ‘a’
a 5 a – variable, 5 – value, 1000 – assumed as the address of a
1000
printf(“ Value = %d”, a); prints the value 5

printf(“ Address of a = %u”, &a); prints the address 1000

A pointer variable is declared with an asterisk before the variable name. The type-specifiers
determine that what kind of variable the pointer variable points to.
Page 62
C3: Protected
Declaration
General Form:
data-type *pointer-name;
C provides two operators, & and *, for pointer implementation.

& address operator. It is a unary operator that returns the address of its operand.
* Indirection or de-referencing operator. It returns the value of the variable to which
its operand points.
* and & are inverse of each other.
Example 8.1
int x, *px;
px = &x; x = 5 ;
x px variables
5 1000
values
1000 3000 addresses
Example 8.2
Now execute the following printf statements and observe the results.
printf(“ x = %d “ , x); prints 5
printf(” address of x = %d “ , &x); prints 1000
printf (“ address pointed by pointer = %u”, px); prints 1000
printf (“address of the pointer = %u”, &px); prints 3000
printf (“content pointed by pointer = %d”, *px); prints 5
Initialization
Pointer variables should be initialized to 0, Null or an address. No other constant can be initialized
to a pointer variable. Pointer variable of a particular data type can, hold only the address of the
variable of same data type.
Example 8.3
Valid and Invalid pointer assignments
int a , b , *p = &a , *q = NULL; valid.
q = p; valid - both p and q is pointing to the memory location of variable a
b = &a; invalid – ordinary variables cannot hold address.
q = a; invalid - cannot assign value to the pointer variable
Page 63
C3: Protected
Pointer Arithmetic
Pointer Addition or subtraction is done in accordance with the associated data type.
int adds 2 for every increment
char adds 1 for every increment
float adds 4 for every increment
long int adds 4 for every increment
All the operations can be done on the value pointed by the pointer.
The following operations can be performed on pointer variables:

A pointer variable can be assigned the address of an ordinary variable or it can be a
null pointer.
A pointer variable can be assigned the value of another pointer variable.
An integer quantity can be added to or subtracted from a pointer variable.
One pointer can be subtracted from another pointer variable provided both are pointing
to same array.
Two pointer variables can be compared.
The following are the illegal operations on pointers variables:

Two pointer variables can not be added.
Pointer variable can not be multiplied or divided by a constant.
Example 8.4: Pointer arithmetic

int * ptr , i=5;
ptr= &i; let ptr = 1000 (location of i)
ptr ++; ptr = 1002 (+2 for integers)
++*ptr or (*ptr)++ increments the value of i by 1
Example 8. 5: Pointer operations

Legal operations
p1 > p2 p1==p2 p1+2 p1-p2 (if p1, p2 points to same array)
Illegal operations
p1/p2 p1*p2 p1+p2 p1/5
Page 64
C3: Protected
Pointers and Arrays
Arrays
Array is used to store the similar data items in contiguous memory locations under single name.
Array addressing is in the form of relative addressing. Compiler treats the subscript as a relative
offset from the beginning of the array. Array subscripting notation is converted to pointer notation
during compilation, so writing array subscripting expressions using pointer notation can save
compile time.
Pointers
Pointer addressing is in the form of absolute addressing. Exact location of the elements can be
accessed directly by assigning the starting location of the array to the pointer variable. The pointer
variable is incremented to find the next element.
C treats the name of the array as if it is a pointer to the first element. Thus, if v is an
array, *pv is the same as v[0], *(pv+1) is the same as v[1], and so on.
Pointer pointing to an array
Initialization
To initialize a pointer variable, conventional array is declared and pointer variable can be made to
point to the starting location of the array. Array elements are accessed using pointer variable.
General Form:
pointer_variable = &array_name [starting index];
OR
pointer_variable = array_name;
Example 8. 6
int a[5] = {1,2,3, 4,5} , *ptr , i ;
ptr = a ; similar to ptr = &a[0];
Assume that array starts at location 1000
&a[0] = 1000 a[0] = 1 ptr + 0 = 1000 *(ptr+0) = 1
&a[1] = 1002 a[1] = 2 ptr + 1 = 1002 *(ptr+1) = 2
&a[2] = 1004 a[2] = 3 ptr + 2 = 1004 *(ptr+2) = 3
&a[3] = 1006 a[3] = 4 ptr + 3 = 1006 *(ptr+3) = 4
&a[4] = 1008 a[4] = 5 ptr + 4 = 1008 *(ptr+4) = 5
Page 65
C3: Protected
Accessing value
Example 8.7
printf (“%d “,*(ptr+i)); displays the a[i] value
printf (“%d “,*ptr); displays the a[0] value
printf (“%d “,*(a+i)); displays the a[i] value
Accessing address
Example 8.8
printf (“%u “, (ptr+i)); displays address of a(i)
Pointers and Multi Dimensional Arrays

As the internal representation of a multi dimensional array is also linear, a pointer variable can
point to an array of any dimension. The way in which the pointer variable used, varies according to
the dimension.
General Form:
ptr_vble = &array_name [starting index1]…[starting indexn];
OR
ptr_vble = array_name;
Example 8.9
int a[2][2] = {1,2,3,4} , *ptr ;
ptr = &a[0][0] ;
Assume that the array starts at location 1000
&a[0][0] = 1000 a[0][0] = 1 ptr+0 = 1000 *(ptr+0) = 1
&a[0][1] = 1002 a[0][1] = 2 ptr+1 = 1002 *(ptr+1) = 2
&a[1][0] = 1004 a[1][0] = 3 ptr+2 = 1004 *(ptr+2) = 3
&a[1][1] = 1006 a[1][1] = 4 ptr+3 = 1006 *(ptr+3) = 4
If the pointer to the array is accessed with 2 subscripts, it results in a problem.
For example,
(p+0) + 1 if it is used to represent 0th row and 1st column and
(p+1) + 0 if it is used to represent 1st row and 0th column results in p+1.
So, multi dimensional arrays can be represented by pointer in the following two ways:
Pointer to a group of arrays
Array of pointers
Pointer to a group of arrays

A two dimensional array, for example, is a collection of one dimensional array. Therefore, a two-
dimensional array is defined as a pointer to a group of one dimensional array and in the same way
three dimensional arrays can be represented by a pointer to a group of two dimensional arrays.
int a[3][2] can be represented by a pointer as follows:
Page 66
C3: Protected
int (*p)[2] p is a pointer points to a set of one dimensional array, each with 2 elements.
Note: First dimension need not be specified but the second dimension has to be specified. Here, a
single pointer is used and it needs to know how many columns are there in a row.
The following representations are used when a pointer is pointing to a 2D array:

th
ptr+i is a pointer to i row.
*(ptr+i) refers to the entire row - actually a pointer to the first element in i th row.
(*(ptr + i) +j) is a pointer to jth element in ith row
*(*(ptr+i) + j)) refers to the content available in ith row, jth column
Accessing value
Example 8.10
printf (“%d “,*(*(ptr + i) +j); displays the x(i,j) value
printf (“%d “,*(a[ i ] + j); displays the x(i,j) value
printf (“%d “,*(a + i)[ j ]; displays the x(i,j) value
Example 8.11
main()
{
int i, j;
int a[2][3]={1,2,3,4,5,6};
int *pa=&a[0][0];
for (i=0;i<2;i++)
{
for (j=0;j<3;j++)
printf(“\t%d”,*(*(pa+i)+j));
printf(“\n”);
}
}
Output:
1 2 3
4 5 6
Array of Pointers
Multi dimensional array can also be expressed in terms of an array of pointers.
int a[2][2] can be represented as int *ptr[2]
Here, we have 2 pointers ptr[0], ptr[1] and each pointer can point to a particular row . Thus, only
one indirection is enough to represent a particular element.
Page 67
C3: Protected
Example 8.12
int a[2][2] = {1,2,3,4} , *ptr[2] ;
ptr[0] = a[0]; /* ptr[0] is now pointing to the 0th row ( & a[0][0]) */
ptr[1] = a[1]; /* ptr[1] is now pointing to the 1st row ( & a[1][0]) */
ptr[0] + 0 = 1000 *(ptr[0] + 0) = 1

ptr[0] + 1 = 1002 *(ptr[0] + 1) = 2
ptr[1] + 0 = 1004 *(ptr[1] + 0) = 3
ptr[1] + 1 = 1006 *(ptr[1] + 1) = 4
Example 8.13
(1) *p[3] declares p as an array of 3 pointers
(2) (*p)[3] declares p as a pointer to a set of one dimensional array of 3 elements
Pointers and Strings

Character pointer is a pointer, which can hold the address of a character variable. Suppose, if we
have a character array declared as:
char name[30] = {“Data Structures”};
We can declare a character pointer as follows:
char *p = NULL;
Once the pointer is declared, the address of the array is assigned to this pointer. When an array is
referenced by its name, it refers to the address of the 0th element.
p = name;
The statement assigns the address of the 0th element to p.
Now issue the following printf statements and check the output:
printf(“Character output = %c\n”, *p);

printf(“String output = %s”, *p);
When a pointer variable is referred with the indirection operator, it refers the content of the address
pointed by the pointer variable. The above printf statements produce the outputs 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. Pointer automatically gets
incremented to the next location.
Page 68
C3: Protected
Character-type pointer variable can be assigned an entire string as a part of its variable
declaration.
char *p = “string” ; valid

int *p = {0,1,2,3} ; invalid
Thus, string can be represented by either as a one-dimensional character array or a character
pointer.
An array of character pointers offers a convenient method for storing strings. Each pointer is used
to represent a particular string.
Conventional array declaration: char name[10][10];

Array of character pointers : char *name[10];
Ragged Arrays
Consider the following array declaration.
char names[3][10] = { “abcde”, “rstu”, “xyz”};
This array occupies 30 bytes and the row length is fixed. Instead of making each row a fixed
number of characters, make it a pointer to a string of varying length.
If the elements of array are string pointers, a set of initial values can be specified as part of the
array declaration.
char *name[4] = { “A” , “AB” , “ABC” , “ABCD”} ;
An advantage is that a fixed block of memory need not be reserved in advance. The above
statement allocates variable length block of memory and occupies only 14 bytes. It declares 4
pointers each pointing to a string. Thus, substantial saving in memory. Arrays of this type are
referred as Ragged arrays (used only in the initialization of string arrays).
In the above example,

*(name + 1) will access the string AB
* (name + 2) will access the string ABC
*(*(name + i) +j) refers the jth character in ith string
*(*(name+3)+3) refers D in the string “ABCD”
Memory organization – String Pointers
Example 8.14
(1) char *ps = “xyz”;
pointer ‘ps’ is stored in 2 bytes and ‘ps’ contains the address of the string that requires 4 bytes.
(2) char s[ ] = “xyz”;
string ‘s’ is stored in 4 bytes.
Page 69
C3: Protected
Pointer to a constant
The address of a constant variable can be assigned to a pointer variable. The following example
explains the pointer variable to a constant variable:
Example 8.15
const int a=10;
int *pa = &a;
/* suspicious pointer conversion. Wise to avoid such assignments */
Variable ‘a’ is a constant variable. The value cannot be modified.
Pointer variable ‘pa’ can take any other address and value of ‘a’ can be changed using pointer
even though it is constant variable.
Constant Pointer
The pointer variable can be a constant. A pointer variable can take the address of a non-constant
data and constant data.
Constant pointer to non-constant data always points to the same memory locations and the data at
that location can be modified through the pointer. Pointers variables that are declared ‘const’ must
be initialized when they are declared.
Example 8.16
int a;
int *const pa = &a;
Constant pointer to constant data always points to the same memory location and the data at that
memory location cannot be modified.
Example 8.17
int b;
const int * const pb = &b;
Generic Pointer (void Pointer / Pointer to void)

The type void * is used to declare generic pointers. The generic pointer can be made to point any
data type. Type casting is not needed during address assignment. But it is needed, when
dereferencing the content using void pointer, in order to know the size and value of the data item.
Example 8.18
int a; float b;
void *pab;
pab=&a;
*(int *) pab =100;
pab=&b;
*(float *) pab = 105.55;
Page 70
C3: Protected
Dynamic Memory Allocation

Conventional arrays are static in nature, because size has to be mentioned in the declaration
statement itself and fixed block of memory is reserved during the compilation.
C supports dynamic memory allocation through the following functions:

malloc(), calloc () , free()
These functions provides the ability to reserve as much memory as may required during program
execution, and then release this memory when it is no longer required.
Thus, arrays can be represented in terms of pointers and an initial memory location can be
allocated to pointer variable by means of this memory allocation functions.
int *p;
p = (int *) malloc ( 10 * sizeof(int)) ;
The above program constructs will return memory block of 20 bytes, which can hold 10 integers.
The starting address is pointed by the pointer ‘p’.
A one dimensional dynamic array can be declared using pointers as follows:

int *p;
p = (int *) calloc (10, sizeof(int));
This will return 10 continuous memory blocks of 2 bytes each and initializes them to 0. This can be
used to allocate space for arrays and structures.
free(p) will release the memory pointed by a pointer variable ‘p’. free() will take a void pointer.
Example 8.19: Program for adding two matrices using array of pointers
void main()
{
int *a[3] , *b[3] , *c[3];
int i,j;
for(i=0 ; i<3; i++)
{
a[i] = (int *)malloc( 3 * sizeof(int));
/* memory is allocated to individual pointers */
b[i] = (int *)malloc( 3 * sizeof(int));
c[i] = (int *)malloc( 3 * sizeof(int));
}
printf(" \n enter the values of matrix 1 \n");
for(i=0; i<3; i++)
for(j=0; j<3; j++)
scanf("%d", a[i]+j);
printf("\n enter the values of second matrix");
Page 71
C3: Protected
for(i=0; i<3; i++)

for(j=0; j<3; j++)
scanf("%d", b[i]+j);
for(i=0; i<3; i++
for(j=0; j<3; j++)
*(c[i]+j) = *(a[i]+j) + *(b[i]+j);
for(i=0; i<3; i++)
for(j=0; j<3; j++)
printf("\t%d", *(c[i]+j));
}
Chain of Pointers
Multi dimensional arrays can be declared using pointer to pointer representation and memory can
be allocated dynamically.
int **p; represents 2 dimensional array
In the above declaration p is a pointer variable, which holds the address of another integer pointer.
As such, there is no restriction imposed by the compiler as to how many levels we can go about in
using a pointer.
The following declaration is perfectly valid:

int *****p;
However, beyond 3 levels, it will make the code highly complex and un-maintainable.
Example 8.20
addr.ptr2 addr.ptr1 value
int x,*p1,**p2;
x=100;
p1=&x;
p2=&p1;
To access the value we can use either **p2 or *p1
Advantages
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(Dynamic Memory Allocation)
Page 72
C3: Protected
Limitations
If the allocated memory is not freed properly, it cause memory leakages
If not used properly, it makes the program difficult to understand and may cause the
illegal memory references
Summary
Pointer is a variable which can hold the address of another variable.
& operator is used to refer the address of a variable and * operator is used for
dereferencing the pointer.
Pointer can point to an array of any dimensions.
There are two ways to represent multi dimensional arrays by means of pointers:
o Single pointer points to set of arrays
o Array of pointers
Strings can easily be represented using pointer – Ragged arrays.
malloc(), calloc() functions are used to allocate memory dynamically.
free() function is used to de-allocate the memory.

1. State whether the following are true or false
a. Pointer variable can only contain an address
b. Address of the memory location can be assigned to ordinary variables
c. Pointer can refer to the content of the memory location by & operator
d. Size of the pointer variable is equivalent to the size of the data item it points.
2. What is the use of generic pointers?

main()
{
int n[25];
n[0]=100;
n[24]=200;
printf("\n%d,%d", *n, *(n+24)+*(n+0) );
}
4. Given the following declaration:

int a, *b = &a , **c = &b;
What is the output of the following statements?
a=4; **c=5; b = (int *)**c;
Page 73
C3: Protected

main( )
{
char *str1=”abcd”;
char str2[]=”abcd”;
printf(“%d %d %d”, sizeof(str1),sizeof(str2), sizeof(“abcd”));
}
6. Differentiate malloc() , calloc().
Answers:
1. True, false, false, false
2. Generic pointers (void pointers) can point to data items of any type.
3. 100, 300
4. The first statement assigns 4 to a. The second statement assigns 5 to the location pointed to
by the location pointed to by c. Since c points to b, this is same as assigning 5 to the location
pointed to by b. Since b points to a, this statement is equivalent to assigning 5 to a. The third
statement castes **c, which is value of a, into type int *, assign the value to a. The result is
meaningless, because values cannot be assigned to pointers.
5. 2 5 5
6. malloc(), calloc() will both allocate the memory dynamically, but the difference is calloc() will
return a contiguous memory location and initializes it to 0.
Page 74
C3: Protected
Session 10: Functions
Learning Objectives
Explain the need for user-defined functions
Define functions
Invoke functions
Differentiate between different argument passing mechanisms
Pass arrays and pointers as arguments to a function
Define recursion
Use different storage classes in to a program
Use command line arguments
Need for Functions

Functions are smaller self-contained components which carry out some specific, well defined task.
As real world applications 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 after designing an algorithm, its implementation becomes more difficult because
of the size of the program.
As programs become larger, testing, debugging, and maintenance will be a difficult
task.
Thus, complex problems can be solved by breaking them into a set of sub-problems, called
Modules. Each module can be implemented independently and later can be combined into a single
unit.
C supports modularity by means of functions. C functions are classified into two categories.
User defined functions
Library functions
C function offers the following advantages.

It facilitates top-down modular programming. Modularity brings logical clarity to the
programs
It avoids the need for redundant code. The repeated instructions can be written as a
function, which can then be called whenever it is needed
Page 75
C3: Protected
It facilitates reusability – functions created in one program can be accessed in other

programs. C programmer can build on what others have already done, instead of
starting from scratch
C functions can be used to build a customized library of frequently used routines
Function Prototype
Like variables, functions are declared and declaration of a function is called Function Prototype.
Prototype specifies the signature (name) of the function, the return type, and number and data
types of the arguments. It helps the compiler to know about the function. Functions must be
declared before it is called.
Function prototyping is not mandatory in C. It is mandatory when the function is called prior to its
definition. They are desirable, however, because they further facilitate error checking between
function calls and the corresponding function definition.
Example 10.1
int find_big (int, int);
/* function find_big returns integer value, takes 2 integer
arguments */
void swap (int *, int *);
/* function ‘swap’ does not return any value, takes 2 pointer
variables. */
float add(float, int);
/* function ‘add’ returns float value, takes 1 float variable and 1
integer variable */
Example 10.2
(1)
main()
{
int a,b;
int sum(int, int) ; /* function prototyping. */
scanf("%d%d” , &a, &b);
printf(“ %d “ , sum(a, b);
}
int sum(int a , int b)
{
return a+b;
}
Page 76
C3: Protected
(2)
void fun()
Function is defined prior to its
{
reference. So compiler will
printf(“"prototype not needed “); identify the function name.
}
main()
{
fun();
}
Function Definition
Function definition is used to define the function with appropriate name, parameters, and the
operations to be carried out by the function. Functions can be defined at any location in the
program. If the function is defined before the ‘main’ program, there is no need for the function
prototype.
A function definition has two principle components: Function header (first line), Function body.
General form:
return-type function-name(type arg1, type arg2, …..)
{
local variables Declaration;
executable statement 1;
executable statement 2;
:
return expression;
}
Function Header
function-name specifies the name of the function and it must be a valid identifier
arg1,arg2 … specifies formal arguments (formal parameters)
return-type represents the data type of the data item returned by the function
Function Body
Function can have declaration statements and any number of valid executable statements.
Local Variables - The variables declared inside any function are local to that function. It can be
accessed only within that function. Memory for the local variables is allocated only when the
function is invoked and de-allocated when the control moves out of the function.
Global Variables - The variables that are common to all the functions are declared outside the
functions. If it is declared in the Global declaration section, it is used by all the functions in the
program. Memory for the global variables is allocated, when the program gets executed and de-
allocated only at the end of program execution.
Page 77
C3: Protected
return statement is used to transfer the control back to the calling program. A function may or may
not return a value to the calling function. A function may receive any number of values from the
called function. If it returns a value, it is achieved by the return statement. There can be multiple
return statements, each containing different expression. If there is no return statement, the closing
braces (}) in the function body acts as a return statement.
General Form:
return;
OR
return(expression);
expression can be a variable name, constant value or any single valued expression.
Example 10.3
(1) return; does not return any value; (control is transferred to calling program)
(2) return 0; returns zero
(3) return(a*b); returns the product of a & b
(4) return(a<b); returns True (1) or False (0)
Example 10.4
Function for finding the biggest of two integers
int find_big(int a, int b)
{
if ( a > b)
return a; Function Name – find_big
else Return Type – integer
return b;
Formal arguments – 2 (a, b)
}
If the function doesn’t receive any arguments and doesn’t return any data, then void keyword is
used to represent that. Default return type is ‘int’.
Example 10.5
(1) void display(void)
{
printf(“this is a function”);
}
(2) main()
{
return 0;
}
Page 78
C3: Protected
Function Call
Functions are invoked by specifying its name, followed by a list of parameters enclosed within
parentheses.
General form:
[variable name =] function name(actual arguments);
Actual arguments are the parameters passed to the called function. The number, data type, and
the order of the actual arguments and formal arguments should match. Variable names of the
actual arguments and the formal arguments need not be same.
When the function call is encountered, the control is transferred to the called function and the
statements in the function are executed. When the return statement is executed or last statement
is execution, the control is transferred back to the place of function call in the calling function. If a
function is returning a value, that value is substituted in place of a function call in the calling
function. The LHS variable name in the function call is optional. If the function returns value, the
value returned is stored in the LHS variable name.
Example 10.6
Program for finding biggest of two integers using the function find_big
int find_big(int, int);
/* function prototype, global declaration */
main( )
{
int num1, num2, big;
scanf(“%d%d”, &num1, &num2);
big=find_big(num1,num2);
/* function call statement, num1 & num2 are actual arguments */
printf(“ The biggest is : %d “, big);
}
int find_big(int a, int b) /* a & b are formal arguments */
{
if ( a > b)
return a;
else
return b;
}
Note: Function can also be called using printf (“The biggest is: %d”, find_big(num1,num2))
statement.
Recursion
If a function is having a self-reference, it is called Recursion. It is a process by which a function
calls itself.
Page 79
C3: Protected
A recursive function must have the following properties:

The problem must be written in a recursive form
There must be a base criteria (terminating condition) for which the function doesn’t call
itself
Example 10.7
main()
{
int n, fact(int);
printf(“Enter an integer\n”);
scanf(“%d“,&n);
printf(“Factorial = %d“,fact(n));
}
fact(int k);
{
if (k<=1)
return 1;
else
return(k*fact(k-1);
}
If n = 4, then
call 1 = 4 * fact(3); call 2 = 3 * fact(2) ; call 3 = 2 * fact(1)
In fourth call, the condition evaluates to 1 and returns 1 to the calling part (call 3), which in turn
return the value to its calling function. Function will be evaluated in Last In First Out manner
(Stack)
Nesting of Functions
Functions may be nested. The main function may call function1, which in turn call function2, which
may call function3.
Passing Arguments
A function is referenced by its name and providing appropriate values for the arguments. On
seeing the name of the function in calling statement, the control is immediately transferred to the
function. The parameter values are substituted and the function is executed. When the return
statement is encountered, control is transferred back to the called function, along with the value
returned.
Depending on its definition, functions may be classified as:

Functions with no arguments & no return value
Functions with no arguments but return value
Functions with arguments but no return value
Functions with arguments and return value
Page 80
C3: Protected
Example 10.8
No Arguments and no return value No arguments but return value
main() main()
{ {
border(); int sum;
printf(“\t\t Hello World\n””) sum=add();
border(); printf(“\nSum = %d”,sum);
} }
border() add()
{ {
int i; int a,b;
for(i=1;i<=80;i++) scanf(“%d%d”, &a,&b);
printf(“-“); return(a+b);
printf(“\n”); }
return;
}
Example 10.9
With arguments and no return value With arguments and return value
main() main()
{ {
int n; char c; int sum,a,b;
printf(“Enter the size of border & style\n”); printf(“Enter2 integers\n”);
scanf(“%d%c”, &n,&c); scanf(“%d%d”,&a,&b);
border(n,c); sum=add(a,b);
printf(“\t\t Hello World\n””) printf(“\nSum = %d”,sum);
border(n,c);
} }
border(int m, char s) add(int x,int y)
{ {
int i; return a+b ;
for(i=1;i<=m;i++) }
printf(“%c“,s);
printf(“\n”);
return;
}
Passing arguments to a Function:

There are two approaches to pass the information to a function via arguments. They are:
Call by Value
Call by Reference
Page 81
C3: Protected
Call by Value
Arguments are usually passed by value in C function calls. The values of the actual arguments are
copied in to the respective formal arguments. Actual and formal arguments refer to the different
memory locations and the value of actual argument is copied into the formal argument. So, any
changes made to the formal argument are not reflected in their corresponding actual arguments.
The value of the actual argument will remain same.
ax a is actual argument and x is formal argument.
Example 10.10: Program that illustrates call by value mechanism

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
In this approach, the addresses of actual arguments are passed to the function call and the formal
arguments will receive the address. The actual and formal arguments refer to the same memory
location. So, changes in the formal arguments are reflected in actual arguments.
Note: Actual arguments are address of the ordinary variable, pointer variable or array name.
Formal arguments should be a pointer variable or array.
This approach is of practical importance while passing arrays to functions and returning back more
than one value to the calling function. Passing arrays to functions is call by reference by default.
a x a is actual argument and x is formal argument.
Page 82
C3: Protected
Example 10.11: Program that illustrates call by reference mechanism

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) /* reference is made */
{
int temp;
temp = *c;
*c = *d;
*d = temp;
}
Functions and Arrays

It is possible to pass an entire array to a function. To pass an array to a function, it is enough to
give the name of the array as argument. Array name is interpreted as base address of the array
and the address is given to the formal argument. Formal argument can be an array or pointer
variable, which points to an array.
Example 10.12
int maximum( int val[] )
/*size of the array need not be mentioned */
{
int max_value, i;
max_value = val[0];
for( i = 0; i < 5; ++i )
if ( val[i] > max_value )
max_value = val[i];
return max_value;
}
Page 83
C3: Protected
main()
{
int values[5], i, max;
printf("Enter 5 numbers\n");
for( i = 0; i < 5; ++i )
scanf("%d", &values[i] );
max = maximum(values);
/* array name is used to pass an entire array without any
subscripts */
printf("\nMaximum value is %d\n", max );
}
Passing Multidimensional Arrays

Multi dimensional arrays can also be passed in the same manner as single dimensional array, but
care must be taken in representing the formal arguments.
Example 10.13
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");
}
}
Note: Second dimension is mentioned with its size. In case of three dimensional arrays, second &
third dimension has to be mentioned. This is to represent the column size. The array elements are
stored in row major form.
Arrays can not be returned with return statement since return can pass only a single-value back to
the calling program. Therefore, in order to return an array to the calling program, the array must
either be defined as global array, or it must be passed as a formal argument to a function.
Page 84
C3: Protected
Functions and Pointers

Pointers can be passed to a function as arguments and a function can also return a pointer to the
calling program.
Example 10.14: Passing pointers as argument

main()
{
int a =5 , *p;
void change(int *); /* function prototype */
p =&a;
change(p); /* pointer p is passed to a function – call by
reference */
printf(“ %d “ , a); /* prints 10 */
}
void change(int *q) /* q is a pointer which will point to
the memory location pointed by p */
{
*q = 10;
}
Example 10.15: Function returning pointer

main()
{
int *p ;
int *assign() ; /* function prototype - function returning an
integer pointer */
p = assign() ;
printf(‘’ %d ‘’ , *p) ; /* will print 20 */
}
int *assign()
{
int a , *q = &a;
*q = 20 ;
return q ;
}
Page 85
C3: Protected
Example 10.16: Function receiving pointers and returning pointer

int *big (int * , int *);
main()
{
int a=10, b=20, *p;
p = big (&a, &b); /* address of the variable a or b will be
stored in p */
printf (“%d”,*p);
}
int *big (int *x , int *y)
{
if (*x > *y) return (x); /* addr. of a is returned */
else return (y); /* addr. of b is returned */
}
It is possible to pass a portion of an array, rather than an entire array, to a function using pointers.
Function Pointer
Function will also have a memory address like other variables. So, we can have a pointer variable
to point to the starting location of a function and can execute the function by means of the pointer
variable, which will speeds up the execution.
General Form:
return-type (* function_pointer_name)(argument list..)
Suppose we have a function as,

void add(int x, int y)
{
printf(“Value = %d”, x + y);
}
Pointer to this function is declared as,

void (*p)(int x, int y); ‘p’ is a pointer which can point to a function having two
integer arguments and returning an integer value.
p = add; makes the pointer to point to the function add()
Note: function name specifies the starting address.
(*p)(10,20); will call the function add() with parameters 10,20
Page 86
C3: Protected
Example 10. 17
int display();
int (*func_ptr) ();
func_ptr = display;
(*func_ptr) (); /*invokes the function display */
Example 10.18
main()
{
void abc();
abc();
(*abc)(); /* calling the function by function pointer */
}
void abc()
{
printf(“function”);
}
Output:
functionfunction
Storage Classes
Variables in C can be characterized by their data type and storage classes. Data type refers to the
type of information represented by a variable and storage classes define its life time and scope.
Scope
The scope of the variable (where it can be used), is determined by where it is defined. If it is
defined outside of all the blocks, it has file scope. This means, it may be accessed anywhere in the
current source code file. This is normally called a global variable and is normally defined at the top
of the source code. All other types of variables are local variables. If a variable is defined in a block
(encapsulated with {and}), its scope begins when the variable is defined and ends when it hits the
terminating. This is called block scope.
Life Time
Life time refers to the permanence of a variable – How long the variable will retain its value in
memory.
General Form:
storage-class-specifier type-specifier variable-names,...
The storage-class-specifier can be any one of the following:
auto
static
register
extern
Page 87
C3: Protected
Automatic variables (Auto storage class)

Automatic variables are local (visible) to the block in which they are declared. If the variable is
declared within a function, then its scope is confined to that function. Local variables of different
functions/blocks may have the same name. It retains its value till the control remains in that block.
When the execution of the block is completed, it is cleared and its memory destroyed. Whenever
the control again comes to the same block new memory location will be allocated to those
variables. They are local or private to the function in which they are declared. Because of this
property, they are also called local or internal variables. If not initialized in the declaration
statement, their initial value will be unpredictable (garbage value). If no storage class is specified,
by default it is an auto variable.
Example 10.19
main()
{
int a = 5 ;
{
int a =6 ;
printf (“%d “ , a); prints 6
}
printf(“ %d “ , a); prints 5
}
One important feature of automatic variables is that their value cannot be changed by whatever
happens in some other function in the program. A variable local to the main function will be
normally alive throughout the whole program, although it is active only in main(). In the case
recursive functions, the nested variables are unique auto variables, a situation similar to function
nested auto variables, with identical names.
Static variables (static storage class)

Static variables are also local (visible) to the block in which the variable is declared. They retain
the values throughout the life of the program. Once allocated, memory will be de-allocated after
the completion of the program execution. So, it will retain the value between function calls. If not
initialized in the declaration, it is automatically initialized to zero. Static variables are stored in
memory.
A static variable may be either internal (local) or external (global). Internal variables are those
declared inside a function (or block). The scope is only to the function in which it has been
declared but the variable exists in the memory throughout the entire life of the program .Thus,
internal static variables retain values between function calls.
Page 88
C3: Protected
Example 10.20
main()
{
int i;
for (i=1;i<=5;i++)
incre();
}
incre()
{
static int x = 0;
x = x +1;
printf(“ x = %d\n”,x);
}
Output:
x = 1
x = 2
x = 3
x = 4
Register variables (register storage class)

It is possible to inform the compiler that a variable should be kept in one of the registers, instead of
keeping it in the memory. Since registers are faster than memory, keeping the frequently accessed
variables like a loop control variable in a register will increase the execution speed. Since the
registers are less in numbers, careful selection must be made for their use.
If the declaration of register variable exceeds the availability, they will be automatically converted
into non register variables (automatic variable).
Register variables are local (Visible) to the block in which they declared. It retains its value till the
control remains in that block. If not initialized in the declaration, the variable is initialized to zero.
External variables (extern storage class)

External variables are not confined to a single function. Their scope extends from the point of
definition through the remainder of the program. They are referred to as global variables. Access
to variables outside of their file scope can also be made by using linkage. Linkage is done by
placing the keyword extern prior to a variable declaration. This allows a variable that is defined in
another source code file to be accessed.
External variables can be accessed from any function and the changes done by one function will
be reflected through out the entire scope. When using external variables, we must distinguish
between:
External Variable Definition
External Variable Declaration
If not initialized in the declaration, it is initialized to zero. External variables are useful when
working with multiple source files.
Page 89
C3: Protected
Example 10. 21
int a = 5 ;
/* external variable definition (No need to use extern keyword) */
main()
{
extern int b;
/* external variable declaration, just to say that the
variable is declared somewhere else in the same program or
other programs. */
void fun();
fun();
printf(“ %d “ , a); /* prints 10 */
printf(“ %d “ , b); /* prints 20 */
}
void fun()
{
a = 10 ;
}
int b = 20;
External variable declaration can not have initialization.

extern int a = 10; invalid
Command Line Arguments

Depending on the operating system and programming environment, a C program can be executed
either by selecting an icon from a graphical user interface or by entering a command in a
command window (DOS or UNIX command window). It is usually easier to write programs that are
run by entering a command in a command window.
When a command is entered in a command window, it is executed by a command-line interpreter.

The operation of a command interpreter is quite complex, but as a first approximation, interpreter
breaks up a command into words separated by spaces. The first word is treated as the name of a
program. The interpreter searches for the program and starts it executing with the command words
passed as arguments.
A C program is executed by calling its main() function. The function is called with one integer
argument that indicates how many words are in the command line and another argument that is a
character array of pointers containing the command line words.
Page 90
C3: Protected
main ( int argc, char *argv[])

{
:
}
Where:
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 10.21
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]);
}
When the following command is given in the command prompt,
C:\tc\bin> CMLPGM c cpp java (CMLPGM program name, c cpp java arguments)
The following result is displayed
Number of Arguments = 4
Argument number 0 = CMLPGM
Argument number 1 = c
Argument number 2 = cpp
Argument number 3 = java
Summary
Functions are smaller self-contained components which carry out some specific, well
defined task.
Functions facilitates reusability and brings logical clarity to the programs.
C functions should be considered with three aspects: i) function definition, ii) function
call, iii) function prototyping
Arguments can be passed to a function via call by reference method or by call by value
method.
Arrays can be passed to a function by simply specifying its name.
A function calling itself is called recursion.
C supports four storage class specifiers (auto, static, extern and register) to define
scope and life time for the variable.
The command line arguments, argc and argv are used to pass arguments to main()
function.
Page 91
C3: Protected

1. What is function prototyping?
2. What is relationship between the actual parameters and its formal parameters?

main()
{
int a =4;
{
int a = 3;
printf(“ %d “ , a);
}
printf(“%d” , a);
}
4. What is the difference between call by reference and call by value?

main()
{
int i=10;
fn(i);
printf("%d",i);
}
fn(int i)
{
return ++i;
}
6. What the following declaration statements imply?

a. int p(char *a)
b. int *p(char *a)
c. int (*p)(char a)
d. int *p(char *a[])
7. How main() function is called with parameters?
Page 92
C3: Protected
Answers:
1. Function prototyping is like a function declaration statement which informs the compiler
about the function (its name, type of its arguments, return data type). In C, it is needed
only when the function is called prior to its definition.
2.
a. There must be a one-to-one correspondence between the actual and formal
parameters.
b. Corresponding parameters must be of same type.
3. 3 4
4. In call by reference, address of the actual parameters are passed to corresponding formal
parameters but in call by value, only the values of the actual parameters are copied in to
corresponding formal parameters.
5. 10
6. a) p is a function which receives a character pointer and returns an integer value

b) p is a function which receives a character pointer and returns an integer pointer
c) p is a pointer (function pointer) which can point to any function with character argument
and integer return value.
d) p is a function whose argument is an array of pointers.
7. Using command line arguments.
Page 93
C3: Protected
Session 12: Structures and Unions
Learning Objectives
Appreciate the concept of structures and unions
Define and utilize the advantages of structures and unions
Differentiate structures and unions
Declare enumerated variables
Define new data types using typedef statement
Introduction
Structures and Unions are the main constructs available in C by which programmers can define
new data type. Structures and unions provide a way to group together logically related data items.
Structure
Structure is a derived data type used to represent heterogeneous data items. A structure is an
aggregation of components that can be treated as a single variable. The components are called
Members.
For example, an employee is represented with the following attributes: employee code (string /
integer), employee name (string), department code (string), salary (float).
Declaration
C provides facilities to define structures via a template and to declare a tag to be associated with
such structures so that it is not necessary to repeat the definition. “struct” keyword is used to
define structures.
General form:
struct tag_name
{
type variable-name, variable-name,........;
:
:
};
Page 94
C3: Protected
Structure-variables can be declared separately by specifying:
struct tag_name new-structure-variable;

When declaring structure variables, a separate instance of structure will be created with the name
specified and memory will be allocated for that. Individual members will be given a separate
memory location.
Structure definition and declaration of structure variables can be combined together. Here, tag
name is optional.
Note: If tag name is not specified in the declaration, no extra structures can be created.
Example 12.1
1) struct employee
{
int code;
char name[20];
int dept_code;
float salary;
} ;
struct employee emp1, emp2;
2) struct employee (tag name is optional here)

{
int code;
char name[20];
int dept_code;
float salary;
} emp1, emp2;
Initialization
Structure variables can be initialized at the time of declaration. The format used is quite similar to
initializing an array. If the structure variable is declared before the main function in the global
declaration section, the member variables are automatically initialized to zero or Null depending on
the data type of the member variable. If it is partially initialized, uninitialized members are assigned
zero or Null.
Page 95
C3: Protected
Example 12.2
struct stud
{
int rollnum;
char name[20];
int semester;
float avg;
};
struct stud stud1={101,”Dina”, 1, 90.78}, stud2={102, “Raja”, 1};
For the structure variable ‘stud2’, the ‘avg’ will be initialized to 0.0
Individual structure members can be initialized only via structure variable. No storage class can be
specified for structure members.
struct employee
{
int empno = 101 ; illegal;
static char[20] empname = “AAAA”; illegal;
}
Accessing the members

Members of the structure can be accessed by using the member access operator “.”(dot). If ‘s’ is a
structure variable with a member named ‘m’, then the expression “s.m” refers to the value of the
member ‘m’ within the structure ‘s’.
General Form:
struct_vble . member-field-name
Example 12.3
emp1.code
emp1.name
emp1.dept_code
emp1.salary
emp2.code
emp2.name
Operations on Structures
Two structure variables cannot be compared for equality, even though the values stored in the
member variables are same. This is because, slack bytes are added in-between two member
variables and these slack bytes have garbage value. While comparing structure variables, the
values in slack bytes are also compared, which is always not same for different structure variables.
Assignment operation is allowed. For example, if ‘a’ and ‘b’ are two structure variables of the same
structure type, the assignment expression a = b is valid. It causes each member of ‘a’ to be
assigned the value of the corresponding member of ‘b’.
Page 96
C3: Protected
sizeof() operator can be used to find the size of the structure.
Example 12.4
struct emp
{
int empno;
char name[20];
float basic;
} emp1;
printf (“Size = %d”,sizeof(emp1)); Size = 26
Nested Structure
Just as arrays of arrays, structures can contain members that themselves are structures. This can
be a powerful method to create complex data types.
Note: Member structure must be defined prior to its use.
Example 12.5
struct date
{
int day;
int month;
int year;
};
struct employee
{
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
Page 97
C3: Protected
Structures and Arrays

A structure can be a array of structure and the members of structures can be arrays.
Example 12.6 Array of structures

struct stud
{
int rollnum;
char name[20];
int semester;
int avg;
};
struct stud student[50];
Accessing values:
student [1].rollnum
student [1].name
student [1].semester
student [1].avg
Example 12.7: Arrays within structures

struct student-mark
{
int rollnumber;
char name[15];
int sub_marks[5];
}student;
Accessing values:
student.sub_marks[0] student.sub_mark[1]
Structures and Pointers

Structure variable can be declared as pointers. It will be useful when an entire structure is passed
to a function via call by reference. Pointer declaration to a structure is as follows:
struct student *ptr;
In this declaration, ‘ptr’ is a pointer type variable, which can hold an address of a variable of the
type ‘student’.
Page 98
C3: Protected
Example 12.8
struct stud
{
int rollnum;
char name[20];
int semester;
float avg;
};
struct stud student={101,”raja”, 1, 95.67}, *ptr ;
To make ‘ptr’ to point to the structure ‘student’, we can write as
ptr = &student;
Accessing a member through pointer variable
The notation for referring a member field of a structure pointed by a pointer is as follows:
(*pointer). memberfieldname
(OR)
pointer -> memberfieldname
Example 12.9
printf(“ %d \t %s \t %d \t %f “, ptr->rollnum, ptr->name, ptr->semester,

ptr->avg);
Self-Referential structures
A structure containing a member that is a pointer to the same structure type is called self-
referential structures. It is used to build various kinds of linked data structures.
Example 12.10
struct employee
{
char name[20];
char gender;
float salary;
struct employee *empptr;
};
Page 99
C3: Protected
Structures and Functions

Structures can be passed to a function via call by value and call by reference methods. When the
structure variable (which not a pointer) is passed as an argument to a function, it is passed using
call by value method. All the members are copied into corresponding formal arguments. But
changes will not be reflected back.
Example 12.11
struct emp
{
int empno;
char empname[10];
};
main( )
{
void display(struct emp);
struct emp emp1 = { 101 , “AAAA”} ;
display(emp1);
}
void display(struct emp emp2)

{
printf(“ %d “ , emp2.empno);
printf(“ %s “ , emp2.empname);
}
Entire structure can be passed to a function using call by reference method. We can use pointer to
structures, or we can pass address of the structure variable using & operator.
Example 12.12
struct emp
{
int empno;
char empname[10];
};
void main( )
{
void change(struct emp *);
struct emp emp1 = { 101 , “AAAA”} ;
change(&emp1);
printf(“%d” , emp1->empno); /* prints 102 */
}
void display(struct emp *emp2)
Page 100
C3: Protected
{
emp2->empno=102;
}
Function can return a structure type
struct_name = fun_name (struct_vble_name);
Function should be declared and defined as:
struct tag_name fun_name( struct tag_name struct_vble_name, …)
Example 12.13
emp1 = emp_pay (wage, x, y); wage is a structure variable of sal structure.
emp1 is a structure variable of employee structure.
struct employee emp_pay (struct sal pay, int a, float b) { } function definition
Unions
Union, like a structure, is a derived data type. Unions follow the same syntax as structures. The
programmer is responsible for interpreting the stored values correctly. Union differs from structure
in storage and in initialization.
Declaration
The declaration can be thought of as a template - it creates the type, but no storage is allocated. In
the declaration, keyword ‘union’, the tag name, and the members of the union are given. The tag
name, along with the keyword ‘union’, can be used to declare variables of the union type. For each
variable, the compiler allocates a piece of storage that can accommodate the largest of the
specified members.
General Form:
union tag_name
{
:
:
}union-variable, union-variable...... ;
Page 101
C3: Protected
Initialization
Union can be initialized only with a value for the first union member. No other member can be
initialized.
Example 12.14
union item
{
int m;
float x;
char c;
};
static union item product = {100};
/* m will be initialized with 100 */
Accessing the member of union

The notation used to access a member of a union is identical to that used to access member of a
structure. The dot operator (.) is used to access the members. 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 another occasion. Thus, only one member variable can be accessed at a time.
Union of Structures
Structures and unions can be members of structures and unions.
Example 12.15 Union of Structures

struct employee_type
{
int code;
char name[20];
int dept_code;
float salary;
};
struct stud_type
{
int rollno;
char name[15];
int age;
float avg;
};
Page 102
C3: Protected
union person
{
char surname[10];
struct employee_type e1;
struct stud_type s1;
}ex;
In the above example, the union allows the structure variables, e1 and s1, to share common
memory. 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
Enumeration
Enumeration is a derived data type, similar to structures or a union. Its members are constants that
are written as identifiers, though they have signed integer values. These constants represent
values that can be assigned to corresponding enumeration variables. “enum” keyword is used to
declare enumerated variables.
General Form:
enum tag { member1 , member2 , …… member n } ;
tag is a name that identifies enumerations having this composition and members represent the
identifiers that may be assigned to variables of this type. The member names must differ from one
another.
Enumerated variables can be declared as follows:
storage-class enum tag var1 , var2 , …………… var n;
As structures, definition and variable declaration can be combined.
Example 12.16
enum escapes { bell = `\a', backspace = `\b', tab = `\t’, newline =
`\n', vtab = `\v', return = `\r'}
main()
{
enum escapes e1;
e1 = getch();
if (e1 == newline)
printf("newline");
}
Page 103
C3: Protected
Enumeration variables can be processed in the same manner as other integer variables. As with
arrays, first enumerated name has index value 0, next value is calculated as previous plus one.
We can also override the 0 start value by assigning some other value.
enum colors { red = 1 , blue = 5 , green }
Here, green takes the value 6.
Typedef Statement
The ‘typedef’ allows users to define new data types that are equivalent to existing data types. It is
used to give new names to existing data types.
General Form
typedef datatype new-type;
Example 12.17
typedef numbers int;
numbers is the new name given to integer data type and it can be used to declare integer
variables.
numbers n1, n2 ; n1 , n2 are the integer variables.
typedef is mostly useful with structures and unions.
Example 12.18
typedef struct
{
int empno;
char empname[10];
}employee;
employee is the name given to the structure of the above type. Then structure variables can be
declared as follows,
employee emp1, emp2; no need to use struct keyword.
Page 104
C3: Protected
Summary
Structure is a derived data type used to store heterogeneous data items under a single
unit.
Structure members can be accessed by structure variables using dot ( . ) operator.
Structures can be nested and can also have self reference.
Structure can be passed to a function by both call by value approach and call by
reference approach.
Unions are similar to structures but the main difference is that union members share
the common memory location whereas memory is allocated to individual structure
members.
In unions, only one member is accessible at a time.
enum keyword is used to define enumerations.
typedef statement is used to define new data types which are compatible with existing
ones.

1. What distinguishes an array from a structure?
2. What is a self referential structure and where can it be used?
3. Consider the following structure,

struct
{
int a;
int *p;
}*p1;
How can the content pointed by member pointer p be accessed via structure variable p1?
4. What will be the result when the following code is executed?

struct stud_type
{
int rollno;
char name[15];
int age;
};
union person
{
char surname[10];
struct stud_type s1;
}ex;
printf(“Size = %d”, sizeof (ex));
Page 105
C3: Protected
Answers:
1. The elements of an array are always of the same type, whereas the members of a
structure can be of different types.
2. Self referential structures will contain a member that is a pointer to the parent structure
type. It is very useful in applications that involve linked data structures.
3. *p1->p;
4. Size = 19
Page 106
C3: Protected
Session 14: Files and Preprocessors
Learning Objectives
This session will enable you to:
Explain the concept of file and its types
Know the basic file operations
Perform formatted, unformatted and block file I/O operations
Access files in both sequential and random order
Make use of pre-processor directives
Introduction
When a large volume of data is involved, supplying data through the keyboard during the
execution or displaying the output on the screen is not convenient. The input data can be stored on
disks and the program may access the data from disks for processing. Similarly, the results may
be stored on disks. For such applications, files are needed. A file is a place on the disk where a
group of related data is stored. In C, file manipulations may be done in two ways:
Low-level I/O using system calls
High-level I/O using functions from standard I/O library
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.
Streams and Files

Streams facilitate a way to create a level of abstraction between the program and an input/output
device. This allows a common method of sending and receiving data amongst the various types of
devices available. There are two types of streams: text and binary.
Text streams are composed of a set of lines. Each line has zero or more characters and is
terminated by a new line character. Text streams consist of printable characters, the tab character,
and the new-line character. Conversions may occur on text streams during input and output.
Spaces cannot appear before a newline character, a text stream removes these spaces even
though implementation defines it. A text stream, on some systems, may be able to handle lines of
up to 254 characters long (including the terminating new line character).
Binary streams are composed of only 0’s and 1’s. It is simply a long series of 0’s and 1’s. More
generally, there need not be a one-to-one mapping between characters in the original file and the
characters read from or written to a text stream. But in the binary stream there will be one-to-one
mapping because no conversion exists, and all characters will be transferred as such.
Page 107
C3: Protected
When a program begins, there are three available streams:

Standard input (stdin) is the stream where a program gets its input data
Standard output (stdout) is the stream where a program writes its output data.
Standard error (stderr) is another output stream typically used by programs to output
error messages.
File Operations
Files are associated with streams and must be open in order to use it. The point of I/O within a file
is determined by the file position. When a file is opened, the file position points to the beginning of
the file unless the file is opened for an append operation - in which case the position points to the
end of the file. The file position indicates where the next operation (read/write) will occur.
When a file is closed, no more actions can be taken on it until it is opened again. Exiting from the
main function causes all open files to be closed.
In C, ‘FILE’ is a structure that holds the description of a file and is defined in stdio.h.
Basic File operations are:

Opening a File
Reading from and/or writing into a File
Closing the File
The logic is, the code must:

define a local ‘pointer’ of type FILE ( called file pointer )
‘open’ the file and associate it with the file pointer via fopen()
perform the I/O operations using file I/O functions ( ex. fscanf() and fprintf() )
disconnect the file from the task using fclose()
Page 108
C3: Protected
General form:
FILE *fp;
fp = fopen(“name”, “mode”);
fscanf(fp, "format string", variable list);
fprintf(fp, "format string", variable list);
fclose(fp );
Where:
The ‘fp’ is a file pointer or file handler.
The ‘name’ is to represent filename and it is a string of characters. (Extensions can be
specified like test.c, details.dat etc)
The ‘mode’ argument in the fopen() specifies, the purpose/positioning of opening the
file. It is a string enclosed within double quotes.
The ‘mode’ can be any of the following:
r read text mode
w write text mode (truncates file to zero length if it already exits or creates new file)
a append text mode for writing (opens or creates file and sets file pointer to the end-of-file)
rb read binary mode
wb write binary mode (truncates file to zero length if it already exits or creates new file)
ab append binary mode for writing (opens or creates file and sets file pointer to the end-of-file)
r+ read and write text mode
w+ read and write text mode (truncates file to zero length if it already exists or creates new file)
a+ read and write text mode (opens or creates file and sets file pointer to the end-of-file)
r+b or
read and write binary mode
rb+
w+b or read and write binary mode (truncates file to zero length if it already exists or creates new
wb+ file)
a+b or
read and write binary mode (opens or creates file and sets file pointer to the end-of-file)
ab+
Page 109
C3: Protected
If the file does not exist and it is opened with read mode (r), the file open fails and it will return
NULL to file pointer.
If the file is opened with append mode (a), all write operations occur at the end of the file
regardless of the current file position.
If the file is opened in the update mode (+), output cannot be directly followed by input and input
cannot be directly followed by output without an intervening fseek(), fsetpos(), rewind(), or fflush().
fopen() returns the file pointer position for successful open and returns NULL, if the file does not
open or the file does not exist.
fclose() returns zero for successful close and returns EOF (end of file) when error is encountered
in closing a file. By default, all the files opened are closed when the program is terminated. It is
good to close all the files opened with fopen(), because files can be reopened only if they are
closed.
The Standard I/O 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
Integer I/O
Character I/O
Using character I/O, one character (byte) can be written to or read from a file at a time.
Writing in to a file
To write into a file, the file must be opened in ‘w’ mode The function putc() is used to write a byte
to a file.
General Form:
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, monitor as a file. On success, the character is
returned. If an error occurs, the error indicator for the stream is set and EOF is returned.
Page 110
C3: Protected
Example 14.1: Program to create a text file (character file)

main()
{
FILE *fp;
char c;
if ((fp=fopen(“sample.dat”,”w”)) !=NULL)
{
while ((c=getchar()) != EOF)
putc(c,fp);
fclose(fp);
}
else
printf(“Error in opening a file”);
}
Reading from a file

The function getc() is used to read a byte from a file. This may be a macro version of fgetc.
General Form:
ch =getc (fptr);
This function reads a character from the file and it is returned to the program defined character
variable. After the reading a character, the pointer is moved to the next position. The fptr may be
stdin, which represents a standard input device, keyboard as a file. On success, the character is
returned. If the end-of-file is encountered, EOF is returned and the end-of-file indicator is set. If an
error occurs, the error indicator for the stream is set and EOF is returned. The EOF is end of file
status flag, which is true if end of file is reached, otherwise false.
Example 14.2: Program to read a character data from a text file

main()
{
FILE *fp;
char c;
if ((fp=fopen(“sample.dat”,”r”)) !=NULL)
{
while ((c=getc(fp)) != EOF)
putchar(c);
fclose(fp);
}
else
printf(“Error in opening a file”);
}
Page 111
C3: Protected
String I/O
Using string I/O, string can be written to, or read from, a file at a time.
Writing a string in to a file

The function used is fputs(). Writes a string to the specified stream till the last character is read but
does not include the null character. On success, a nonnegative value is returned. On error, EOF is
returned.
General Form:
fputs (str, fptr);
Reading a string from a file

The function used is fgets(). Reads a line from the specified stream and stores it into the string
pointed to by str. It stops when (n-1) characters are read, the newline character is read, or the end-
of-file is reached, whichever comes first. The newline character is copied to the string. A null
character is appended to the end of the string. On success, a pointer to the string is returned. On
error, a null pointer is returned. If the end-of-file occurs before any characters have been read, the
string remains unchanged.
General Form:
fgets(str,n,fptr);
Numeric I/O
Using numeric I/O, integers can be written to, or read from, a file at a time.
Writing integer in to a file

The function used is putw(). This function writes an integer to a file. On success, a nonnegative
value is returned. On error, EOF is returned.
General Form:
putw (i, fptr);
Reading integer from a file

The function used is getw(). Reads an integer from the file and assigns it to the program defined
numeric variable at the LHS.
General Form:
i = getw( fptr);
Page 112
C3: Protected
Formatted I/O
The formatted I/O functions can handle a group of data in a single call.
Writing formatted data to a file

The function fprintf() is used. This function will write the values stored in the variables into a file
pointed by fptr, according to the format specifier specified in format string. On success, the number
of characters printed is returned. If an error occurred, -1 is returned.
General Form:
fprintf ( fptr, format-string, variable-list);
The fprintf() function takes the format string specified by the format argument and applies each
following argument to the format specifiers in the string, in a left to right fashion. Each character in
the format string is copied to the stream except for conversion characters which specify a format
specifier.
Reading formatted data from the file

The function used is fscanf().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. Reading an input field (designated with a conversion specifier) ends
when an incompatible character is met, or the width field is satisfied. On success, the number of
input fields converted and stored is returned. If an input failure occurs, EOF is returned.
General Form:
fscanf( fptr, format-string, addresses-list);
The fscanf() function takes input in a manner that is specified by the format argument and stores
each input field into the corresponding arguments, in a left to right fashion.
Each input field is specified in the format string with a conversion specifier which specifies how the
input is to be stored in the appropriate variable. Other characters in the format string specify
characters that must be matched from the input, but are not stored in any of the following
arguments. If the input does not match, the function stops scanning and returns. A white space
character may match with any white space character such as space, tab, carriage return, new line,
vertical tab, or form feed, or the next incompatible character.
Page 113
C3: Protected
Example 14.3: Program using fscanf() and fprintf()

main()
{
FILE *fpt;
struct
{
int no;
char name[10];
int age;
}std[10], std1[10];
int i;
clrscr();
fpt = fopen("details.dat" , "w");
printf("\n\n enter the details (no , name , age )\n\n");
for(i=0; i<5 ;i++)
{
scanf("%d %s %d " , &std[i].no , std[i].name , &std[i].age);
fprintf(fpt , "%d %s %d " , std[i].no , std[i].name ,
std[i].age);
}
fclose(fpt);
fpt = fopen("details.dat" , "r");
printf("\n\n reading from file \n\n");
while(!feof(fpt))
{
fscanf(fpt , "%d %s %d " , &std1[i].no , std1[i].name
,&std1[i].age);
printf("%d %s %d \n" , std1[i].no , std1[i].name ,
std1[i].age);
i++;
}
}
Block I/O
Block I/O is used to read or write a specified number of bytes. The data handled by block
input/output function will be in ‘raw data format’ (i.e. bytes of data).
Writing in to a file
The function used is fwrite().Transfers a specified number of bytes beginning at a specified
location in memory to a file. Used to write a structure or an array of structures to an output file. The
function writes data from the array pointed to by ptr to the given stream. It writes ‘n’ blocks of size
‘size’. The total number of bytes written is (size*n). On success the number of elements written is
returned. On error the total number of elements successfully written (which may be zero) is
returned.
Page 114
C3: Protected
General Form
fwrite (ptr, size, n, fp);
Where:
ptr pointer to the data block (source)
size size of each block (number of bytes to be written)
n number of blocks to be written
fp file pointer (destination)
Reading from a file

The function used is fread(). Reads data from the given stream into the variable pointed to by ptr. It
reads ‘n’ number of elements of size ‘size’. The total number of bytes read is (size*n). On success
the number of elements read is returned. On error or end-of-file, the total number of elements
successfully read (which may be zero) is returned.
General Form
fread (&str, size, n, fp);
Where:
&str destination memory address
size size of each block (number of bytes to be read)
n number of blocks to be read
fp file pointer (source)
Example 14.4: Program using Block I/O
main()
{
FILE *fptr;
struct tag
{
char name[10];
int age ;
}stud[10] , stud1[10];
int i ;
clrscr();
fptr=fopen("ex.dat" , "w" );
for(i=0 ; i<5 ; i++)
scanf("%s %d ",stud[i].name , &stud[i].age);
fwrite(&stud , sizeof(stud[0]) , 5 , fptr);
fclose(fptr);
fptr = fopen("ex.dat" , "r" );
fread(&stud1 , sizeof(stud1[0]) , 5 , fptr);
printf(" \n\n printing the values ");
for(i=0 ; i<5 ; i++)
printf("\n %s \t %d " , stud1[i].name , stud1[i].age);
}
Page 115
C3: Protected
Random File Operations

The functions discussed earlier are to be used for reading and writing data sequentially. In some
applications, it may be necessary to access some part of the file directly. This can be achieved by
using the functions fseek(), ftell() and rewind().
ftell()
This function takes a file pointer and returns a long int, which corresponds to the current file pointer
position. If it is a binary stream, then the value is the number of bytes from the beginning of the file.
If it is a text stream, then the value is a value usable by the fseek() function to return the file
position to the current position. On success, the current file position is returned. On error, the value
-1L is returned and error number (errno) is set.
General Form:
n = ftell(fptr);
fseek()
This function sets the file position to the given offset (specified in long integer format).
General Form:
fseek( fptr, offset, from_where)
The argument offset signifies the number of bytes to seek from the given ‘from_where’ position.
The argument from_where can be:
Seeks from the beginning of the 0

SEEK_SET
file.
SEEK_CUR Seeks from the current position. 1
SEEK_END Seeks from the end of the file. 2
On a text stream, from_where should be SEEK_SET and offset should be either zero or a value
returned from ftell(). The end-of-file indicator is reset. The error indicator is NOT reset. On
success, zero is returned. On error, a nonzero value is returned.
Example 14.3
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.
Page 116
C3: Protected
rewind()
This function sets the file position to the beginning of the file of the given stream. The error and
end-of-file indicators are reset.
General Form:
rewind(fptr);
Preprocessor Directives
One of C's most useful features is its preprocessor. Preprocessor directives are lines included in
the code that are not program statements but directives for the preprocessor. These lines are
always preceded by a pound sign (#). The preprocessor is executed before the actual compilation
of code begins, therefore the preprocessor digests all these directives before any executable code
is generated for the statements.
Preprocessing is a step that takes place before compilation that lets you to:
Replace preprocessor tokens in the current file with specified replacement tokens.
Embed files within the current file
Conditionally compile sections of the current file
Generate diagnostic messages
Remove the blank lines in the program, change the line number of the next line of
source and change the file name of the current file.
Remove comments from the source file.
A token is a series of characters delimited by white space. The white space allowed on a
preprocessor directive may be the space, horizontal tab, vertical tab, form feed, or carriage return.
The preprocessed source program file must be a valid C program.
Preprocessor directives begin with the # token followed by a preprocessor keyword. The # token
must appear as a first character. The # is not part of the directive name and can be separated from
the name with white spaces.
A preprocessor directive ends at the new-line character unless the last character of the line is the \
(backslash) character. If the \ character appears as the last character in the preprocessor line, the
preprocessor interprets the \ and the new-line character as a continuation marker. The
preprocessor deletes the \ (and the following new-line character) and splices the physical source
lines into continuous logical lines. No semicolon (;) is expected at the end of a preprocessor
directive.
Page 117
C3: Protected
Except for some #pragma directives, preprocessor directives can appear anywhere in a program.
Preprocessor Directives
Name Action
# Null directive specifying that no action be performed.
#define Defines a preprocessor macro.
#elif Conditionally includes source text if the previous #if, #ifdef, #ifndef, or #elif test fails.
#else Conditionally includes source text if the previous #if, #ifdef, #ifndef, or #elif test fails.
#endif Ends conditional text.
#error Defines text for a compile-time error message.
Conditionally includes or suppresses portions of source code, depending on the result

#if
of a constant expression.
#ifdef Conditionally includes source text if a macro name is defined.
#ifndef Conditionally includes source text if a macro name is not defined.
#include Inserts text from another source file.
#line Supplies a line number for compiler messages.
#pragma Specifies implementation-defined instructions to the compiler.
#undef Removes a preprocessor macro definition.
Preprocessing Operations:
Pre processing operations are mainly classifieds into 1) File Inclusion, 2) Macro substitution and 3)
Conditional Compilation.
Preprocessing will be done before compilation, compilation process operates on the preprocessor
output, which is then syntactically and semantically analyzed and translated, and then linked as
necessary with other programs and libraries.
File Inclusion
Page 118
C3: Protected
The #include directive allows external files to be added in to our source file, and then processed
by the compiler.
General Form:
#include <header file> OR #include “header file”
The only difference between both expressions is the places (directories) where the compiler is
going to look for the included file.
If the file name is enclosed between angle-brackets <>, the file is searched in the directories where
the compiler is configured to look for the standard header files. Therefore, standard header files
are usually included in angle-brackets, while other user specificed header files are included using
quotes.
In the second case where the file name is specified between double-quotes, the file is searched
first in the current working directory. In case that it is not there, the compiler searches the file in the
default directories where it is configured to look for the standard header files.
Example 14.4
#include <stdio.h>
#include “stdio.h”
Preprocessor Macros:
#define preprocessor directive is used to define a macro that assigns a value to an identifier. The
preprocessor replaces subsequent occurrences of that identifier with its assigned value until the
identifier is undefined with the #undef preprocessor directive, or until the end of the program
source is reached, whichever comes first.
There are two basic types of macro definitions that you can use to assign a value to an identifer:
Object-like Macros Replaces a single identifier with a specified token or constant value.
(Symbolic constants)
Function-like Macros Associates a user-defined function and argument list to an identifier.

When the preprocessor encounters that identifier in the program source,
the defined function is inserted in place of the identifier along with any
corresponding arguments.
Symbolic Constants
The preprocessing directives #define and #undef allow the definition of identifiers which hold a
certain value. These identifiers can simply be constants or a macro function.
Page 119
C3: Protected
#define
General Form:
#define symbolicvaraiablename value
Example 8.5
#define SIZE 10
#define NAME “xyz” /* good practice is to use upper case
letters */
#undef:
General Form:
#undef variablename
Example 14.6
#undef SIZE
Macros:
General Form:
#define macroname(argument list) macrodefn
Example:
#define sqarea(a) ((a)*(a))
main()
{
areaofsquare=sqarea(a);
…..
}
Arguments in the macro definition are enclosed with parenthesis to avoid miscalculation.
Continuation character for macro definition is \. There is no need for semicolon after the macro
definition.
Page 120
C3: Protected
Example 14.7
#define sqarea(a) ((a)*(a))
#define sqa(b) b*b
#define add(a,b) ((a)+(b));
main()
{
areaofsquare=sqarea(a); /* areaofsquare = (a) * (a); */
areaofsquare=sqarea(3); /* areaofsquare = (3) *(3); */
areaofsquare=sqarea(3+4); /* areaofsquare=(3+4)*(3+4); */
areaofsquare=sqa(3+4); /* areaofsquare=3+4*3+4; (1) */
addition=add(2,3); /* addition=(2)+(3);; (2) */
}
(1) miscalculation because of no parentheses
(2) two semicolons in macro expansion.
Conditional Compilation Directives:

A preprocessor conditional compilation directive causes the preprocessor to conditionally suppress
the compilation of portions of source code. These directives test a constant expression or an
identifier to determine which tokens the preprocessor should pass on to the compiler and which
tokens should be bypassed during preprocessing. The directives are:
#if
#ifdef
#ifndef
#else
#elif
#endif
The directives #ifdef and #ifndef allow conditional compiling of certain lines of code based on
whether or not an identifier has been defined. For each #if, #ifdef, and #ifndef directive, there are
zero or more #elif directives, zero or one #else directive, and one matching #endif directive. All the
matching directives are considered to be at the same nesting level.
General Form:
#if constant_expression
#else
#endif
OR
#if constant_expression
#elif constant_expression
#endif
The compiler only compiles the code after the #if expression if the constant_expression evaluates
to a non-zero value (true). If the value is 0 (false), then the compiler skips the lines until the next
Page 121
C3: Protected
#else, #elif, or #endif. If there is a matching #else, and the constant_expression evaluated to 0
(false), then the lines between the #else and the #endif are compiled. If there is a matching #elif,
and the preceding #if evaluated to false, then the constant_expression after that is evaluated and
the code between the #elif and the #endif is compiled only if this expression evaluates to a non-
zero value (true).
Example 14.8
Check whether a variable is defined. If so, change the value of that variable to 1 after undefining it.
#if define(NUMBER)
#undef NUMBER
#define NUMBER 1
#endif
# and ## operators
# causes the argument to be converted as a string enclosed within quotes.
Example 14.9
#define name(x) #x
main()
{
…..
printf(name(xyz)); /* printf(“xyz”); */
….
}
## concatenation operator
Example 14.10
#define name(x,y) x##y
main()
{
…..
printf(name(ssn,somca)); /* printf(“ssnsomca”); */
….
}
Page 122
C3: Protected
Summary
Files are used to store bulk of related information in secondary storage.
Files can be classified as system oriented and stream oriented files.
fopen(), fclose() functions are used for opening and closing of files.
Input, Output operations on files can be of character I/O, string I/O, formatted I/O and
block I/O.
Direct access of a file is supported by fseek(), ftell(), and rewind() functions.
Preproccessing is done before compilation.
Preprocessor directives are identified by # symbol.
Preprocessor directives perform i) macro substitution, ii) file inclusion and iii)
conditional compilation.

1. What are the three files automatically associated with every C program?

int main()
{
while(i<10)
{
fprintf(stdout,"hello-out");
sleep(1);
i++;
}
return 0;
}
3. What is EOF, and what value does it usually have?
4. What does the following statement specifies?

fseek( fptr , 2L , 2)
Page 123
C3: Protected

#define a 10
foo( )
{
#undef a
# define a 50
}
main( )
{
printf(“%d..”, a);
foo( );
printf(“%d”,a );
}
Answers:
1. stdin, stdout, stderr
2. It will print hello-out in the monitor 10 times.
3. EOF is a constant returned by many I/O functions to indicate that the end of an input file
has been reached. Its value on most computers is -1.
4. No significance, trying to move file pointer in the forward direction from the end of file.
5. 50 50
Page 124
C3: Protected
Syntax Summary
Program Structure/Functions
type fnc(type1,: : : ) function declarations
type name external variable declarations
main() { main routine
declarations local variable declarations
statements
}
type fnc(arg1,: : : ) { function definition

declarations local variable declarations
statements
return value;
}
/* */ comments
main(int argc, char *argv[]) main with args
exit(arg) terminate execution
C Preprocessor
#include <filename> include library file
#include "filename" include user file
#define name text replacement text
#define name(var) text replacement macro
Example. #define max(A,B) ((A)>(B) ? (A) : (B))
#undef name undefine
# quoted string in replace
## concatenate args and rescan
#if, #else, #elif, #endif conditional execution
#ifdef, #ifndef is name defined, not defined?
name defined? defined(name)
line continuation char \
Page 125
C3: Protected
Data Types/Declarations
character (1 byte) char
integer int
float (single precision) float
float (double precision) double
short (16 bit integer) short
long (32 bit integer) long
positive and negative signed
only positive unsigned
pointer to int, float *int, *float
enumeration constant enum
constant (unchanging) value const
declare external variable extern
register variable register
local to source file static
no value void
structure struct
create name by data type t typedef typename
size of an object (type is size_t) sizeof object
size of a data type (type is size_t) sizeof(type name)
Initialization
initialize variable type name=value
initialize array type name[]={value1,: : : }
initialize char string char name[]="string"
Constants
long (suffix) L or l
float (suffix) F or f
exponential form e
octal (prefix zero) 0
hexadecimal (prefix zero-ex) 0x or 0X
character constant (char, octal, hex) ‘a’, ‘\ooo’, ‘\xhh’
newline, cr, tab, backspace \n, \r, \t, \b
special characters \\, \?, \, \"
string constant (ends with \0) "abc: : : de"
Page 126
C3: Protected
Pointers, Arrays & Structures

declare pointer to type type *name
declare function returning pointer to type type *f()
declare pointer to function returning type type (*pf)()
generic pointer type void *
null pointer NULL
object pointed to by pointer *pointer
address of object name &name
array name[dim]
multi-dim array name[dim1][dim2]….
Structures
struct tag { structure template
declarations declaration of members
};
struct tag name create structure

name.member member of structure from template
pointer -> member Ex. (*p).x and p->x are the member of pointed to structure
same
union single value, multiple type structure
member : b bit field with b bits
Operators (grouped by precedence)

structure member operator name.member
structure pointer pointer->member
increment, decrement ++, --
plus, minus, logical not, bitwise not +, -, !, ~
indirection via pointer, address of object *pointer, &name
cast expression to type (type) expr
size of an object sizeof
multiply, divide, modulus (remainder) *, /, %
add, subtract +, -
left, right shift [bit ops] <<, >>
comparisons >, >=, <, <=
comparisons ==, !=
bitwise and &
bitwise exclusive or ^
bitwise or (incl) |
logical and &&
Page 127
C3: Protected
logical or ||
conditional expression expr1 ? expr2 : expr3
assignment operators +=, -=, *=, ……
expression evaluation separator ,
Unary operators, conditional expression and assignment operators group right to left; all others
group left to right.
Flow of Control
Statement terminator ;
Block delimiters {}
Exit from switch, while, do, for break
Next iteration of while, do, for continue
go to goto label
Label label:
Return value from function return expr
Flow Constructions
if statement if (expr) statement
else if (expr) statement
else statement
while statement while (expr)
statement
for statement for (expr 1; expr2; expr3)
statement
do statement do statement
while(expr );
switch statement switch (expr) {
case const1: statement1 break;
case const2: statement2 break;
default: statement
}
ANSI Standard Libraries

<assert.h> <ctype.h> <errno.h> <float.h> <limits.h>
<locale.h> <math.h> <setjmp.h> <signal.h> <stdarg.h>
<stddef.h> <stdio.h> <stdlib.h> <string.h> <time.h>
Page 128
C3: Protected
Character Class Tests <ctype.h>

Functions Functionalities
isalnum(c) Checks whether c is alphanumeric
isalpha(c) Checks whether c is alphabetic
iscntrl(c) Checks whether c is a control character
isdigit(c) Checks whether c is a decimal digit
isgraph(c) Checks whether c is a printing character (not incl space)
islower(c) Checks whether c is a lower case letter
isprint(c) Checks whether c is a printing character (incl space)
ispunct(c) Checks whether c is a printing char except space, letter,
digit
isspace(c) Checks whether c is a Space, form feed, newline, cr, tab,
vtab
isupper(c) Checks whether c is a upper case letter
isxdigit(c) Checks whether c is a hexadecimal digit
tolower(c) Convert c to lower case
toupper(c) Convert c to upper case
String Operations <string.h>
Consider s, t are strings and cs, ct are constant strings

Functions Functionalities
strlen(s) Returns the length of s
strcpy(s,ct) Copies ct to s
strncpy(s,ct,n) Copies up to n chars to s
strcat(s,ct) Concatenate ct after s
strncat(s,ct,n) Concatenate up to n chars
strcmp(cs,ct) Compares cs to ct
strncmp(cs,ct,n) Compares only first n chars
strchr(cs,c) Pointer to first c in cs
strrchr(cs,c) Pointer to last c in cs
memcpy(s,ct,n) Copy n chars from ct to s
memmove(s,ct,n) Copy n chars from ct to s (may overlap)
memcmp(cs,ct,n) Compare n chars of cs with ct
memchr(cs,c,n) Pointer to first c in first n chars of cs
memset(s,c,n) Put c into first n chars of cs
Page 129
C3: Protected
Input/Output <stdio.h>
Standard I/O
Standard input stream stdin
Standard output stream stdout
Standard error stream stderr
End of file EOF
Get a character getchar()
Print a character putchar(chr )
Print formatted data printf("format ",arg 1,..)
Print to string s sprintf(s,"format ",arg 1,… )
Read formatted data scanf("format ",&name1,… )
Read from string s sscanf(s,"format ",&name1,…. )
Read line to string s (< max chars) gets(s,max)
Print string s puts(s)
File I/O
Declare file pointer FILE *fp
Pointer to named file fopen("name","mode")
Where modes: r (read), w (write), a (append)
Get a character getc(fp)
Write a character putc(chr ,fp)
Write to file fprintf(fp,"format",arg 1,: : : )
Read from file fscanf(fp,"format",arg 1,: : : )
Close file fclose(fp)
Non-zero if error ferror(fp)
Non-zero if EOF feof(fp)
Read line to string s (< max chars) fgets(s,max,fp)
Write string s fputs(s,fp)
Page 130
C3: Protected
Codes for Formatted I/O: "%-+ 0w:pmc"

- left justify
+ print with sign
Space print space if no sign
0 pad with leading zeros
w min field width
p precision
m conversion character:
h short, l long, L long double
c conversion character:
d,i integer
u unsigned
c single char
s char string
f double
e,E exponential
o octal
x,X hexadecimal
p pointer
n number of chars written
g,G same as f or e,E depending on exponent
Standard Utility Functions <stdlib.h>

Function Type Functions
Absolute value of int n abs(n)
Absolute value of long n labs(n)
Quotient and remainder of ints n,d div(n,d) returns structure with div_t.quot and
div_t.rem
Quotient and remainder of longs n,d ldiv(n,d) returns structure with ldiv_t.quot and
ldiv_t.rem
Pseudo-random integer [0,RAND_MAX] rand()
Set random seed to n srand(n)
Terminate program execution exit(status)
Pass string s to system for execution system(s)
Page 131
C3: Protected
Conversions
Convert string s to double atof(s)
Convert string s to integer atoi(s)
Convert string s to long atol(s)
Convert prefix of s to double strtod(s,endp)
Convert prefix of s (base b) to long strtol(s,endp,b)
Convert prefix of s (base b) to unsigned long strtoul(s,endp,b)
Storage Allocation
Allocate storage malloc(size), calloc(nobj,size)
Change size of object realloc(pts,size)
Deal locate space free(ptr)
Mathematical Functions <math.h>

Arguments and returned values are double
Trig functions sin(x), cos(x), tan(x)
Inverse trig functions a sin(x), acos(x), atan(x)
Arctan (y/x) atan2(y,x)
Hyperbolic trig functions sinh(x), cosh(x), tanh(x)
Exponentials and logs exp(x), log(x), log10(x)
Exponentials and logs (2 power) ldexp(x,n), frexp(x,*e)
Division and remainder modf(x,*ip), fmod(x,y)
Powers pow(x,y), sqrt(x)
Rounding ceil(x), floor(x), fabs(x)
Page 132
C3: Protected
Conversion Specifier for ‘printf’ statement

A conversion specifier begins with the % character. After the % character come the following in
this order:
[flags] Control the conversion (optional).
[width] Defines the number of characters to print (optional).
[.precision] Defines the amount of precision to print for a number type (optional).
[modifier] Overrides the size (type) of the argument (optional).
[type] The type of conversion to be applied (required).
Flags:
- Value is left justified (default is right justified). Overrides the 0 flag.
+ Forces the sign (+ or -) to always be shown. Default is to just show the - sign. Overrides the
space flag.
space Causes a positive value to display a space for the sign. Negative values still show the -
sign.
# Alternate form:
Conversion Character Result
o Precision is increased to make the first digit a zero.
X or x Nonzero value will have 0x or 0X prefixed to it.
E, e, f, g, or G Result will always have a decimal point.
G or g Trailing zeros will not be removed.
0 For d, i, o, u, x, X, e, E, f, g, and G leading zeros are used to pad the field width instead of
spaces. This is useful only with a width specifier. Precision overrides this flag.
Width:
The width of the field is specified here with a decimal value. If the value is not large enough to fill
the width, then the rest of the field is padded with spaces (unless the 0 flag is specified). If the
value overflows the width of the field, then the field is expanded to fit the value. If a * is used in
place of the width specifer, then the next argument (which must be an int type) specifies the width
of the field. Note: when using the * with the width and/or precision specifier, the width argument
comes first, then the precision argument, then the value to be converted.
Page 133
C3: Protected
Precision:
The precision begins with a dot (.) to distinguish itself from the width specifier. The precision can
be given as a decimal value or as an asterisk (*). If a * is used, then the next argument (which is of
an int type) specifies the precision. Note: when using the * with the width and/or precision specifier,
the width argument comes first, then the precision argument, then the value to be converted.
Precision does not affect the c type.
Result
[.precision]
(none) Default precision values:

1 for d, i, o, u, x, X types. The minimum number of digits to appear.
6 for f, e, E types. Specifies the number of digits after the decimal point.
For g or G types all significant digits are shown.
For s type all characters in string are print up to but not including the null character.
. or .0 For d, i, o, u, x, X types the default precision value is used unless the value is zero in
which case no characters are printed.
For f, e, E types no decimal point character or digits are printed.
For g or G types the precision is assumed to be 1.
.n For d, i, o, u, x, X types then at least n digits are printed (padding with zeros if
necessary).
For f, e, E types specifies the number of digits after the decimal point.
For g or G types specifies the number of significant digits to print.
For s type specifies the maximum number of characters to print.
Modifier:
A modifier changes the way a conversion specifier type is interpreted.
[modifier] [type] Effect
h d, i, o, u, x, X Value is first converted to a short int or unsigned short i nt.
h n Specifies that the pointer points to a short int.
l d, i, o, u, x, X Value is first converted to a long int or unsigned long int .
l n Specifies that the pointer points to a long int.
L e, E, f, g, G Value is first converted to a long double.
Page 134
C3: Protected
Conversion specifier type:

The conversion specifier specifies what type the argument is to be treated as.
[type] Output
d, i Type signed int.
o Type unsigned int printed in octal.
u Type unsigned int printed in decimal.
x Type unsigned int printed in hexadecimal as dddd using a, b, c, d, e, f.
X Type unsigned int printed in hexadecimal as dddd using A, B, C, D, E, F.
f Type double printed as [-]ddd.ddd.
e, E Type double printed as [-]d.dddeñdd where there is one digit printed before the decimal
(zero only if the value is zero). The exponent contains at least two digits. If type is E then
the exponent is printed with a capital E.
g, G Type double printed as type e or E if the exponent is less than -4 or greater than or equal to
the precision. Otherwise printed as type f. Trailing zeros are removed. Decimal point
character appears only if there is a nonzero decimal digit.
c Type char. Single character is printed.
s Type pointer to array. String is printed according to precision (no precision prints entire
string).
p Prints the value of a pointer (the memory location it holds).
n The argument must be a pointer to an int. Stores the number of characters printed thus far
in the int. No characters are printed.
% A % sign is printed.
Conversion specifier for ‘fscanf()’

An input field is specified with a conversion specifier which begins with the % character. After the
% character come the following in this order:
[*] Assignment suppressor (optional).
[width] Defines the maximum number of characters to read (optional).
[modifier] Overrides the size (type) of the argument (optional).
[type] The type of conversion to be applied (required).
Page 135
C3: Protected
Assignment suppressor:
Causes the input field to be scanned but not stored in a variable.
Width:
The maximum width of the field is specified here with a decimal value. If the input is smaller than
the width specifier (i.e. it reaches a nonconvertible character), then what was read thus far is
converted and stored in the variable.
Modifier:
A modifier changes the way a conversion specifier type is interpreted.
[modifier] [type] Effect
h d, i, o, u, x The argument is a short int or unsigned short int.< /td>
h n Specifies that the pointer points to a short int.
l d, i, o, u, x The argument is a long int or unsigned long int .
l n Specifies that the pointer points to a long int.
l e, f, g The argument is a double.
L e, f, g The argument is a long double.
Conversion specifier type:

The conversion specifier specifies what type the argument is. It also controls what a valid
convertible character is (what kind of characters it can read so it can convert to something
compatible).
[type] Input
d Type signed int represented in base 10. Digits 0 through 9 and the sign (+ or -).
i Type signed int. The base (radix) is dependent on the first two characters. If the first
character is a digit from 1 to 9, then it is base 10. If the first digit is a zero and the second
digit is a digit from 1 to 7, then it is base 8 (octal). If the first digit is a zero and the second
character is an x or X, then it is base 16 (hexadecimal).
o Type unsigned int. The input must be in base 8 (octal). Digits 0 through 7 only.
u Type unsigned int. The input must be in base 10 (decimal). Digits 0 through 9 only.
x, X Type unsigned int. The input must be in base 16 (hexadecimal). Digits 0 through 9 or A
through Z or a through z. The characters 0x or 0X may be optionally prefixed to the value.
e, E, f, Type float. Begins with an optional sign. Then one or more digits, followed by an optional
g, G decimal-point and decimal value. Finally ended with an optional signed exponent value
designated with an e or E.
s Type character array. Inputs a sequence of non-white space characters (space, tab,
carriage return, new line, vertical tab, or form feed). The array must be large enough to
hold the sequence plus a null character appended to the end.
Page 136
C3: Protected
[type] Input
[...] Type character array. Allows a search set of characters. Allows input of only those
character encapsulated in the brackets (the scan set). If the first character is a carrot (^),
then the scan set is inverted and allows any ASCII character except those specified
between the brackets. On some systems a range can be specified with the dash character
(-). By specifying the beginning character, a dash, and an ending character a range of
characters can be included in the scan set. A null character is appended to the end of the
array.
c Type character array. Inputs the number of characters specified in the width field. If no
width field is specified, then 1 is assumed. No null character is appended to the array.
p Pointer to a pointer. Inputs a memory address in the same fashion of the %p type
produced by the printf function.
n The argument must be a pointer to an int. Stores the number of characters read thus far in
the int. No characters are read from the input stream.
% Requires a matching % sign from the input.
Page 137
C3: Protected
References
Websites
http://refcards.com/refcards/c/c-refcard-letter.pdf
http://cm.bell-labs.com/cm/cs/who/dmr/chist.html
http://www.lysator.liu.se/c/bwk-tutor.html#introduction
http://www.acm.uiuc.edu/webmonkeys/book/c_guide/
Books
Deitel & Deitel, “C How to Program”, Third Edition, Prentice Hall
Byron Gottfried, “Programming in C”, Tata McGraw Hill
R.G.Dromey, “How to solve it by Computer”, Eastern Economy Edition
Al Kelley, Ira Pohl, “A Book on C”, Fourth Edition, Pearson Education Asia
Page 138
C3: Protected
STUDENT NOTES
Page 139
C3: Protected

Problem Solving and C Programming - Handout - v2 (1) .1

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Problem Solving and C Programming - Handout - v2 (1) .1

Загружено:

Авторское право:

Доступные форматы

Handout: Problem Solving

Session 1: Introduction to Problem Solving and Programming Languages...........................7

Session 2: Introduction to C Programming Language ...........................................................21

Session 4: Selection and Control Structures ..........................................................................41

Session 6: Arrays and Strings ..................................................................................................52

Session 10: Functions...............................................................................................................75

Session 12: Structures and Unions..........................................................................................94

Session 14: Files and Preprocessors.....................................................................................107

STUDENT NOTES ....................................................................................................................139

About this Document

Session 1: Introduction to Problem Solving and

Problem Solving Aspect

Program Development Steps

Analyzing or Defining the Problem

Tasks in defining a problem:

Specifying the input requirements

Specifying the output requirements

Specifying the Processing Requirements

Example 1.1 Find the factorial of a given number

A well designed program is more likely to be:

Top-down design has the following advantages:

Algorithm (Developing a Solution technique)

An algorithm must be:

Example 1.2: Algorithm for finding factorial of a given number

Example 1.3: Pseudo Code for finding factorial of a given number

Step 4.1: PRINT factorial = 1

Represents Start, End

Represents Input, Output data

Represents Process (actions, calculations)

Represents Decision Making

Represents Pre-defined Process / module

Represents control flow

Example 1.4: Flow Chart for finding factorial of a given number

Declare the variables

Initialize fact =1,i =1

Documenting the Program

Documentation comes in two forms:

Compiling and Executing the Program

The Boundary (or Extreme) Cases

The Unusual Cases

The Invalid Cases

Introduction to Programming Languages

What is a Programming Language?

Computer Programming is an art of making a computer to do the required operations, by means of

Why Study Programming Languages?

The study of more than one programming language helps us:

Types and Categories of Programming Languages

Types of Programming Languages

Low Level Languages

(a) Machine Language

High Level Languages

Advantages of High Level Languages

Categories of programming languages

Artificial Intelligence Languages (AI)

What makes a Good Language?

Every language has its strengths and weaknesses.

Cost of use: Cost of use is measured on different languages like:

Program Development Environments

Programming Environments (Host Environment)

Embedded System Environments

Test your Understanding

3. Distinguish between testing and debugging.

4. State whether the following is True or False :