C Programming

Handling Multiple Choices

2012-06-15T20:33:00.000-07:00

In many occasions we come across situations where we are required to choose one thing out of many. This can be handled by using nested if - else if - else if ... else structure.

C also provides a special control structure that allows us to handle such cases effectively, rather than using a series of if statements.

Case Control Structure

The control structure in C, which allows as to make a selection out of a number of choices is called a switch. It consists of three keywords switch - case - default.

Syntax : switch (<expression>) <statement>
case <constant expression>
default;

switch <expression>
{
case <constant expression>:
do this;
case <constant expression>:
do this;
default :
do this;
}

switch Causes control to branch to one of a list of possible statements in the block defined by <statement>

case The list of possible branch points within <statement> is determined by preceding sub statements with case <constant expression>; where <constant expression> must be an int and must be unique.

Once a value is computed for <expression>, the list of possible <constant expression> values determined from all case statements is searched for a match. If a match is found, execution continuous until a break statementis encountered or the end of <statement> is reached.

default If a switch is not found and "default : " statement prefix is found within <statement>, execution continues at this point. Otherwise<statement> is skipped entirely.

The loop control structure

The programs so far we have discussed followed either a sequential or a decision control structure. In the sequential structure the execution of statements was carried out in a fixed order while in the selection structure the execution of statements was carried out depending on the outcome of a condition being over, with variations in the details each time. The structure that meets this need is the Repetitive Control Structure and its action is termed 'looping'.

Repetition

The versatility of a computer lies in its ability to perform a set of instructions repeatedly. This involves repeating some parts of a program, a specified number of times or until a particular condition is full-filled. This is achieved by using the 'Repititive' or loop control structure.

/* Day of week */
#include <stdio.h>
#include <conio.h>
int main()
{
int day;
printf(“Enter day of the week : ”);
scanf(“%d”, &day);
switch (day)
{
case 1:
printf(“Today is Sunday \n”);
break;
case 2:
printf(“Today is Monday \n”);
break;
case 3:
printf(“Today is Tuesday \n”);
break;
case 4:
printf(“Today is Wednesday \n”);
break;
case 5:
printf(“Today is Thursday \n”);
break;
case 6:
printf(“Today is Friday \n”);
break;
case 7:
printf(“Today is Saturday \n”);
break;
default :
printf(“Wrong entry! \n”);
}
}

Transferring Control of a Program Unconditionally

2012-06-15T11:21:00.001-07:00

Syntax : goto <identifier>;
keyword transfers the control of a program unconditionally, to the location of a local label specified by <identifier>

Note: The use of goto statement is usually avoided in good programming practice. A program code can be restructured to avoid goto statement. Do not goto a label inside a repetitive structure or a switch statement.

getchar() is a macro that gets a character from stdin. Note that getchar reads from stdin and is line
buffered; ie. it will not return until you press enter.

getch() reads a single character from the keyboard without echoing to the screen.

getche() reads a single character from keyboard and echoes to the screen.

getc() is a macro that gets one character from a stream. It returns the next character on the given input
stream and increments the stream's file pointer point to the next character.
Declaration int getc(FILE a Stream);

gotoxy - Positions cursor in a text window
Syntax : gotoxy(int x, int y) If the co-ordinates are invalid, the call to gotoxy is ignored.

