Structured Programming
Structured Programming
COMMUNICATION TECHNOLOGY
STRUCTURED PROGRAMMING
1
STRUCTURED PROGRAMMING ..............................................................................................................................4
DEFINITION OF TERMS...............................................................................................................................................4
INTRODUCTION TO STRUCTURED PROGRAMMING ...............................................................................6
HISTORY OF PROGRAMMING LANGUAGES ..................................................................................................6
PROGRAMMING PARADIGMS ................................................................................................................................8
SOFTWARE CONSIDERATIONS ..............................................................................................................................9
ADVANTAGES C LANGUAGE .............................................................................................................................. 10
PROGRAM DEVELOPMENT AND DESIGN ..................................................................................................... 11
PROGRAM DEVELOPMENT CYCLE .................................................................................................................. 11
STRUCTURED PROGRAMMING DESIGN CONCEPTS .............................................................................. 12
PROGRAM DESIGN TOOLS .................................................................................................................................... 12
PROGRAM STRUCTURE ............................................................................................................................................ 17
STRUCTURE OF A C PROGRAM .......................................................................................................................... 17
SOURCE CODE FILES ................................................................................................................................................ 20
C DATA TYPES.............................................................................................................................................................. 21
VARIABLES .................................................................................................................................................................... 22
CONSTANTS ................................................................................................................................................................... 25
TYPE CASTING ............................................................................................................................................................. 25
C PROGRAMMING OPERATORS ......................................................................................................................... 26
ARITHMETIC OPERATORS ................................................................................................................................ 26
INCREMENT AND DECREMENT OPERATORS – Unary Operators ................................................... 27
ASSIGNMENT OPERATORS – Binary Operators ......................................................................................... 27
RELATIONAL OPERATORS - Binary Operators .......................................................................................... 28
LOGICAL OPERATORS - Binary Operators ................................................................................................... 28
CONDITIONAL OPERATOR – Ternary Operators ....................................................................................... 29
PRECEDENCE OF OPERATORS ............................................................................................................................ 30
ASSOCIATIVITY OF OPERATORS ...................................................................................................................... 30
CONTROL STRUCTURES .......................................................................................................................................... 32
IMPORTANCE OF CONTROL STRUCTURES ................................................................................................. 32
TYPES OF CONTROL STRUCTURES .................................................................................................................. 32
SELECTION STRUCTURES ..................................................................................................................................... 33
THE IF SELECTION STRUCTURE .................................................................................................................. 33
THE IF/ELSE.............................................................................................................................................................. 34
THE IF.. ELSE IF ...ELSE STATEMENT.......................................................................................................... 34
NESTED IF STATEMENTS ................................................................................................................................. 35
SWITCH STATEMENT ......................................................................................................................................... 36
NESTED SWITCH STATEMENTS ................................................................................................................... 38
REPETITION/ITERATIVE/LOOP STRUCTURES ............................................................................................ 39
WHILE LOOP IN C ................................................................................................................................................. 39
FOR LOOP IN C ....................................................................................................................................................... 40
DO .. WHILE LOOP IN C ....................................................................................................................................... 42
NESTED LOOPS IN C ............................................................................................................................................ 43
BRANCHING STATEMENTS .................................................................................................................................. 45
BREAK STATEMENT IN C ................................................................................................................................. 45
CONTINUE STATEMENT IN C......................................................................................................................... 45
GOTO STATEMENT IN C .................................................................................................................................... 46
THE RETURN STATEMENT .............................................................................................................................. 47
THE INFINITE LOOP ................................................................................................................................................... 47
SUBPROGRAMS IN C.................................................................................................................................................... 48
TYPES OF FUNCTIONS ............................................................................................................................................. 48
LIBRARY FUNCTION ............................................................................................................................................ 48
USER DEFINED FUNCTION ............................................................................................................................... 49
DEFINING A FUNCTION........................................................................................................................................... 50
2
FUNCTION DECLARATIONS ................................................................................................................................. 51
CALLING A FUNCTION ............................................................................................................................................ 51
FUNCTION ARGUMENTS ........................................................................................................................................ 53
TYPES OF VARIABLES ............................................................................................................................................. 53
LOCAL VARIABLES .............................................................................................................................................. 53
GLOBAL VARIABLES ........................................................................................................................................... 53
DATA STRUCTURES ..................................................................................................................................................... 56
ARRAYS............................................................................................................................................................................ 57
DECLARING ARRAYS .......................................................................................................................................... 57
INITIALIZING ARRAYS ....................................................................................................................................... 58
ACCESSING ARRAY ELEMENTS .................................................................................................................... 58
SORT TECHNIQUES ............................................................................................................................................... 59
SEARCHING ARRAYS .......................................................................................................................................... 67
LINKED LISTS ............................................................................................................................................................... 69
POINTERS ........................................................................................................................................................................ 69
C STRINGS ....................................................................................................................................................................... 71
QUEUES ............................................................................................................................................................................ 75
STACKS............................................................................................................................................................................. 76
FILE HANDLING ............................................................................................................................................................. 77
OPENING FILES ............................................................................................................................................................ 77
CLOSING A FILE .......................................................................................................................................................... 77
WRITING A FILE .......................................................................................................................................................... 78
READING A FILE .......................................................................................................................................................... 78
BINARY I/O FUNCTIONS ......................................................................................................................................... 79
SOFTWARE DOCUMENTATION ........................................................................................................................... 81
PROCESS DOCUMENTATION ............................................................................................................................... 81
PRODUCT DOCUMENTATION .............................................................................................................................. 81
3
STRUCTURED PROGRAMMING
DEFINITION OF TERMS
1. HEADER FILE - A header file is a file with extension .h which contains C function declarations
to be shared between several source files. A header file is used in a program by including it with
the use of the preprocessing directive #include, which comes along with the compiler.
#include<stdio.h>
2. EXPRESSION – These are statements that return a value. Expressions combine variables and
constants to create new values or logical conditions which are either true or false e.g.
x + y, x <= y etc
3. KEYWORD - A keyword is a reserved word in C. Reserved words may not be used as constants
or variables or any other identifier names. Examples include auto, else, Long, switch, typedef
,break etc
4. IDENTIFIER - A C identifier is a name used to identify a variable, function, or any other user-
defined item. An identifier starts with a letter A to Z or a to z or an underscore _ followed by
zero or more letters, underscores, and digits (0 to 9). C does not allow punctuation characters
such as @, $, and % within identifiers.
6. FUNCTION - A function is a group of statements, enclosed within curly braces, which together
perform a task.
8. SOURCE CODE – Program instructions in their original form. C source code files have an
extension .c
9. OBJECT CODE – Code produced by a compiler from source code and exists in machine
readable language.
10. EXECUTABLE FILE – Refers to a file in a format that a computer can directly execute and is
created by a compiler.
12. SIGNED INTEGER – This is an integer that can hold either positive or negative numbers.
13. COMPILER – This is a program that translates source code into object code.
14. PREPROCESSOR COMMAND - The C preprocessor modifies a source file before handing it
over to the compiler for instance by including header files with #include as I #include <stdio.h>
15. LINKER/Binder/Link Editor – This is a program that combines object modules to form an
executable program. The linker combines the object code, the start up code and the code for
4
library routines used in the program (all in machine language) into a single file- the executable
file.
16. OPERATOR - A symbol that represents a specific action. For example, a plus sign (+) is an
operator that represents addition. The basic mathematic operators are + addition, - subtraction,*
multiplication,/ division
17. OPERAND - Operands are the objects that are manipulated by operators in expressions. For
example, in the expression 5 + x, x and 5 are operands and + is an operator. All expressions
have at least one operand.
18. EXPRESSION – This is a statement that returns a value. For example, when you add two
numbers together or test to see whether one value is equal to another.
19. VARIABLE - A variable is a memory location whose value can change during program
execution. Variable declaration must have a type, which defines what values that variable can
hold.
20. Data type – The data type of a variable etc determines the si ze and layout of the variable's
memory; the range of values that can be stored within that memory; and the set of operations that
can be applied to the variable.
21. CONSTANT - a constant is a value that never changes during program execution.
22. WHITESPACE - A line containing only whitespace, possibly with a comment, is known as a
blank line, and a C compiler totally ignores it.
Whitespace is the term used in C to describe blanks, tabs, newline characters and comments.
Whitespace separates one part of a statement from another and enables the compiler to identify
where one element in a statement, such as int, ends and the next element begins. Therefore, in the
following statement:
int age;
There must be at least one whitespace character (usually a space) between int and age for the
compiler to be able to distinguish them. On the other hand, in the following statement
5
CHAPTER 1
A programming language is a vocabulary and set of grammatical rules designed for instructing
a computer to perform specific tasks.
• Instructions were entered directly in binary format (1s and 0s) and therefore they were
tedious and error prone. Programmers had to design their code by hand then transfer it to
a computer using a punch card, punch tape or flicking switches.
• Instructions were executed directly by a computer's central processing unit (CPU) i.e.
they were executed very fast.
• Memory management was done manually.
• Programs were very difficult to edit and debug.
• Used to code simple programs only.
They were introduced to mitigate the error prone and excessively difficult nature of
binary programming.
By using codes resembling English, programming becomes much easier. The use of these mnemonic
codes such as LDA for load and STA for store means the code is easier to read and write. To convert an
assembly code program into object code to run on a computer requires an Assembler and each line of
assembly can be replaced by the equivalent one line of object (machine) code:
6
Assembly Code Machine Code
LDA A 000100110100
ADD #5 -> Assembler -> 001000000101
STA A 001100110100
JMP #3 010000000011
Such languages are sometimes still used for kernels and device drivers, i.e. the core of the operating
system and for specific machine parts. More often, such languages are used in areas of intense
processing, like graphics programming, when the code needs to be optimized for performance.
Almost every CPU architecture has a companion assembly language. Most commonly used are the
assembly languages today like Autocoder for IBM mainframe systems, Linoreum, MACRO -11,etc.
Third generation languages are the primary languages used in general purpose programming
today. They each vary quite widely in terms of their particular abstractions and syntax. However,
they all share great enhancements in logical structure over assembly languages.
Examples:
Most Modern General Purpose Languages such as C, C++, C#, Java, Basic, COBOL, Lisp and ML.
Examples: Progress 4GL, PL/SQL, Oracle Reports, Revolution language, SAS, SPSS, SQ
While 4GL are designed to build specific programs, 5GL are designed to make the computer solve a
7
given problem without the programmer. The programmer only needs to worry about what
problems needed to be solved and only inputs a set of logical constraints, with no
specified algorithm, and the Artificial Intelligence (AI)-based compiler builds the program
based on these constraints
High-level languages are closer to human languages and further from machine languages.
The main advantage of high-level languages over low-level languages is that they are easier
to read, write, and maintain. Ultimately, programs written in a high-level language must be
translated into machine language by a compiler or interpreter.
The first high-level programming languages were designed in the 1950s. Now there are dozens of
different languages, including Ada, Algol, BASIC, COBOL, C, C++, FORTRAN, LISP, Pascal,
and Prolog.
PROGRAMMING PARADIGMS
A programming paradigm is a fundamental style of computer programming, a way of building
the structure and elements of computer programs. There are four main paradigms:
a) Unstructured Programming
In unstructured programs, the statements are executed in sequence (one after the other) as written.
This type of programming uses the GoTo statement which allows control to be passed to any other
section in the program. When a GoTo statement is executed, the sequence continues from the
target of the GoTo. Thus, to understand how a program works, you have to execute it. This often
makes it difficult to understand the logic of such a program.
b) Structured Programming
8
Program flow follows a simple hierarchical model that employs looping constructs such as
"for," "repeat," and "while." Use of the "GoTo" statement is discouraged.
Most programs will require thousands or millions of lines of code. (Windows 2000 – over 35
millions lines of code). The importance of splitting a problem into a series of self-contained
modules then becomes obvious. A module should not exceed 100 lines, and preferably short
enough to fit on a single page or screen.
Examples of structured programming languages include:
C
Pascal
Fortran
Cobol
ALGOL
Ada
dBASE etc.
d) Visual Programming
A visual programming language uses a visual representation (such as graphics, drawings,
animation or icons, partially or completely). A visual language manipulates visual information or
supports visual interaction, or allows programming with visual expressions
A VPL allows programming with visual expressions, spatial arrangements of text and graphic
symbols, used either as elements of syntax or secondary notation. For example, many VPLs
(known as dataflow or diagrammatic programming) are based on the idea of "boxes and arrows",
where boxes or other screen objects are treated as entities, connected by arrows, lines or arcs which
represent relations. An example of visual programming languages is Microsoft Visual Basic which
was derived from BASIC and enables the rapid application development (RAD) of graphical user
interface (GUI) applications.
Programming in VB is a combination of visually arranging components or controls on a form,
specifying attributes and actions for those components, and writing additional lines of code
for more functionality.
This is programming oriented to the development of internet applications using languages and
tools such as PHP, ASP, Perl, JavaScript, HTML, Java etc.
SOFTWARE CONSIDERATIONS
Before you can start programming in C, you will need text editor such as a plain text Notepad
Editor though it does not offer code completion or debugging. Many programmers prefer and
recommend using an Integrated Development Environment (IDE) instead of a text editor on which
to code, compile and test their programs.
Memory requirements
9
Disk space required
ADVANTAGES C LANGUAGE
1. Modularity: modularity is one of the important characteristics of C. we can split
the C program into no. of modules instead of repeating the same logic statements
(sequentially). It allows reusability of modules.
2. General purpose programming language: C can be used to implement any kind
of applications such as math’s oriented, graphics, business oriented applications.
3. Portability: we can compile or execute C program in any operating system
(UNIX, dos, windows).
4. Powerful and efficient programming language: C is very efficient and powerful
programming language; it is best used for data structures and designing system
software. Efficient in that it is a modular programming language and thus
makes efficient use of memory and system resources.
10
CHAPTER 2
11
STRUCTURED PROGRAMMING DESIGN CONCEPTS
1. TOP-DOWN DESIGN
A top-down approach (also known as stepwise design or deductive reasoning, and in many
cases used as a synonym of analysis or decomposition) is essentially the breaking down of a
system to gain insight into its compositional sub-systems. In a top-down approach an overview of
the system is formulated, specifying but not detailing any first-level subsystems. Each subsystem
is then refined in yet greater detail, sometimes in many additional subsystem levels, until the entire
specification is reduced to base elements. Top- down approach starts with the big picture. It breaks
down from there into smaller segments.
Top-down design (also called " Modular programming " and "stepwise refinement") therefore, is
a software design technique that emphasizes separating the functionality of a program into
independent modules such that each module is designed to execute only one aspect of the desired
functionality.
2. BOTTOM-UP DESIGN
A bottom-up approach (also known as inductive reasoning, and in many cases used as a
synonym of synthesis) is the piecing together of systems to give rise to larger systems, thus
making the original systems sub-systems of the emergent system. In a bottom-up approach the
individual base elements of the system are first specified in great detail. These elements are then
linked together to form larger subsystems, which then in turn are linked, sometimes in many
levels, until a complete top-level system is formed.
With this approach, there is more user and business awareness of the product. Benefits
are also realized in the early phases of development.
3. MONOLITHIC DESIGN
The monolithic design philosophy is that the application is responsible not just for a particular
task, but can perform every step needed to complete a particular function
A monolithic application describes a software application which is designed without modularity.
12
Begin
If A is greater than B
And if A is greater than C, A is the Biggest
Otherwise C is the Biggest
Otherwise
If B is greater than C B is the Biggest
Otherwise C is the Biggest
End
Pseudo-code cannot be compiled nor executed, and there are no real formatting or syntax rules. It
is simply one step - an important one - in producing the final code
2. Algorithm
This refers to an established, computational procedure for solving a problem in a finite number
of steps. Algorithms can be expressed in any language including natural languages such as
English. Algorithm means a method/ logic for solving a given problem.
An algorithm to find the largest among three different numbers entered by user.
Step 1:
Start
Step 2:
Declare variables a, b and c.
Step 3:
Read variables a, b and c.
Step 4:
If a>b
If a>c
Display a is the largest number.
Else
Display c is the largest number.
Else
If b>c
Display b is the largest number.
Else
Display c is the greatest number.
Step 5: Stop
3. Flowchart
A flowchart is a type of diagram that represents an algorithm or process, showing the steps as
boxes of various kinds, and their order by connecting them with arrows. This diagrammatic
representation illustrates a solution to a given problem. Flowcharts are used in designing and
documenting complex processes or programs. Like other types of diagrams, they help to
visualize what is going on and thereby help the viewer to understand a process, and perhaps also
find flaws/errors, bottlenecks, and other less-obvious features within it.
Different symbols are used for different states in flowcharts. The table below describes all
the symbols that are used in making flowchart
Symbol Purpose Description
Used to indicate the flow of logic by
Flow line
connecting symbols.
13
Symbol Purpose Description
Used for arithmetic operations and data-
Processing
manipulations.
Used to represent the operation in which there are
Decision
two alternatives, true and false.
Draw flowchart to find the largest among three different numbers entered by user.
Or a flowchart to ask for a number from user and multiply with another number and print result
as follows:
Examples of flowcharts include Activity diagram, Data flow diagram and sequence diagrams etc.
14
STRUCTURE CHARTS (module chart, hierarchy chart)
A structure chart is a top-down modular design tool, constructed of squares representing the
different modules in the system, and lines that connect them. A structure chart is a graphic
depiction of the decomposition of a problem. It is a tool to aid in software design but is particularly
helpful on large problems.
A structure chart illustrates the partitioning of a problem into sub-problems and shows the
hierarchical relationships among the parts. A classic "organization chart" for a company is
an example of a structure chart.
The top of the chart is a box representing the entire problem, the bottom of the chart shows a
number of boxes representing the less complicated sub-problems (e.g. Phone Bill System).
A structure chart is NOT a flowchart. It has nothing to do with the logical sequence of tasks. It
does NOT show the order in which tasks are performed. It does NOT illustrate an algorithm.
Each block represents some function in the system, and thus should contain a verb phrase,
e.g. "Print report heading."
Decision Tables
Decision tables provide a handy and compact way to represent complex business logic. In a
decision table, business logic is well divided into conditions, actions (decisions) and rules
for representing the various components that form the business logic.
There is one row for each condition and each vertical column for each combination of values
and resulting actions. Conditions are the factors to consider when making certain business
decision. Actions are the possible actions to take when certain business decision is made.
Each vertical column of a decision table is called a rule and each rule symbolizes the combinations of
condition(s) and action(s) that form the business decision. If constructed properly, the decision
15
table has a rule to cover every combination. Rules are made of selectors symbolized by Y (Yes),
N (No) and – (for redundant or irrelevant rules).
EXAMPLE
A student who passes the examinations and completes the coursework and project satisfactorily is
awarded a pass. If the course work and the project are unsatisfactory, the student is asked to
resubmit the unsatisfactory work, as long as the exams have been passed. A student who fails the
examinations is deemed to have failed the whole ourse unless both the course work and the project
are satisfactory, in which case the student is allowed to re-sit the examination.
SOLUTION
ASSIGNMENT 1
Candidates are accepted for employment if they pass the interview and their qualifications and
reference are satisfactory. If they pass the interview and the qualifications or references (but
not both) are unsatisfactory, a job for probationary period is offered. In all other circumstances,
the candidate’s application is rejected.
Assignment 2
• Design the business logic (at least three conditions) that is applicable when a customer
is applying for a bank loan.
• Draw a decision table to represent the business logic.
16
CHAPTER 3
3. PROGRAM STRUCTURE
STRUCTURE OF A C PROGRAM
The C programming language was designed by Dennis Ritchie as a systems
programming language for Unix.
Example:
#include <stdio.h>
int main()
{
/* My first program*/
printf("Hello, World! \n");
return 0;
}
Preprocessor Commands
These commands tell the compiler to do preprocessing before doing actual compilation. Like
#include <stdio.h> is a preprocessor command which tells a C compiler to include stdio.h file
before going to actual compilation. The standard input and output header file (stdio.h) allows
the program to interact with the screen, keyboard and file system of the computer.
NB/ Preprocessor directives are not actually part of the C language, but rather instructions from
you to the compiler.
Functions
These are main building blocks of any C Program. Every C Program will have one or more
functions and there is one mandatory function which is called main() function. When this
function is prefixed with keyword int, it means this function returns an integer value when it
exits. This integer value is retuned using return statement.
The C Programming language provides a set of built-in functions. In the above example printf() is
a C built-in function which is used to print anything on the screen.
A function is a group of statements that together perform a task. A C program can be divide up
into separate functions but logically the division usually is so each function performs a specific
task. A function declaration tells the compiler about a function's name, return type, and parameters.
A function definition provides the actual body of the function.
The general form of a function definition in C programming language is as follows:
17
return_type function_name( parameter list )
{
body of the function/Function definition
}
Variable Declarations
In C, all variables must be declared before they are used. Thus, C is a strongly typed
programming language. Variable declaration ensures that appropriate memory space is reserved
for the variables. Variables are used to hold numbers, strings and complex data for manipulation
e.g. Int x;
Int num; int z;
Comments
These are non-executable program statements meant to enhance program readability and
allow easier program maintenance- they document the program. They are ignored by the
compiler. These are used to give additional useful information inside a C Program. All the
comments will be put inside /*...*/ or // for single line comments as given in the example above. A
comment can span through multiple lines.
/* Author: Mzee Moja */
or
/*
* Author: Mzee Moja
* Purpose: To show a comment that spans multiple lines.
* Language: C
*/
or
Fruit = apples + oranges; // get the total fruit
Escape Sequences
Escape sequences (also called back slash codes) are character combinations that begin with
a backslash symbol used to format output and represent difficult-to-type characters.
They include:
\a Alert/bell
\b Backspace
\n New line
\v Vertical tab
\t Horizontal tab
\\Back slash
\’ Single quote
18
\” Double quote
\0 Null
Keywords
The following list shows the reserved words in C. These reserved words may not be used
as constants or variables or any other identifier names.
19
case extern return union
char float short unsigned
const for signed void
continue goto sizeof volatile
default if static while
do int struct _packed
double
Linking is the process where the object code, the start up code and the code for library routines
used in the program (all in machine language) are c mbined into a single file- the executable file.
If the compiled program can run on a computer whose CPU or operating system is
different from the one on which the compiler runs, the compiler is known as a
cross-compiler.
A program that translates from a low level language to a higher level one is
a decompiler.
Library Functions
There is a minimal set of library functions that should be supplied by all C compilers, which your
program may use. This collection of functions is called the C standard library. The standard library
contains functions to perform disk I/O (input/ output), string manipulations, mathematics and much
more. When your program is compiled, the code for library functions is automatically added to your
program. One of the most common library functions is called printf() which is a general purpose
output function. The quoted string between the parenthesis of the printf() function is called an
argument.
Printf(“This is a C program\n”)
The \n at the end of the text is an escape sequence tells the program to print a new line as part
of the output.
20
C DATA TYPES
In the C programming language, data types refer to a system used for declaring variables or
functions of different types. A data type is, therefore, a data storage format that can contain a
specific type or range of values. The type of a variable determines how much space it occupies
in storage and how the bit pattern stored is interpreted.
Long
Sometimes while coding a program, we need to increase the Storage Capacity of a
variable so that it can store values higher than its maximum limit which is there as default.
This can be applied to both int and double. When applied to int, it doubles its length,
in bits, of the base type that it modifies. For example, an integer is usually 16 bits long.
Therefore a long int is 32 bits in length. When long is applied to a double, it roughly
doubles the precision.
Short
A “short” type modifier does just the opposite of “ long”. If one is not expecting to see
high range values in a program.
For example, if we need to store the “age” of a stu dent in a variable, we will make use
of this type qualifier as we are aware that this value is not going to be very high
The type modifier precedes the type name. For example this declares a long integer.
21
Integer Types
Following table gives you details about standard integer types with its storage sizes and
value ranges:
Type Storage size Value range
Char 1 byte -128 to 127 or 0 to 255
unsigned char 1 byte 0 to 255
signed char 1 byte -128 to 127
Int 2 or 4 bytes -32,768 to 32,767 or -2,147,483,648 to
2,147,483,647
unsigned int 2 or 4 bytes 0 to 65,535 or 0 to 4,294,967,295
Short 2 bytes -32,768 to 32,767
unsigned short 2 bytes 0 to 65,535
Long 4 bytes -2,147,483,648 to 2,147,483,647
unsigned long 4 bytes 0 to 4,294,967,295
Floating-Point Types
Following table gives you details about standard floating-point types with storage sizes and
value ranges and their precision:
Type Storage size Value range Precision
float 4 byte 1.2E-38 to 3.4E+38 6 decimal places
double 8 byte 2.3E-308 to 1 7E+308 15 decimal places
long double 10 byte 3.4E-4932 o 1.1E+4932 19 decimal places
VARIABLES
A variable is a memory location whose value can change during program execution. In C a
variable must be declared before it can be used.
Variable Declaration
Declaring a variable tells the compiler to reserve space in memory for that particular variable. A
variable definition specifies a data type and the variable name and contains a list of one or
more variables of that type .Variables can be declared at the start of any block of code. A
declaration begins with the type, followed by the name of one or more variables. For example,
Int high, low;
int i, j, k;
char c, ch;
float f, salary;
22
Variables can be initialized when they are declared. This is done by adding an equals sign and
the required value after the declaration.
TYPES OF VARIABLES
The Programming language C has two main variable types
• Local Variables
• Global Variables
Local Variables
A local variable is a variable that is declared inside a function.
• Local variables scope is confined within the block or function where it is defined.
Local variables must always be defined at the top of a block.
• When execution of the block starts the variable is available, and when the block ends
the variable 'dies'.
Global Variables
Global variable is defined at the top of the program file and it can be visible and modified by
any function that may reference it. Global variables are declared outside all functions.
Sample Program.
#include <stdio.h>
int area; //global variable
int main ()
{
int a, b; //local variable
/* actual initialization */
a = 10;
b = 20;
area = a*b;
printf("\t The area of your rectangle is : %d \n", area);
return 0;
}
23
Variable Names
Every variable has a name and a value. The name identifies the variable and the value stores
data. Every variable name in C must start with a letter; the rest of the name can consist of letters,
numbers and underscore characters. C is case sensitive i.e. it recognizes upper and lower case
characters as being different. You cannot use any of C’s keywords like main, while, switch etc as
variable names,
It is conventional in C not to use capital letters in variable names. These are used for names
of constants.
Declaration vs Definition
A declaration provides basic attributes of a symbol: its type and its name. A definition provides all
of the details of that symbol--if it's a function, what it does; if it's a class, what fields and methods it
has; if it's a variable, where that variable is stored. Often, the compiler only needs to have a
declaration for something in order to compile a file into an object file, expecting that the linker can
find the definition from another file. If no source file ever defines a symbol, but it is declared, you
will get errors at link time complaining about undefined symbols. In the following short code, the
definition of variable x means that the storage for the variable is that it is a global variable.
int x;
int main()
{
x = 3;
}
The %d is a format specifier which tells the compiler that the second argument will be receiving
an integer value.
The & preceding the variable name means “address of ”. The function allows the function to place
a value into one of its arguments.
The table below shows format specifiers or codes used in the scanf() function and their meaning.
24
When used in a printf() function, a type specifier informs the function that a different type item is
being displayed.
int main ()
{
int a, b; //local variables
/* actual initialization */
printf("Enter the value of side a: ");
scanf("%d", &a);
area = a*b;
printf("\t The area of your rectangle is : %d \n", area);
return 0;
}
CONSTANTS
C allows you to declare constants. When you declare a constant it is a bit like a variable
declaration except the value cannot be changed during program execution. The const keyword is
used to declare a constant, as shown below:
int const A = 1;
const int A =2;
TYPE CASTING
Type casting is a way to convert a variable from one data type to another. For example, if you want
to store a long value into a simple integer then you can type cast long to int. You can convert
values from one type to another explicitly using the cast operator as follows:
(type_name) expression
Consider the following example where the cast operator causes the division of one integer
variable by another to be performed as a floating-point operation:
25
#include <stdio.h>
main()
{
int sum = 17, count = 5;
double mean;
When the above code is compiled and executed, it produces the following result:
It should be noted here that the cast operator has precedence over division, so the value of sum
is first converted to type double and finally it gets divided by count yielding a double value.
Type conversions can be implicit which is performed by the compiler automatically, or it can
be specified explicitly through the use of the cast operator. It is considered good programming
practice to use the cast operator whenever type conversions are necessary.
C PROGRAMMING OPERATORS
Operator is the symbol which operates on a value or a variable (operand). For example: + is an
operator to perform addition.
C programming language has a wide range of operators to perform various operations. For
better understanding of operators, these operators can be classified as:
OPERATORS IN C PROGRAMMING
1. Arithmetic Operators
2. Increment and Decrement Operators
3. Assignment Operators
4. Relational Operators
5. Logical Operators
6. Conditional Operators
7. Bitwise Operators
8. Special Operators
ARITHMETIC OPERATORS
Assume variable A holds 10 and variable B holds 20 then
Operator Description Example
+ Adds two operands A + B will give 30
- Subtracts second operand from the first A - B will give -10
* Multiplies both operands A * B will give 200
/ Divides numerator by de-numerator B / A will give 2
% Modulus Operator - remainder of after an B % A will give 0
integer division
26
Note: % operator can only be used with integers.
Let a=5
a++; //a becomes 6
a--; //a becomes 5
++a; //a becomes 6
--a; //a becomes 5
#include <stdio.h>
int main(){
int c=2;
printf("%d\n",c++); /*this statement displays 2
then, only c incremented by 1 to 3.*/
printf("%d",++c); /*this statement increments 1 to c
then, only c is displayed.*/
return 0;
}
Output
2
4
27
Operator Example Same as
/= a/=b a=a/b
%= a%=b a=a%b
NB/ += means Add and Assign etc.
a>b
Here, > is a relational operator. If a is greater than b, a>b returns 1 if not then, it returns 0.
Meaning of
Operator Example
Operator
If c=5 and d=2 then,((c= =5) && (d>5))
&& Logical AND
returns false.
If c=5 and d=2 then, ((c= =5) || (d>5))
|| Logical OR
returns true.
! Logical NOT If c=5 then, !(c= =5) returns false.
The following table shows the result of operator && evaluating the expression a&&b:
28
The operator || corresponds to the Boolean logical operation OR, which yields true if either of its
operands is true, thus being false only when both operands are false. Here are the possible
results of a || b:
|| OPERATOR (or)
a b a || b
true true true
true false true
false true true
false false false
Explanation
For expression, ((c==5) && (d>5)) to be true, both c==5 and d>5 should be true but, (d>5) is
false in the given example. So, the expression is false. For expression ((c==5) || (d>5)) to be
true, either the expression should be true.
Since, (c==5) is true. So, the expression is true. Since, expression (c==5) is true, !(c==5) is false.
c=(c>0)?10:-10;
If c is greater than 0, value of c will be 10 but, if c is less than 0, value of c will be -10.
BITWISE OPERATORS
Bitwise operators work on bits and performs bit-by-bit operation.
29
PRECEDENCE OF OPERATORS
If more than one operator is involved in an expression then, C language has a predefined rule of
priority of operators. This rule of priority of operators is called operator precedence.
Here, operators with the highest precedence appear at the top of the table, those with the lowest appear
at the bottom. Within an expression, higher precedence operators will be evaluated first.
ASSOCIATIVITY OF OPERATORS
Associativity indicates in which order two operators of same precedence (priority) executes. Let us
suppose an expression:
a= =b!=c
30
Here, operators == and != have the same precedence. The associativity of both == and != is left to
right, i.e., the expression in left is executed first and execution take pale towards right. Thus,
a==b!=c equivalent to :
(a= =b)!=c
Operators may be left-associative (meaning the operations are grouped from the left),
right-associative (meaning the operations are grouped from the right)
31
Chapter 4
CONTROL STRUCTURES
Definition
Control structures represent the forms by which statements in a program are executed. Flow of
control refers to the order in which the individual statements, instructions or function calls of a program
are executed or evaluated.
The kinds of control flow statements supported by different languages vary, but can be categorized by
their effect:
continuation at a different statement i.e. unconditional jump e.g. GoTo statements
executing a set of statements only if some condition is met i.e. choice
executing a set of statements zero or more times, until some condition is met i.e. loop
executing a set of distant statements, after which the flow of control usually returns e.g.
subroutines/functions
3. Repetition/Iterative structures
This is where a group of statements in a program may have to be executed repeatedly until some
condition is satisfied. These include while, do/while and for
32
SELECTION STRUCTURES
(a) THE IF SELECTION STRUCTURE
– Used to choose among alternative courses of action i.e. the if statement provides a junction at which
the program has to select which path to follow. The if selection performs an action only if the
condition is true,
General form
If (expression)
statement
Pseudocode:
As in
if (marks>=600)
printf(“Passed”);
If condition is true
– Print statement executed and program goes on to next statement
– If false, print statement is ignored and the program goes onto the next statement
NB/ Indenting makes programs easier to read
true
grade >= 60 print “ Passed”
false
NB/ The statement in the if structure can be a single statement or a block (Compound statement).
If it’s a block of statements, it must be marked off by braces.
33
if (expression)
{
Block of statements
}
As in
If (salary>5000)
{
tax_amount = salary * 1.5;
printf(“Tax charged is %f”, tax_amount);
}
While if only performs an action if the condition is true, if/else specifies an action to be performed both
when the condition is true and when it is false. E.g.
Pseudocode:
If student’s grade is greater than or equal to 60
Print “Passed”
else
Print “Failed”
false true
grade >= 60
Example
if (x >=100)
{
printf(“Let us increment x:\n”);
x++;
}
else
34
– Test for multiple cases/conditions.
– Once a condition is met, the other statements are skipped
– Deep indentation usually not used in practice
Example
#include <stdio.h>
main()
{
int marks;
printf("Please enter your MARKS:");
scanf("%d", &marks);
Syntax
The syntax for a nested if statement is as follows:
if (boolean_expression 1)
{
/* Executes when the boolean expression 1 is true */
if(boolean_expression 2)
35
{
/* Executes when the boolean expression 2 is true */
}
}
You can nest else if...else in the similar way as you have nested if statement.
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
/* check the boolean condition */
if( a = = 100 )
{
/* if condition is true then check the following */
if( b = = 200 )
{
/* if condition is true then print the following */
printf("Value of a is 100 and b is 200\n" );
}
}
return 0;
}
When the above code is compiled and executed, it produces the following result:
Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200
Syntax
The syntax for a switch statement in C programming language is as follows:
switch(expression)
{
case constant-expression
statement(s);
break;
case constant-expression :
statement(s);
break;
/* you can have any number of case statements */
default :
statement(s);
}
36
The following rules apply to a switch statement:
1) You can have any number of case statements within a switch. Each case is followed by the
value to be compared to and a colon.
2) The constant-expression for a case must be the same data type as the variable in the switch
3) When the variable being switched on is equal to a case, the statements following that case will
execute until a break statement is reached.
4) When a break statement is reached, the switch terminates, and the flow of control jumps to
the next line following the switch statement.
5) Not every case needs to contain a break. If no break appears, the flow of control will fall
through to subsequent cases until a break is reached.
6) A switch statement can have an optional default case, which must appear at the end of the
switch. The default case can be used for performing a task when none of the cases is true. No
break is needed in the default case.
#include<stdio.h>
void main()
{
char grade;
switch (grade)
{
case 'A':
printf("Excellent!\n");
break;
case 'B':
printf("Very Good!\n");
37
break;
case 'C':
printf("Good!\n");
break;
case 'D':
printf("Work harder!\n");
break;
default:
printf("Fail!\n");
}
}
38
}
When the above code is compiled and executed, it produces the following result:
REPETITION/ITERATIVE/LOOP STRUCTURES
A loop statement allows the execution of a statement or a group of statements multiple times until
a condition either tests true or false. There are two types of loops: Pre-test and post-test loops.
In a pretest loop, a logical condition is checked before each repetition to determine if the loop should
terminate. These loops include:
– while loop
– for loop
Post-test loops check a logical condition after each repetition for termination. The do-while loop is a post-
test loop.
The statement(s) may be a single statement or a block of statements. The loop iterates while the
condition is true.
When the condition becomes false, program control passes to the line immediately following the loop.
39
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10; //loop index
When the above code is compiled and executed, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
Syntax
The syntax of a for loop in C programming language is:
2. Next, the condition is evaluated. If it is true, the body of the loop is executed. If it is false, the
body of the loop does not execute and flow of control jumps to the next statement just after the
for loop.
40
3. After the body of the for loop executes, the flow of control jumps back up to the update
expression. This statement allows you to update any loop control variables. This statement can be
left blank, as long as a semicolon appears after the condition.
4. The condition is now evaluated again. If it is true, the loop executes and the process repeats
itself. After the condition becomes false, the for loop terminates.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
int a;//loop index
/* for loop execution */
for(a = 10; a < 20; a++)
{
printf("value of a: %d\n", a);
}
return 0;
}
When the above code is compiled and executed, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
41
value of a: 17
value of a: 18
value of a: 19
Syntax
do
{
statement(s);
}while( condition );
If the condition is true, the flow of control jumps back up to do, and the statement(s) in the loop execute
again. This process repeats until the given condition becomes false.
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* do loop execution */
do
{
printf("value of a: %d\n", a);
a = a + 1;
}while( a < 20 );
return
42
When the above code is compiled and executed, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
The syntax for a nested while loop statement in C programming language is as follows:
while(condition)
{
while(condition)
{
statement(s);
}
statement(s);
}
The syntax for a nested do...while loop statement in C programming language is as follows:
do
{
statement(s);
do
{
statement(s);
}while( condition );
}while( condition );
43
A final note on loop nesting is that you can put any type of loop inside of any other type of loop. For
example, a for loop can be inside a while loop or vice versa.
Example
#include <stdio.h>
int main()
{
int n, c, k;
return 0;
}
Result:
If the user interred 5 as the number of rows, the output would be:
1
12
123
1234
1 2345
TERMINATING LOOPS
• Counter-controlled loops - a loop controlled by a counter variable, generally where the number of times
the loop will execute is known ahead of time especially in for loops.
• Event-controlled loops - loops where termination depends on an event rather than executing a fixed
number of times for example when a zero value is keyed in or search through data until an item is found.
Used mostly in while loops and do-while loops.
Using a Sentinel
• The value -999 is sometimes referred to as a sent inel value. The value serves as the “guardian” for the
termination of the loop. It is a good idea to make the sentinel a constant:
#define STOPNUMBER -999
while (number != STOPNUMBER) ...
44
BRANCHING STATEMENTS
(a) BREAK STATEMENT IN C
The break statement has the following two uses:
1. When the break statement is encountered inside a loop, the loop is immediately terminated and
program control resumes at the next statement following the loop.
2. It can be used to terminate a case in the switch statement.
3. If you are using nested loops (i.e., one loop inside another loop), the break statement will stop
the execution of the innermost loop and start executing the next line of code after the block.
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* do loop execution */
do
{
if( a = = 15)
{
/* skip the iteration */
break;
}
printf("value of a: %d\n", a);
a++;
}while( a < 20 );
return 0;
}
Example
//program to demonstrate the working of continue statement in C programming
# include <stdio.h>
int main(){
int i,num,product;
for(i=1,product=1;i<=4;++i){
printf("Enter num%d:",i);
scanf("%d",&num);
if(num==0)
continue; /*In this program, when num equals to zero, it skips
the statement product*=num and continue the loop. */
product*=num;
}
printf("product=%d",product);
45
return 0;
}value of a: 19
Syntax
The syntax for a goto statement in C is as follows:
goto label;
..
.
Example
#include <stdio.h>
int main ()
{
/* for loop execution */
int a,userinput,sum=0;
sum+=userinput;
}
jump:
46
printf("The sum of the values is %d\n", sum);
return 0;
}
The last of the branching statements is the return statement. The return statement exits from the
current function, and control flow returns to where the function was invoked. The return statement has
two forms: one that returns a value, and one that doesn't. To return a value, simply put the value (or an
expression that calculates the value) after the return keyword.
return count;
The data type of the returned value must match the type of the method's declared return value. When a
function is declared void, use the form of return that doesn't return a value.
return;
#include <stdio.h>
int main ()
{
for( ; ; )
{
printf("This loop will run forever.\n");
}
return 0;
}
When the conditional expression is absent, it is assumed to be true. You may have an initialization and
increment expression, but C programmers more commonly use the for(;;) construct to signify an
infinite loop.
NOTE: You can terminate an infinite loop by pressing Ctrl + C keys.
47
CHAPTER 5
SUBPROGRAMS IN C
A sub-program is a series of C statements that perform a specific task in a program. A
subprogram can be called within another procedure. Every C program has at least one
function, which is main(). A C program can be divided up into separate functions.
A function declaration tells the compiler about a function's name, return type, and
parameters. A function definition provides the actual body of the function.
The C standard library provides numerous built-in functions that your program can
call. For example, function strcat() to concatenate two strings, function memcpy()
to copy one memory location to another location and many more functions.
A function is known with various names like a method or a sub-routine or a
procedure, etc. However, a function returns a value while a procedure doesn’t: it
just executes commands.
A Subprogram is:
• a part of a program that performs one or more related tasks
• has its own name
• written as an independent part of the program
TYPES OF FUNCTIONS
Basically, there are two types of functions in C on basis of whether it is defined by
user or not.
• Library function
• User defined function
LIBRARY FUNCTION
Library functions are the in-built function in C programming system. For example:
48
printf()
scanf()
As mentioned earlier, every C program begins from main() and program starts
executing the codes inside main() function. When the control of program reaches to
function_name() inside main() function. The control of program jumps to void
function_name() and executes the codes inside it. When, all the codes inside that user-
defined function are executed, control of the program jumps to the statement just after
function_name() from where it is called. Analyze the figure below for understanding
the concept of function in C programming.
49
Remember, the function name is an identifier and should be unique.
DEFINING A FUNCTION
The general form of a function definition in C programming language is as follows:
1. Return Type: A function may return a value. The return_type is the data type
of the value the function returns. Some functions perform the desired operations
without returning a value. In this case, the return_type is the keyword void.
2. Function Name: This is the actual name of the function. The function name
and the parameter list together constitute the function signature.
3. Parameters: A parameter is like a placeholder. When a function is invoked, you
pass a value to the formal parameter. This value is referred to as actual
parameter or argument. The parameter list refers to the type, order, and
number of the parameters of a function. Parameters are optional; that is, a
function may contain no parameters.
4. Function Body: The function body contains a collection of statements that define
what the function does.
50
Example
Following is the source code for a function called max(). This function takes
two parameters num1 and num2 and returns the maximum between the two:
For the above defined function max(), following is the function declaration:
Parameter names are not important in function declaration; only their type is required,
so the following is also valid declaration:
Function declaration is required when you define a function in one source file and
you call that function in another file. In such case you should declare the function at
the top of the file calling the function.
CALLING A FUNCTION
While creating a C function, you give a definition of what the function has to do. To
use a function, you will have to call that function to perform the defined task.
When a program calls a function, program control is transferred to the called
function. A called function performs defined task, and when its return statement is
executed or when its function-ending closing brace is reached, it returns program
control back to the main program. Therefore, the calling program is suspended during
execution of the called subprogram.
To call a function, you simply need to pass the required parameters along with
function name, and if function returns a value, then you can store returned value. For
example:
51
#include <stdio.h>
/* function declaration */
int max(int num1, int num2);
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
/* calling a function to get max value
*/ ret = max(a, b);
printf( "Max value is : %d\n", ret );
return 0;
}
return result;
}
The formal parameters behave like other local variables inside the function and are
created upon entry into the function and destroyed upon exit.
While calling a function, there are two ways that arguments can be passed to
a function:
By default, C uses call by value to pass arguments. In general, this means that code
within a function cannot alter the arguments used to call the function and above
mentioned example while calling max() function used the same method.
52
FUNCTION ARGUMENTS
If a function is to use arguments, it must declare variables that accept the values of
the arguments. These variables are called the formal parameters of the function.
The formal parameters behave like other local variables inside the function and are
created upon entry into the function and destroyed upon exit.
A formal parameter is a dummy variable listed in the subprogram header and used
in the subprogram. An actual parameter represents a value used in the subprogram
call statement.
When max() is called, we pass it the arguments which the function uses as the values
of ret. This process is called parameter passing. *****
Parameters refers to the list of variables in a method declaration. Arguments are the
actual values that are passed in hen the method is invoked. When you invoke a
method, the arguments used must match the declaration's parameters in type and
order.
TYPES OF VARIABLES
The Programming language C has two main variable types
• Local Variables
• Global Variables
LOCAL VARIABLES
GLOBAL VARIABLES
Global variable is defined at the top of the program file and it can be visible and
modified by any function that may reference it. Global variables are declared outside
all functions.
53
Sample Program.
#include <stdio.h>
int area; //global variable
int main ()
{
int a, b; //local variable
/* actual initialization */
a = 10;
b = 20;
printf ("\t Side a is %d cm and side b is %d cm long\n", a,
b); area = a*b;
printf ("\t The area of your rectangle is : %d \n", area);
return 0;
}
EXERCISES
1. Write a C program to add two integers Define a function add to add integers
and display sum in main() function
//main function
#include<stdio.h>
int add(int a, int b);
int main()
{
int a, b, sum;
sum = add(a,b);
printf("The sum of the two numbers is %d\n", result);
54
2. Write a C program– max()- to determine the greater of two integers. Call the
function from main() and supply it with two integers and then display the
greater of the two.
#include <stdio.h>
/* function declaration */
int max(int, int);
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
return 0;
}
return result;
}
55
CHAPTER 6
DATA STRUCTURES
These refer to groups of data elements that are organized in a single unit so that
they can be used more efficiently as compared to the simple data types such as
integers and strings. An example of a data structure is the array. Ordinary variables
store one value at a time while an array will store more than one value at a time in a
single variable name.
Data structures are important for grouping sets of similar data together and passing
them as one. For example, if you have a method that prints a set of data but you don't
know when writing the procedure how large that set is going to be, you could use an
array to pass the data to that method and loop through it. Data structures can be
classified using various criteria.
a) Linear
In linear data structures, values are arranged in linear fashion. A linear data structure
traverses the data elements sequentially. The elements in the structure are adjacent to
one another other and every element has exactly two neighbour elements to which it
is connected. Arrays, linked lists, stacks and queues are examples of linear data
structures.
b) Non-Linear
The data values in this structure are not arranged in order but every data item is
attached to several other data items in a way that is specific for reflecting
relationships. Tree, graph, table and sets are examples of non-linear data structures.
c) Homogenous
In this type of data structures, values of the same types of data are stored, as in an
array.
d) Non-homogenous
In this type of data structures, data values of different types are grouped, as
in structures and classes.
e) Dynamic
In dynamic data structures such as references and pointers, size and memory locations
can be changed during program execution. These data structures can grow and shrink
during execution.
f) Static
With a static data structure, the size of the structure is fixed. Static data structures
such as arrays are very good for storing a well-defined number of data items.
56
ARRAYS
An array is a named list of elements, all with the same data type. It is better defined as
a consecutive group of memory locations all of which have the same name and the
same data type. Arrays store a fixed-size equential collection of elements of the same
type.
All arrays consist of contiguous memory locations. The lowest address corresponds
to the first element and the highest address to the last element.
DECLARING ARRAYS
To declare an array in C, a programmer specifies the type of the elements and the
number of elements required by an array as follows:
double balance[10];
57
Now balance is a variable array which is sufficient to hold up to 10 double numbers.
INITIALIZING ARRAYS
You can initialize an array in C either one by one or using a single statement as
follows:
The number of values between braces { } can not be larger than the number of
elements that we declare for the array between square brackets [ ]. Following is
an example to assign a single element of the array:
If you omit the size of the array, an array just big enough to hold the initialization is
created. Therefore, if you write:
You will create exactly the same array as you did in the previous example.
balance[4] = 50.0;
The above statement assigns element number 5th in the array a value of 50.0. Array
with 4th index will be 5th ie. last element because all arrays have 0 as the index of
their first element which is also called base index. Following is the pictorial
representation of the same array we discussed above:
An element is accessed by indexing the array name. This is done by placing the
index of the element within square brackets after the name of the array. For example:
The above statement will take 10th element from the array and assign the value to
salary variable. Following is an example which will use all the above mentioned
three concepts viz. declaration, assignment and accessing arrays:
#include <stdio.h>
int main ()
{
int n[ 10 ]; /* n is an array of 10 integers
*/ int i,j;
58
/* initialize elements of array n to 0
*/ for ( i = 0; i < 10; i++ )
{
n[ i ] = i + 100; /* set element at location i to i
+ 100 */
}
return 0;
}
When the above code is compiled and executed, it produces the following result:
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
SORT TECHNIQUES
Bubble Sort
In the bubble sort, as elements are sorted they gradually "bubble" (or
rise) to their proper location in the array, like bubbles rising in a glass of
soda. The bubble sort repeatedly compares adjacent elements of an
array. The first and second elements are compared and swapped if out of
order. Then the second and third elements are compared and swapped if
out of order. This sorting process continues until the last two elements of
the array are compared and swapped if out of order.
When this first pass through the array is complete, the bubble sort returns to
elements one and two and starts the process all over again.
The table below follows an array of numbers before, during, and after a bubble sort
59
fordescending order. A "pass" is defined as one full trip through the array comparing
and if necessary, swapping, adjacent elements. Several passes have to be made
through the array before it is finally sorted
Array at beginning: 84 69 76 86 94 91
After Pass #1: 84 76 86 94 91 69
After Pass #2: 84 86 94 91 76 69
After Pass #3: 86 94 91 84 76 69
After Pass #4: 94 91 86 84 76 69
After Pass #5 (done): 94 91 86 84 76 69
The bubble sort is an easy algorithm to program, but it is slower than many other
sorts. With a bubble sort, it is always necessary to make one final "pass"
through the array to check to see that no swaps are made to ensure that the
process is finished. In actuality, the process is finished before this last
pass is made.
60
printf("\nThe total marks is %d\n", total);
printf("Mean marks is %f\n", meanmark);
}
Exchange Sort
The exchange sort is similar to its cousin, the bubble sort, in that it compares
elements of the array and swaps those that are not in their proper positions. (Some
people refer to the "exchange sort" as a "bubble sort".) The difference between these
two sorts is the manner in which they compare the elements. The exchange sort
compares the first element with each following element of the array, making any
necessary swaps.
When the first pass through the array is complete, the exchange sort then takes the
second element and compares it with each following element of the array swapping
elements that are out of order. This sorting process continues until the entire array is
ordered.
Let's examine our same table of elements again using an exchange sort for descending
order. Remember, a "pass" is defined as one full trip through the array comparing and
if necessary, swapping elements.
Array at beginning: 84 69 76 86 94 91
After Pass #1: 94 69 76 84 86 91
After Pass #2: 94 91 69 76 84 86
After Pass #3: 94 91 86 69 76 84
After Pass #4: 94 91 86 84 69 76
After Pass #5 (done): 94 91 86 84 76 69
The exchange sort, in some situations, is slightly more efficient than the bubble
sort. It is not necessary for the exchange sort to make that final complete pass
needed by the bubble sort to determine that it is finished.
61
{
int i, j;
int temp; // holding variable
int num[5];
//intialize array
for(i =0; i<=4; i++){
printf("Enter a number:");
scanf("%d",&num[i]);
}
//sort array
for (i=0; i< (4); i++) // element to be compared
{
for(j = (i+1); j < 5; j++) // rest of the elements
{
if (num[i] < num[j]) // descending order
{
temp= num[i]; // swap
num[i] = num[j];
num[j] = temp;
}
}
}
//print sorted array
printf("\nSorted array:\n");
Selection Sort
The selection sort is a combination of searching and sorting.
During each pass, the unsorted element with the smallest (or largest) value is
moved to its proper position in the array.
The number of times the sort passes through the array is one less than the number of
items in the array. In the selection sort, the inner loop finds the next smallest (or
largest) value and the outer loop places that value into its proper location.
Let's look at our same table of elements using a selection sort for descending order.
Remember, a "pass" is defined as one full trip through the array comparing and if
necessary, swapping elements.
Array at beginning: 84 69 76 86 94 91
After Pass #1: 84 91 76 86 94 69
62
After Pass #2: 84 91 94 86 76 69
After Pass #3: 86 91 94 84 76 69
After Pass #4: 94 91 86 84 76 69
After Pass #5 (done): 94 91 86 84 76 69
While being an easy sort to program, the selection sort is one of the least
efficient. The algorithm offers no way to end the sort early, even if it
begins with an already sorted list.
Shell Sort
The shell sort is named after its inventor D. L. Shell. Instead of comparing adjacent
elements, like the bubble sort, the shell sort repeatedly compares elements that are a
certain distance away from each other (d represents this distance). The value
of d starts out as half the input size and is halved after each pass through the array.
The elements are compared and swapped when needed. The equation d= (N + 1) / 2
is used. Notice that only integer values are used for d since integer division is
occurring.
Let's look at our same list of values for descending order with the shell
sort. Remember, a "pass" is defined as one full trip through the array
comparing and if necessary, swapping elements.
Array at beginning: 84 69 76 86 94 91 d
After Pass #1: 86 94 91 84 69 76 3
After Pass #2: 91 94 86 84 69 76 2
63
After Pass #3: 94 91 86 84 76 69 1
After Pass #4 (done): 94 91 86 84 76 69 1
First Pass: d = (6 + 1) / 2 = 3. Compare 1st and 4th , 2nd and 5th, and 3rd and 6th
items since they are 3 positions away from each other))
Second Pass: value for d is halved d = (3 + 1) / 2 = 2. Compare items two places
away such as 1st and 3rd ……
Third Pass: value for d is halved d = (2 + 1) / 2 = 1. Compare items one place away
such as 1st and 2nd …..
Last Pass: sort continues until d = 1 and the pass occurs without any swaps.
This sorting process, with its comparison model, is an efficient sorting algorithm.
Quick Sort
The quicksort is considered to be very efficient, with its "divide and conquer"
algorithm. This sort starts by dividing the original array into two sections (partitions)
based upon the value of the first element in the array. Since our example sorts into
descending order, the first section will contain all the elements greater than the first
element. The second section will contain elements less than (or equal to) the first
element. It is possible for the first element to end up in either section.
= 1st partition 86 94 91 84 69 76
= 2nd partition 94 91 86 84 69 76
94 91 86 84 69 76
64
94 91 86 84 69 76
Done: 94 91 86 84 76 69
This sort uses recursion - the process of "calling itself". Recursion will be
studied at a later date.
int middle;
if (top < bottom)
{
middle = partition(num, top, bottom); quicksort(num, top,
middle); // sort first section quicksort(num, middle+1,
bottom); // sort second section
}
return;
}
do
{
i++;
} while (x <array[i]);
if (i < j)
{
temp = array[i];
array[i] = array[j];
65
array[j] = temp;
}
}while (i < j);
return j; // returns middle subscript
}
Merge Sort
The merge sort combines two sorted arrays into one larger sorted array.
As the diagram below shows, Array A and Array B merge to form Array C.
Here is how it works: The first element of array A is compared with the first element
of array B. If the first element of array A is smaller than the first element of array B,
the element from array A is moved to the new array C. The subscript of array A is
now increased since the first element is now set and we move on.
If the element from array B should be smaller, it is moved to the new array C. The
subscript of array B is increased. This process of comparing the elements in the two
arrays continues until either array A or array B is empty. When one array is empty,
any elements remaining in the other (non-empty) array are "pushed" into the end of
array C and the merge is complete.
66
}
indexC++; //move to the next position in the new array
}
// Move remaining elements to end of new array when one merging array is
empty while (indexA < 5)
{
arrayC[indexC] =
arrayA[indexA]; indexA++;
indexC++;
}
while (indexB < 5)
{
arrayC[indexC] =
arrayB[indexB]; indexB++;
indexC++;
}
return;
}
SEARCHING ARRAYS
When working with arrays, it is often necessary to perform a search or "lookup" to
determine whether an array contains a value that matches a certain key value The
process of locating a particular element value in an array is called searching. There
are two types of search mechanisms: serial/linear search and binary search
a) Serial Search
The technique used here is called a serial search, because the integer elements of the
array are compared one by one to the user input being looked for (userValue) until
either a match is found or all elements of the array are examined without finding a
match.
In the code below, if a match is found, the text “T here is a match” is printed on
the form and the execution of the procedure is terminated (Exit Sub). If no match
is found, the program exits the loop and prints the text “No match found”.
#include <stdio.h>
int main()
{
int array[5]={10,7,8,2,5}, searchvalue, c;
67
printf("\n\t%d is present at location
%d.\n", searchvalue, c+1);
break;
}
}
if (c == 5) // if looped more than 5 times ie 6 times
printf("\n\t%d is not present in the array.\n",
searchvalue);
return 0;
}
Binary Search
Binary search uses the concept of splitting your searchable array in two, discarding the half
that does not have the element for which you are looking.
You place your items in an array and sort them. Then you simply get the middle element and
test if it is <, >, or = to the element for which you are searching. If it is less than, you discard
the greater half, get the middle index of the remaining elements and do it again. Binary search
divides your problem in half every time you execute your loop.
#include <stdio.h>
int main()
{
int c, first, last, middle, n, search, array[100];
first = 0;
last = n - 1;
middle = (first+last)/2;
68
}
if ( first > last )
printf("Not found! %d is not present in the list.\n", search);
return 0;
}
LINKED LISTS
A linked list is a dynamic data structure whose length can be increased or decreased at
run time.
How Linked lists are different from arrays? Consider the following points :
• An array is a static data structure. This means the length of array cannot
be altered at run time. While, a linked list is a dynamic data structure.
• In an array, all the elements are kept at consecutive memory locations while
in a linked list the elements (or n des) may be kept at any location but still
connected to each other.
When to prefer linked lists over arrays? Linked lists are preferred mostly when you
don’t know the volume of data to be stored. For example, In an employee
management system, one cannot use arrays as they are of fixed length while any
number of new employees can join. In scenarios like these, linked lists (or other
dynamic data structures) are used as their capacity can be increased (or decreased) at
run time (as an when required).
Linked list basically consists of memory blocks that are located at random
memory locations. Linked lists are connected through pointers.
POINTERS
A pointer is a variable whose value is the address of another variable, i.e., direct
address of the memory location. Like any variable or constant, you must declare
a pointer before you can use it to store any variable address. The general form of
a pointer variable declaration is:
type *var-name;
Here, type is the pointer's base type; it must be a valid C data type and var-name is
the name of the pointer variable. The asterisk * you used to declare a pointer is the
69
same asterisk that you use for multiplication. However, in this statement the asterisk
is being used to designate a variable as a pointer. Following are the valid pointer
declaration:
The actual data type of the value of all pointers, whether integer, float, character, or
otherwise, is the same, a long hexadecimal number that represents a memory address.
The only difference between pointers of different data types is the data type of the
variable or constant that the pointer points to.
There are few important operations, which we will do with the help of pointers very
frequently. (a) we define a pointer variable (b) assign the address of a variable to a
pointer and (c) finally access the value at the address available in the pointer
variable. This is done by using unary operator * that returns the value of the variable
located at the address specified by its operand. Following example makes use of
these operations:
#include <stdio.h>
int main ()
{
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
return 0;
}
When the above code is compiled and executed, it produces result something as
follows:
NULL Pointers in C
70
It is always a good practice to assign a NULL value to a pointer variable in case you
do not have exact address to be assigned. This is done at the time of variable
declaration. A pointer that is assigned NULL is called a null pointer.
#include <stdio.h>
int main ()
{
int *ptr = NULL;
return 0;
}
When the above code is compiled and executed, it produces the following result:
On most of the operating systems, programs are not permitted to access memory at
address 0 because that memory is reserv d by the operating system. However, the
memory address 0 has special significance; it signals that the pointer is not intended
to point to an accessible memory location. But by convention, if a pointer contains the
null (zero) value, it is assumed to point to nothing.
C STRINGS
In C, one or more characters enclosed between double quotes is called a string. C does
not have built-in string data type. Instead, C supports strings using one-dimensional
arrays. A string is defined as a null terminated array i.e. \0. This means that you must
define the array that is going to hold a string to be one byte larger than the largest
string it is going to hold, in order to make room for the null.
To read a string from the keyboard, you must use another of C’s standard library
functions, gets( ) , which requires the stdio.h header file. The gets ( ) function reads
characters until you presss <ENTER>. The carriage return is not stored, but it is
replaced by a null, wich terminates the string. E.g.
#include<stdio.h>
Main ( )
Char str [80];
Int I;
Printf (ËNter a string: \n”);
71
gets(str);
The following declaration and initialization create a string consisting of the word
"Hello". To hold the null character at the end of the array, the size of the
character array containing the string is one more than the number of characters in
the word "Hello".
Initialization of strings
In C, string can be initialized in a different number of ways.
char c[]="abcd";
OR,
char c[5]="abcd";
OR,
char c[]={'a','b','c','d','\0'};
OR;
char c[5]={'a','b','c','d','\0'};
char *c="abcd";
String variable c can only take a word. It is beacause when white space
is encountered, the scanf() function terminates.
#include <stdio.h>
int main(){
char name[20];
printf("Enter name: ");
scanf("%s",name);
printf("Your name is %s.",name);
return 0;
}
72
Output
Here, program will ignore Ritchie because, scanf() function takes only string
before the white space.
The C library function int strcmp(const char *str1, const char *str2) compares
the string pointed to by str1 to the string pointed to by str2.
PARAMETERS
• str1 -- This is the first string to be compared.
• str2 -- This is the second string to be compared.
RETURN VALUE
This function returned values are as follows:
73
Example
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[15];
char str2[15];
int ret;
strcpy(str1, "abcdef");
strcpy(str2, "ABCDEF");
if(ret > 0)
{
printf("str1 is less than str2");
}
else if(ret < 0)
{
printf("str2 is less than str1");
}
else
{
printf("str1 is equal to str2");
}
return(0);
}
More Examples
1) C Program to Find the Length of a String
#include <stdio.h>
int main()
{
char s[1000],i;
printf("Enter a string: ");
scanf("%s",s);
for(i=0; s[i]!='\0'; ++i);
printf("Length of string: %d",i);
return 0;
}
Output
74
printf("Enter first string: ");
scanf("%s",s1);
printf("Enter second string: ");
scanf("%s",s2);
for(i=0; s1[i]!='\0'; ++i); /* i contains length of string
s1. */
for(j=0; s2[j]!='\0'; ++j, ++i)
{
s1[i]=s2[j];
}
s1[i]='\0';
printf("After concatenation: %s",s1);
return 0;
}
Output
QUEUES
Queue is a specialized data storage structure (Abstract data type). Unlike arrays,
access of elements in a Queue is restricted. It has two main operations enqueue and
dequeue. Insertion in a queue is done using enqueue function and removal from a
queue is done using dequeue function. An item can be inserted at the end (‘rear’) of
the queue and removed from the front (‘front’) of t he queue. It is therefore, also
called First-In-First-Out (FIFO) list. Queue has five properties - capacity stands for
the maximum number of elements Queue can hold, size stands for the current size of
the Queue, elements is the array of elements, front is the index of first element (the
index at which we remove the element) and rear is the index of last element (the
index at which we insert the element).
Primitive operations
a) enqueue (q, x): inserts item x at the rear of the queue q
b) x = dequeue (q): removes the front element from q and returns its value.
c) isEmpty(q) : true if the queue is empty, otherwise false.
Example
enqueue(q, ‘A’);
enqueue(q, ‘B’);
enqueue(q, ‘C’);
x = dequeue(q);
enqueue(q, ‘D’);
enqueue(q, ‘E’);
75
x= dequeue (q) -> x= ‘A’
STACKS
A stack is a data structure that allows adding and removing elements in a particular
order. Every time an element is added, it goes on the top of the stack; the only
element that can be removed is the element that was at the top of the stack.
Consequently, a stack is said to have "first in last out" behavior (or "last in, first
out"). The first item added to a stack will be the last item removed from a stack.
76
CHAPTER 7
FILE HANDLING
This chapter explains how C programmers can create, open and close text or binary files
for their data storage.A file represents a sequence of bytes, does not matter if it is a text
file or binary file.
OPENING FILES
You can use the fopen( ) function to create a new file or to open an existing file, this call
will initialize an object of the type FILE, which contains all the information necessary to
control the stream. Following is the prototype of this function call:
Here, filename is string literal, which you will use to name your file and access mode
can have one of the following values:
Mode Description
r Opens an existing text file for reading purpose.
Opens a text file for writing, if it does not exist then a new file is created. Here
w
your program will start writing content from the beginning of the file.
Opens a text file for writing in appending mode, if it does not exist then a new file
a is created. Here your program will start appending content in the existing file
content.
r+ Opens a text file for reading and writing both.
Opens a text file for reading and writing both. It first truncate the file to zero
w+
length if it exists otherwise create the file if it does not exist.
Opens a text file for reading and writing both. It creates the file if it does not exist.
a+
The reading will start from the beginning but writing can only be appended.
If you are going to handle binary files then you will use below mentioned access modes
instead of the above mentioned:
CLOSING A FILE
To close a file, use the fclose( ) function. The prototype of this function is:
77
The fclose( ) function returns zero on success, or EOF if there is an error in closing the
file. This function actually, flushes any data still pending in the buffer to the file, closes
the file, and releases any memory used for the file. The EOF is a constant defined in the
header file stdio.h.
There are various functions provide by C standard library to read and write a file
character by character or in the form of a fixed length string. Let us see few of the in the
next section.
WRITING A FILE
The function fputc() writes the character value of the argument c to the output stream
referenced by fp. It returns the written character written on success otherwise EOF if
there is an error. You can use the following functions to write a null-terminated string to
a stream:
The function fputs() writes the string s to the output stream referenced by fp. It returns a
non-negative value on success, otherwise EOF is returned in case of any error. You can
use int fprintf(FILE *fp,const char *format, ...) function as well to write a string into a
file. Try the following example:
#include <stdio.h>
main()
{
FILE *fp;
fp = fopen("/tmp/test.txt", "w+");
fprintf(fp, "This is testing for fprintf...\n");
fputs("This is testing for fputs...\n", fp);
fclose(fp);
}
When the above code is compiled and executed, it creates a new file test.txt in /tmp
directory and writes two lines using two different functions. Let us read this file in next
section.
READING A FILE
78
The fgetc() function reads a character from the input file referenced by fp. The return
value is the character read, or in case of any error it returns EOF. The following
functions allow you to read a string from a stream:
The functions fgets() reads up to n - 1 characters from the input stream referenced by fp.
It copies the read string into the buffer buf, appending a null character to terminate the
string.
If this function encounters a newline character '\n' or the end of the file EOF before they
have read the maximum number of characters, then it returns only the characters read up
to that point including new line character. You can also use int fscanf(FILE *fp, const
char *format, ...) function to read strings from a file but it stops reading after the first
space character encounters.
#include <stdio.h>
main()
{
FILE *fp;
char buff[255];
fp = fopen("/tmp/test.txt", "r");
fscanf(fp, "%s", buff);
printf("1 : %s\n", buff );
When the above code is compiled and executed, it reads the file created in previous
section and produces the following result:
1 : This
2: is testing for fprintf...
Let's see a little more detail about what happened here. First fscanf() method read just
This because after that it encountered a space, second call is for fgets() which read the
remaining line till it encountered end of line. Finally last call fgets() read second line
completely.
79
There are following two functions, which can be used for binary input and output:
Both of these functions should be used to read or write blocks of memories - usually
arrays or structures.
80
Chapter 8
SOFTWARE DOCUMENTATION
Software documentation is written text that accompanies computer software. It both
explains how the software operates or how to use it and may mean different things to
people in different roles.
Importance of software documentation
1. Provide for communication among team members
2. They should provide information for management to help them plan, budget and
schedule the software development process.
3. It acts as an information repository to be used by maintenance engineers
4. Describe to users how to operate and administer the system
5. In all software projects some amount of documentation should be created prior to
any code being written for example Design docs, etc.
6. Documentation should continue after the code has been completed for example
User’s manuals, etc.
The two main types of documentation created are Process and Product documents
PROCESS DOCUMENTATION
(a) Used to record and track the development process
Planning documentation
Cost, Schedule, Funding tracking
Schedules
Standards e.t.c.
(b) This documentation is created to allow for successful management of a software
product
(c) Has a relatively short lifespan
(d) Only important to internal development process
(e) Except in cases where the customer requires a view into this data
(f) Some items, such as papers that describe design decisions should be extracted and
moved into the product documentation category when they become implemented
PRODUCT DOCUMENTATION
Describes the delivered product
Must evolve with the development of the software product
There are two main categories of process documentation:
1. System Documentation
This describes how the system works, but not how to operate it
Examples:
Requirements Spec
Architectural Design
81
Detailed Design
Commented Source Code
Including output such as JavaDoc
Test Plans
Including test cases
V&V plan and results
List of Known Bugs
2. User Documentation
User Documentation has two main types
End User
System Administrator
In some cases these are the same people. The target audience must be well understood.
There are five important areas that should be documented for a formal release of a
software application. These do not necessarily each have to have their own document, but
the topics should be covered thoroughly. These include:
Functional Description of the Software
Installation Instructions
Introductory Manual
Reference Manual
System Administrator’s Guide
Document Quality
Providing thorough and professional documentation is important for any size product
development team
Document Structure
All documents for a given product should have a similar structure
The authors “best practices” are:
Put a cover page on all documents
Divide documents into chapters with sections and subsections
Add an index if there is lots of reference information
Add a glossary to define ambiguous terms
82