/* Larger number*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int main()
{
int a, b, c, max;
start:
printf(“Enter a number : ");
scanf(“%d”, &a);
printf(“Enter another : ");
scanf(“%d”, &b);
if (a = = b)
{
printf(“\n Please enter two different numbers \n”);
gotoxy(5,20);
printf(“Press any key to continue ...\n”);
getch();
goto start;
}
else if (a>b)
max = a;
else
max = b;
printf(“\n The larger number is %d\n”, max);
}

/* Weather */
# include <stdio.h>
# include <conio.h>
# define max_temp 35
# define min_temp 25
# define max_humi 30
# define min_humi 15
int main()
{
float temp, humi;
printf(“Enter today’s temperature : ”);
scanf(“%f”, &temp);
printf(“Enter humidity : ”);
scanf(“%f”, &humi);
if (temp > max_temp && humi > max_humi)
printf(“\n Today is Hot and humid \n”);
else if (temp > max_temp && humi < min_humi)
printf(“\n Today is Hot and dry \n”);
else if (temp < min_temp && humi > max_humi)
printf(“\n Today is cold and humid \n”);
else if (temp < min_temp && humi < min_humi)
printf(“\n Today is dry and cold \n”);
else if (temp > max_temp || temp <min_temp || humi > max_humi || humi < min_humi)
printf(“\n Weather is not norma l\n”);
else
printf(“\n Weather is normal \n”);
}

Controlling the FLOW of a Program

2012-06-13T20:03:00.001-07:00

Controlling the FLOW of a Program

The execution of statements in our programs discussed so far followed an order or sequence. The first statement at the top of the program is executed, then the next statement, then the statement after that and so on, until the last is executed. This is called sequential
execution. In other words it is the execution of a sequence of instructions in the same order as they appear in the sequence. Such type of a program structure is called a sequence structure.

But what if we want the computer to execute either one statement or another depending on what has
happened before? Surely we need something that can control the flow of the instructions in our program.
Such a structure is known as a control structure.

Control Structures

Control Structures are the elements of a programming language that determine the flow of program
execution.
All high-level programming languages have control structures. They allow the programmer to express
computer instructions is a very natural way. They fall in to two distinct classes:
1) Selection (Conditional execution)
2) Repetition
Conditional execution means that an instruction executes when a specified condition occurs. Repetition
control structures use conditions to determine how many times to repeat execution of an action.

The if (keyword)

C programs use if.. else control statement to test conditions and execute one of two statements of statement blocks depending on the condition.

Syntax : a) if (expression) b) if (expression)
<statement 1>; <statement 2>;
else
<statement 2>;
In a) If the (expression) is not zero when evaluated <statement 1> is executed
In b) If the (expression) is not zero when evaluated <statement 1> is executed
and if the expression is zero when evaluated <statement 2> is executed.

Termination of a Program

exit() terminates a program / terminates a calling process. Before termination it closes all files, writes buffered out put and calls any registered "exit function".

/* Age check */
#include<stdio.h>
#include<conio.h>
int main()
{
int age;
printf("Enter your age : ");
scanf("%d",&age);
if (age>=18)
printf("\n You are eligible for voting \n");
}

/* Height check*/
#include<stdio.h>
#include<conio.h>
int main()
{
int height;
printf("Enter your height : ");
scanf("%d",&height);
if (height>=5)
printf("\nYou are tall \n");
else
printf("\n You are short \n");
}

/* Bonus years*/
# include<stdio.h>
# include<conio.h>
# define bonus_rate 10/100;
int main()
{
int current_year, year_join ;
float salary, bonus;
printf(“Enter current year and year of join [yyyy] : ”);
scanf(“%4d %4d”, &current_year, &year_join);
printf(“\n Enter salary : ”);
scanf(“%f”, &salary);
if (current_year - year_join >= 3)
{
bonus = salary * bonus_rate;
printf(“\nBonus = Rs. %.2f \n”, bonus);
}
else
printf(“No bonus \n”);
}

/* Hot, Cold or Nice*/
# include <stdio.h>
# include <conio.h>
# define max_temp 35
# define min_temp 25
int main()
{
float temp;
printf(“Enter today’s temperature : ”);
scanf(“%f”, &temp);
if (temp > max_temp)
printf(“\n Today is Hot \n”);
else if (temp < min_temp)
printf(“\n Today is Cold \n”);
else
printf(“\n The weather is nice \n”);
}

/* Final marks */
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int main()
{
int marks;
printf("Enter your marks (0..100): ");
scanf("%d",&marks);
if (marks>100 || marks<0)
{
printf("\n Please enter correct value \n");
exit(0);
}
else if (marks = = 100 || marks = =0)
;
else if (marks % 10 >=5)
marks ++;
else
marks --;
printf("\nYour final marks %d \n",marks);
}

Expressions, Operators and Punctuators-2

2012-06-12T20:03:00.001-07:00

Punctuators

[] Brackets () Parentheses

{} Braces , Comma

; Semi-colon : Colon

… Ellipses * Asterisk

= Equal sign # Pound sign

Arithmetic Operators

+ Unary plus

- Unary minus

+ Addition

- Subtraction

* Multiplication

/ Division

Logical Operators

Logical Operators use True / False properties of expressions to return a true or false value. In C the true result of an expression is non zero. When a non zero value is subjected to a logical operation, the value is converted to 1. False values are always 0.

&& Logical AND

|| Logical OR

! Unary NOT

Increment and Decrement Operators

C includes several unique operators. Two of them are ++ (increment) and – (decrement) operators.

They can be placed before (prefix) or after (postfix) a variable.

++ Increment

-- Decrement

Eg:-

/* Logical Operators */

#include<stdio.h>

#include<conio.h>

int main()

{

int a,b,c;

printf("Enter an integer:");

scanf("%d",&a);

b = (a>0);

printf("a = %d\n",a);

printf("b = %d\n",b);

c = a||b;

printf("c = %d\n",c);

c = a && b;

printf("c = %d\n",c);

}

/* Prefix */

#include<stdio.h>

#include<conio.h>

int main()

{

int a;

a = 2;

printf("a = %d\n",a);

printf("++a = %d\n",++a);

printf("a = %d\n",a);

printf("--a = %d\n",--a);

printf("a = %d\n",a);

}

Comma [.] Operator

Expressions can be separated by commas. In C each comma-separated expression will be evaluated and the value returned from the group is the value of the right most expression.

/* Comma Operator */

#include<stdio.h>

#include<conio.h>

int main()

{

int a;

a = 2;

printf("%d\n",a);

printf("%d%d\n",a,++a);

printf("%d%d%d\n",a,++a,a);

printf("%d%d%d\n",a,--a,a);

printf("%d%d\n",a,a++);

printf("%d%d\n",a,a--);

printf("%d%d%d%d\n",a,a++,a--,a);

}

Assignment Operators

C has a number of assignment Operators. Each assignment statement itself returns a value. The value that

it returns is the value that is assigned to the variable on the left side of the assignment. So, in C you will be

able to use an expression such as x = y = z = 0; The assignment operator has right to left associativity.

= Assignment += Addition assignment

-= Subtraction assignment *= Multiplication assignment

/= Division assignment %= Modulus assignment

<<= Shift left assignment >>= Shift right assignment

&= Bitwise AND assignment != Bitwise OR assignment

^= Bitwise XOR assignment

/* Assignment Operators */

#include<stdio.h>

#include<conio.h>

int main()

{

int a, b;

unsigned int p, q;

float c;

a = b = 2;

a += 3;

printf("a =%d\n",a);

b *= a;

printf("b =%d\n",b);

p = q = 61234;

printf("p = %u\n",p);

c = p/= 100;

printf("c =%.2f\n",c);

q %= 10;

printf("q = %u\n",q);

}

Conditional Operator [? : ]

The conditional operator tests an expression and returns the result of one of two other expressions depending on the true / false value of the first.

Syntax: <Expression1> ? <Expression 2>:<Expression 3>

The evaluation tests the first expression. If that value is true, the resulting value is that of the second expression; otherwise the resulting value is the third expression

/* ? : Operator*/

#include<stdio.h>

#include<conio.h>

int main()

{

float u,p,q,d;

u=200.00;

printf("Quantity purchase:");

scanf("%f",&q);

d=q>=50 ? u*20.0/100 :0;

p=q*(u-d);

printf("Final price =%.2f",p);

}

Bitwise Shift Operators

E1 << E2 - Left shift E1 - Shift expression

E1 >> E2 - Right shift E2 - Additive expression

The operands must be of Integral type and the operation is invalid

a) if the addtive expression is negative

b) If addtive expression is greater than or equal to the width of the shift expression.

Bitwise Operators Logical

The bitwise operators work on the principles of Boolean Logic – a branch of mathematics that assumes two state (True or False) variables.

/* Bitwise Logical Operators */

#include<stdio.h>

#include<conio.h>

int main()

{

int a,b,c;

a=65;

b=16;

c= a & b;

printf("c=%d \n",c);

c= a | b;

printf("c=%d \n",c);

c=~a;

printf("c=%d\n", c);

c=a^b;

printf("c=%d\n", c);

}

Expressions, Operators and Punctuators

2012-06-12T19:39:00.002-07:00

Variable names, function names, array names, constants, function calls, array references, structure references are all considered expressions. Applying a unary operator to one of these appropriate expressions or combining two or more expressions also leads to an expression. An expression enclosed within parentheses is also an expression.

An expression that may be assigned a value is known as an Lvalue. An lvalue expression is required in certain places: The expression on the left hand side of an assignment operator must be an lvalue. The increment and decrement operators can only be applied to lvalue, as can the unary address operator ‘&’. An lvalue is also required to the left of the structure member operator ‘.’.

Operators with their Precedence

The operators in C can be Arithmetic, Relational, Logical, Increment, Decrement and Bitwise Logical. Most of theoperators are binary; that means they need two operands. Unary Operators need only one operand.
Turbo C/C++ operators are divided into 16 categories. The #1 category has the highest precedence.
Category #2 takes the second and so on to the comma (,) operator that has the lowest.

Standard Inputs

2012-06-11T03:07:00.001-07:00

scanf() Function

scanf() function reads data from a standard input device into arguments specified by the format string.

scanf(format string, arguments)
Eg:-

/* Input through the keyboard */
#include <stdio.h>
#include <conio.h>
int main()
{
int x,y,sum;
printf("Enter an Integer:");
scanf("%d",&x);
printf("Enter another:");
scanf("%d",&y);
sum = x + y ;
printf("sum =%d \n",sum);
}

/* Floating point Numbers */
#include <stdio.h>
#include <conio.h>
int main()
{
float x,y,sum;
printf("Enter a number:");
scanf("%f",&x);
printf("Enter another:");
scanf("%f",&y);
sum = x + y ;
printf("sum =%.2f \n",sum);
}

/* Employee Data */
#include <stdio.h>
#include <conio.h>
int main()
{
int empnum;
char name[10];
int dd, mm , yyyy;
float salary;
printf("Enter employee number:");
scanf("%d",&empnum);
printf("Enter name :");
scanf("%10s", &name);
printf("Enter date dd/mm/yyyy :");
scanf("%2d %2d %4d", &dd, &mm, &yyyy);
printf("Enter salary :");
scanf("%f",&salary);
printf("\n");`
printf("Emp Num :%d \n", empnum);
printf("Name :%s\n", name);
printf("Date of employment :%d%c%d%c%d\n", dd,'/',mm,'/', yyyy);
printf("Salary :%7.2f\n",salary);
}

Reading a character

getc()

getc() is a macro that reads one character from a stream.

getchar()

getchar() is a macro that gets a character from stdin. It returns the next character on the input stream stdin.

/* Reading a character from the keyboard */
#include <stdio.h>
int main()
{
char ch;
printf("Enter a character:");
ch = getc(stdin);
printf("You have entered the character %c\n",ch);
}

Reading a String

gets() Function - Reads a string from a stdin.

/* Reading a string from the keyboard */
#include <stdio.h>
int main()
{
char string[80];
printf("Enter a word:");
gets(string);
printf("You have entered %s\n",string);
}

Assignments

2012-06-08T06:24:00.002-07:00

Once we decide the data types and variables to be used in a program we can assign values to them.

First declare and then assign

Both declare and assign at the same time

Creating a new name for a Data Type

To create a new name for an existing data type the keyword typedef is used.
E.g. typedef int integer;

sizeof()
The sizeof() operator in C is used to obtain the amount of memory (bytes) allocated for a variable of a
given data type.
E.g. sizeof(int)

putchar() - putchar() is a macro that outputs a character on stdout.

/* Output a Character */
#include <stdio.h>
#include <conio.h>
#define msg "End of Program"
int main()
{
char a ;
a =100;
printf("%d\n",a);
putchar(a);
putchar(10);
putchar(13);
putchar(a+1);
puts(msg);
}

/* Area of a circle */
#include <stdio.h>
#include <conio.h>
int main()
{
int r ;
float pi;
pi = 22/7.;
r = 7;
printf("%s%5.2f \n","The area of the circle =" ,pi*r*r);

}

Standard Input

scanf() Function
scanf() function reads data from a standard input device into arguments specified by the format string.
scanf(format string, arguments)

/* Input through the keyboard */
#include <stdio.h>
#include <conio.h>
int main()
{
int x,y,sum;
printf("Enter an Integer:");
scanf("%d",&x);
printf("Enter another:");
scanf("%d",&y);
sum = x + y ;
printf("sum =%d \n",sum);
}

/* Floating point Numbers */
#include <stdio.h>
#include <conio.h>
int main()
{
float x,y,sum;
printf("Enter a number:");
scanf("%f",&x);
printf("Enter another:");
scanf("%f",&y);
sum = x + y ;
printf("sum =%.2f \n",sum);
}

Constants and Variables

2012-06-07T03:30:00.001-07:00

Constants

The C language is composed of seven basic types of code: Constants, Variables, Operators, Punctuations,Keywords, Functions and Labels – collectively known as Tokens.

A constant is a named storage location in the memory where the compiler keeps unchanged data during
program execution. Constants are of two types: Literal Constants and Symbolic Constants.
A literal constant is a value that is directly used in the source code wherever it is needed.
E.g. int max = 100; integer constant
float tax = 0.05; floating point constant.
float multiplier = 2.03E-2 floating point constant (in scientific notation)

Integer constants can be written in three different notations.

An integer constant starting with any digit other than 0 is treated as a decimal integer. It can contain a leading + or -.
A constant starting with a 0 is treated as an octal integer. It can contain a leading + or -.
A constant starting with a 0x or 0X is treated as a Hexadecimal integer. It can contain digits from 0to 9 the letters A to F and a leading + or -.

Symbolic Constants

A symbolic constant is a constant that is represented by a symbol (name) in a program.

A non numeric constant may consist of letters, digits, and other characters.

The literals enclosed in single quotes are referred to as character values. Others those enclosed in

double quotes are called character strings. In C you can use a name to represent a constant. The value

associated with a constant cannot be changed or reassigned.

Eg: ‘a’, ‘b’, ‘,’, ‘;’ - character constants.

“Hello”, “Information”, “31/12/1999” - string constants.

Numeric constants in C are made up of digits and can include decimal points and contain letters and do

not have single or double quotes.

Constants can be defined by using by using the # define construct.

Eg: # define a 10

# define ch ‘a’

# define msg “End of Program”

Variable

A variable is a named memory location in the computer’s memory where different values of a certain type of data can be stored.

Variable Names

In C, a name given to a variable must satisfy the following rules.

The name can contain letters, digits and the underscore character.
The first character of the name must be an alphabet or an underscore. However the use of an underscore is not recommended.
C is case sensitive. So C treats X and x as two different variables.
Keywords cannot be used as variable names

C compilers allow long variable names. However most of the C compilers recognize the first 32 characters.

In C / C++ it is necessary to declare variables before they are used in a program. When a variable is

declared it is designated as belonging to one of the data types used in C. The compiler allocates memory for the variable according to its data type.

Variable Declaration

Eg. /* Adding two integers */

#include <stdio.h>

#define msg “End of Program”

int main()

{

int a,b,c;

a=2;

b=3;

c=a+b;

printf(“%d%s%d%s%d\n”,a,”+”,b,”=”,c);

puts(msg);

}

/* Adding Two Floating Point Numbers */

#include <stdio.h>

#define msg "End of Program"

#include <conio.h>

int main()

{

int a ;

float b;

a=123;

b=123;

printf("%5d\n",a);

printf("%+05d\n",a);

printf("%.5f\n",b);

puts(msg);

}

Initializing Variables

Initializing is the process of assigning a variable its first value.

The Formatted Output of a C Program

2012-06-06T10:46:00.000-07:00

printf() function

The printf() function is one of the most widely used functions in C. The purpose is to output its argument

list to the standard output device. All the characters within a pair of double quotes will be treated as a

string constant except for escape sequences and conversion specifications.

Escape Sequence

\ tells the compiler to treat the following characters in a different way.

Format Control Codes

In the printf() function the control string contains format commands that tells printf() how to display the
remaining arguments and how many arguments are there.

Eg: 1) printf(“%d\n”,2); => 2 2) Printf(“%f\n,2.01) => 2.010000

My First C Program
#include<stdio.h>
int main()
{
printf("Hello World");
return(0);
}

puts() function

puts() is a simpler version of printf() taking only a single string argument and performing no formatting.
puts() automatically appends a new line after displaying the string.

/* Put a String */
#include <stdio.h>
#define mychoice “IT Faculty – Moratuwa University”
main()
{
puts(mychoice);
return(0);
}

/* Escape Sequences */
#include <stdio.h>
main()
{
printf(“C\t U\t Later \n”);
return(0);
}

Introduction to C

2012-06-05T11:16:00.002-07:00

C is a general purpose high-level language developed by Dennis Ritchie and Brain Kernighan at AT&T Bell Laboratories of USA in 1972. Originally it was designed to run on a PDP-11 under UNIX operating system. C was influenced by two related languages BCPL and B. Although it was originally intended to run under UNIX, there has been a great interest in running it under MS-DOS on IBM-PC.

Many high-level languages like Pascal are highly disciplined and structured. C is much more flexible and free-wheeling. This freedom gives C much more power that experienced users can employ.

C has been a popular language due to its simplicity of expression, the compactness of the code,
extensive use of function calls and the wide range of applicability. C is cryptic in nature. It allows the programmer a wide range of operations from high-level up to low-level.

Structure of a C Program

A, C program basically has the following structure.

Pre-processor commands
Type definitions
Function prototypes
Variables
Functions

Structure of a Function

Function name (parameters)
{
local variables ;
statements ;
}

The Minimum C Program

main()
{
}

Note: Every C program must have one and only one main function. The { } groups the statements
together.

Stages in Creating a C program

Designing [will be discussed later]
Coding

You must first create a file which contain the C source code. For this you may use any text
editor. The file name could be any legal name accepted by the DOS / UNIX and must have an
extension of C.
E.g. pro1.c

The source code that you enter must obey the structures, the syntax and semantics of the C language.

Compiling

The C compiler receives the source code from the pre-processor and translates it in to
assembly code.

Assembling

The assembler creates object code. In MSDOS the object files are seen with .obj extension.

Linking

If a source file references library functions defined in other source files, the link editor combines these functions with main() to create an executable file (.EXE)

The Pre-Processor

The pre-processor accepts source code as input and is responsible for
1. removing comments
2. Interpreting special pre-processor directives denoted by #.

Directives in a Program

A directive is a special statement that can control the features of a compiler.
E.g. a) #include <stdio.h> provides a convenient way of telling the compiler that all the I/O functions have been included. ;
b) #include <math.h> provides the standard math library.
c) #define defines a symbolic name or a constant.

Comments in a Program

Any text that you enter between /* and */ is considered to be a comment and is ignored by
the compiler.

White Space Characters

The characters - space, Tab, Carriage Return (CR), Line Feed (LF) and Back Space are

considered to be white space characters and they will be ignored by the compiler.

Statement Terminator

In C a line of text can contain several statements and a statement can straddle several lines. So the ; tells the compiler how to find the end of a statement. You can also have a ; without having a prior statement where an action is not required.

No ; is required after an #include directive

What is programming

2012-06-05T08:54:00.000-07:00

What is Programming?

The roots of man-machine relationship runs back to thousands of years. Today, we manipulate various kinds of machines. Out of myriads of machines available for the human, the computer has become the foremost, due to the fact that it is programmable and versatile.

Like all other machines, computers are not wise. But it is made to obey and work according to a set of instructions given by the human. These instructions are stored in the computer’s memory and the computer is allowed to follow them in the given sequence. Thus computers provide a close association with human in the context of solving real world tasks. This has paved the way to, what is called “Computer Programming”.

Programming

The core activity in the process of instructing a computer in solving problems is known as programming.

Program

An ordered set of instructions given to a computer to accomplish a given task is known as a program.
[ Programming is the art of designing, coding, modifying and testing programs.]

Man-Machine Communication

Conveying human thoughts to a computer in solving problems is not easy. Human beings are intelligent. They use natural languages, signals, symbols etc. in exchanging ideas among them.
Computers on the other hand are dumb. They can only understand their native language called
machine language, which comprises of streams of bits and bytes. So one choice of programming a
computer is to use machine language, in its native form.

Early Stages in Programming

The earliest computers were not programmed in the same way as today’s computers, instead the
programs were hard-wired into the machine and the physical wiring was done by hardware experts. In order to modify such a program, the programmer had to rearrange the wiring.
It was not long before John Von Neumann exposed the concept of sharing the same memory by both programs and data. In this case the programs were entered into the memory through a switch panel as a stream of bits.

Machine Oriented Languages

Programming a computer in machine language is an extremely difficult process. Machine language is tedious, because so much of program code is needed to accomplish even simple tasks. One should know the internal mechanism of the PU thoroughly to work with it. Machine language also differs from PU to PU and is difficult to read and modify.
To make the programmer’s job little easier, another type of programming language called Assembly Language was developed. An instruction in assembly language is in an ‘easy to remember’ form called a mnemonic.

For example instructions to add, subtract, multiply and divide in machine language and assembly
language might look like as follows

M/C Instruction Assembly Instruction (mnemonic)
0000000111011000 ADD
0010100111011000 SUB
1111011111100011 MUL
1111011111110011 DIV

The main problem with assembly language when compared to machine language is that an assembly language program cannot be directly executed by a computer. It needs another program to read assembly code and translate it into machine language. A program that performs this task is called an assembler.

Development of the assembly language and assemblers placed the programming task in the correct
track, but the programmers did not get much relief as they were still forced to think in terms of bits and bytes.

Getting Closer to Natural Languages

Human thoughts originate in its natural form. Natural languages (English, French, Germen, etc.) play the major role in expressing human ideas. Therefore the development of computer languages those closely resemble natural languages was essential to program computers. Such languages are
commonly known as High-level languages. Some examples of high-level languages are PL/I, COBOL, FORTRAN, BASIC and Pascal.

Today there are more than two thousand high-level languages available for programming computers.
Each language has its own objective and structure. For example the BASIC (Beginner’s All purpose
Symbolic Instruction Code) and Pascal languages are originally intended to teach computer
programming; while COBOL (Common Business Oriented Language) is intended to create business
applications such as Payrolls, Stock Control Systems and so on.
Some of the primitive high-level languages are being used extensively even today. This is due to the fact that they had been continuously updated to suite the trends in Information Technology.
For example the BASIC language was developed in 1965. Since then it has been subjected to many
developments and today, its newest version, Microsoft Visual Basic, is used in Rapid Application
Development (RAD). In contrast to high-languages, machine language and assembly language are
known as Low-level languages.
However, C language is unique among most of the high-level languages. It is neither high-level nor lowlevel.
It is rather considered mid-level as it can replace assembly language and still perform high-level
operations Once again, a disadvantage of high-level or mid-level languages is the necessity of a
translator to translate the program code (source code) into machine code (object code).
There are two types of translators used for this purpose; namely an interpreter and a compiler. An interpreter translates one line of code at a time and executes it immediately. An example of a popular interpreter is Microsoft GW-BASIC. Interpreters are more suitable for novice programmers who write small programs and they can run each statement of the code, observing errors and correcting them. Interpreters are not so suitable for large programs where time matters.

A compiler on the other hand reads the whole source code form the beginning to the end and translates it into an object code. Therefore compilers detect errors in advance. An error that encounters in compilation process is known as a compile time error. Such an error has to be corrected and recompiled before the execution.
However, after the compilation the object code is available for execution at any time. The advantage of compilation is that, the compiled code is very compact and runs fast. The disadvantage is that, each time an error is corrected it has to be recompiled.

A brief overview of programming techniques

In the early stages of computing, people neither have powerful computers nor intricate problems to solve as in today using computers. Both the programmers and the users were mostly computer professionals. Yet, programs were written but, in an unstructured way using a handful of programming languages.
An unstructured program consists of one main program module containing the sequence of statements. The data being used in the program are globally visible. i.e. common to the whole program. The suitability of unstructured programming is mostly limited to beginners who write simple programs or small utilities.
However, with the rising demand for IT applications, the things got changed. Today we have
multifarious problems to solve in business, science, industry and everyday life. The most of the
computer users are not computer professionals. So we need more sophisticated and user-friendly
programs to outfit the current trend in Information Technology.
The ability of programmers to organize well-structured solutions to problems is of major importance. In an effort to produce well organized, reliable, easily maintained and efficient programs, a number of guidelines and methodologies were developed.

Procedural Programming

A procedure or function is a self-contained program module that executes a set of specific instructions.The procedural approach focuses on the procedures that must be enacted in order to solve a particular problem. Thus a program can be viewed as a sequence of procedure calls. A procedure calls another (calling procedure) for services. After the sequence of statements in the called procedure is processed, the flow of control continues right after the point where the call was made. A procedure also can call a sub-procedure and in any case, calling procedure and the called procedure are allowed to exchange data in some way.
This form of programming has been in existence the longest, and is still in use today by many
programmers.

Structured Programming

Structured programming can be seen as a subset or sub-discipline of Procedural programming, one of the major paradigms (and probably the most popular one) for programming computers.
It is possible to do structured programming in almost any procedural programming language, but since about 1970 when structured programming began to gain popularity as a methodology, most new procedural programming languages have included features to encourage structured programming, (and sometimes have left out features that would make unstructured programming easy).

Some of the better known structured programming languages are : Pascal, Ada
At the level of relatively small pieces of code, structured programming typically recommends simple, hierarchical program flow structures. These can be obtained in most modern languages by using only structured looping constructs, often named "while", "repeat", "for". Often it is recommended that each loop should only have one entry point and one exit point, and a few languages enforce this.

Object Oriented Programming

Object Oriented Programming is a modern, popular approach to programming which transcends the different generations, and represents an approach and methodology which is becoming the norm rather than the exception.
C++ is the object oriented extension of the C language.
Note that C++ (which we use) incorporates C, meaning that it is possible to use OO languages to program in a procedural manner.
In procedural programming, the main emphasis is on the tasks necessary to effect a solution to the problem - the data on which the procedures act is the secondary focus.
In object-oriented programming the emphasis is reversed with the data being of prime importance and the procedures that act on that data assuming secondary focus.
The OO approach is seen as essential as software projects become more complex.