Notes of programming

ITCP / Programming Techniques / Programming Fundamentals Page 1 of 86
Programming Language Generations
Programming Language Generations are used to represent the major steps or generations
in the evolution of programming languages. Generations of programming languages are
categorized into 5 categories and are:
• First Generation of Programming Language or 1GL
Machine language is considered to be the first generation of programming
language. In machine language the level of instructions and data that the
processor is actually given to work on conventional computers is a string of 0s
and 1s. So, the language of 0s and 1s, i.e. machine language is known to be the
first generation of programming languages.
• Second Generation of Programming Language or 2GL
2GL or second generation language is Assembler (sometimes called Assembly
language). A typical 2GL instruction looks like this:
ADD 12, 8
An assembler converts the assembly language statements into machine
language.
• Third Generation of Programming Language or 3GL
Third generation languages are called High-Level programming languages such
as C/C++, Pascal or Java etc.
A sample Java language statement looks like this:
public static void main(String args[]) {
System.out.println(“Hello Everyone”); }
High-level languages are near to English and the program created in a
high-level language is called source program. Compiled type languages i.e.
C/C++, Pascal, COBOL and Fortran etc and Interpreter based languages i.e.
QBasic, GW-Basic and Visual Basic etc are 3GL.
• Fourth Generation of Programming Language or 4GL
Fourth generation programming language or 4GL is designed to be closer to
natural language than a 3GL. Language for accessing databases are often
described as 4GLs. A 3GL language statement might look like this:
SELECT NAME FROM EMPLOYEES WHERE SALARY > $7000
• Fifth Generation of Programming Language or 5GL
In fifth generation of programming languages, we use a visual or graphical
development interface to create source language that is usually compiled with a
3GL or 4GL compiler. IBM, Microsoft, Borland and other companies make 5GL
programming products.

Introduction to C-Language
C was created by Dennis Ritchie at Bell Labs in 1972, while working to develop Unix
Operating System. It came from Ken Thompson’s B-Language written in 1970.
Levels of Programming Languages
There are 3 levels of programming languages
i) High-Level Language
ii) Middle-Level Language
iii) Low-Level Language
i) High-Level Language
High-Level Language is designed to try to give programmers everything they
could possible want already built into the language.
Following are the high-level languages:
• ADA
• BASIC
• COBOL
• FORTRAN
• Pascal
ii) Middle-Level Language
Middle-Level Language gives programmers a minimal set of control to define
high-level constructs.
Following are the middle-level languages:
• C/C++
• FORTH
iii) Low-Level Language
Low-Level Language forces programmers to define all program functions directly
because nothing is built in the language.
Following are the low-level languages:
• Assembly
C is one of a smallest programming language. It has almost 33 reserve words but
doesn’t restrict the programming style. C is often called a middle-level language.

Advantages of using C-Language
Following are the advantages of using C-Language
i) Structured Format
C offers top-down structured programming approach. C also allows separately
compiled sub-routines to be used without being the part of the program.
ii) Flexibility
Being a general-purpose programming language it can be used for solving
engineering problems or for writing database systems etc
iii) Portability
Programs written on one system can be run on another system with little or very
minor modifications.
iv) Compactness & Efficiency
Programs written in C-Language generate fast and compact code. Programs
compiled by C compilers can run about as fast as those written in Assembler.
v) Personalization
In addition to the built-in functions, C-Language allows the user to add his own
functions to the language. So it can be personalized to fit one needs.
Uses of C/C++ Programming Language
C is meant for designing Operating Systems. 90% of the Unix code is written in C. Areas
other than system programming where C-Language can be used are
• Operating Systems • Network Drivers
• Communication Packages • Data Bases
• Language Interpreters • Utilities
• Language Compilers • Spreadsheets
• Text Editions • etc etc
C/C++ Character Set
C/C++ character set comprises of following characters
A,B,C,….Z
A,b,c,…...z
0,1,2,……9
, . ; : ? ! “ / ‘ | ~
( ) [ ] { } < >
+ - # % _ ^ = & *

White Space Characters
The character that produces blank space when printed is called a white space character,
e.g.
• Spaces
• Tabs
• New Lines
Tokens
A group of characters separated by white space is known as a Token. Following are the
classes of tokens.
i) Keywords
Keywords are the words that make up the C/C++ programming language.
Keywords have special meaning to the C/C++ compiler, so they can not be used
for other than as a keyword. These must be entered in lower case.
ii) Identifiers
Identifiers are used to describe the names of variables, constants and functions in
C/C++, and are also known as Programmer Supplied Words.
iii) Constants
A data object whose pre-set value does not change during the execution of the
program is known as constant, i.e. pie.
iv) Variable
Variable is a data object whose value may change during the execution of the
program.
v) Functions
Functions are routines to perform commands or operations etc, and may return a
value to the calling routine.
vi) String Literals
String Literals are also called a String Constant. It is a sequence of characters
surrounded by double quotes. A null byte 0 is appended to the string so that
programs that scan the string can find its end.
vii) Operators
Operators are symbols that define how values are manipulated. Operators describe
the action that we want to take between the operands.
viii) Other Separators
Other Separators are also using in C/C++.

Naming Rules in C/C++
Following are the naming rules in C/C++
• Can contain letters, digits and underscores.
• Digit can not be the first character.
• Spaces are not allowed.
• May not be same as keyword or function name etc.
• First 40 characters are significant, i.e. Length can be of max. 40 characters, but
varies from compiler to compiler.
• Can not consist of an underscore alone.
Data types and Sizes
There are three main data types in C/C++
i) Character char
ii) Integer int
iii) Floating Point float
i) Character data type
Character data type is represented by char and is used for storing a character,
digit or special character. A character constant must be enclosed in single
quotations i.e. ‘A’, ‘1’ or ‘*’ etc. A variable declared as character uses/occupies
one byte of memory.
A character constant can be signed or unsigned.
• The range of binary numbers in signed char is from -128 to +127
• The range for binary numbers in unsigned char is from 0 to 255
So, there are 3 types of character data type, i.e. char, signed char and unsigned
char. e.g.
• char age means signed char
• signed char code means signed char
• unsigned char value means unsigned char
ii) Integer data type
Integer data type is represented by int and is used for storing Integers, i.e.
numeric values without decimal portions.
• Integer variable can store a value ranging from -32,768 to + 32,767
• Integer data type uses 2 bytes of memory
• Integer data type is also represented as short
• Another integer type to store larger values is long that can store a value
ranging from -2,147,483,648 to 2,147,483,647
• long takes 4 bytes of memory

• Another int type is signed int which is used to store sign too along with
the numeric value.
• Another int type is unsigned int which is used to store values without sign
So, there are 9 types of Integer data types, i.e. int, short, signed int, unsigned
int, signed short, unsigned short, long, signed long and unsigned long e.g.
• int a means signed int
• signed int b means signed int
• unsigned int c means unsigned int
• short d means signed short
• signed short e means signed short
• unsigned short f means unsigned short
• long g means signed long
• signed long h means signed long
• unsigned long i means unsigned long
iii) Float data type
Float data type is represented by float and is used for storing numeric values
along with fraction or decimal portion. Float data type takes 4 bytes of memory. A
floating point number is expressed in scientific notation. The reason of storing
float values in scientific notation is that they can be very large or extremely small,
i.e.
2000000000000000 = 2e+15
0.00000000000023 = 2.3e-13
A value written as 47e3 means 47 x 103
• Exponent value ranges from -38 to +38, i.e. 47x10-38
to 47x10+38
• Another float type is double that takes 8 bytes of memory.
• Exponent values in double ranges from -308 to + 308, i.e. 47x10-308
to
47x10+308
47e3 = 47 x 103
mantissa exponent

Types of C/C++ Instructions
There are 4 types of C/C++ Instructions.
i) Type declaration Instructions
Variable types and definitions etc.
ii) Input/Output Instructions
Data Input, Data Display, Data Write etc
iii) Control Instructions
Controls the sequence of execution of the program instructions.
iv) Arithmetic Instructions
Arithmetic Operations etc

Preprocessor Directive
# is called Preprocessor Directive. The # line tells the compiler to use a file <iostream.h>
or <stdio.h> or whatever written in <angle brackets>. Files having .h extension in C/C++
are called header files. They are also sometimes called include files.
The iostream.h file is included in the program as it contains the information about
the “cout” identifier and the << operator. Normally all the header files of C/C++ are
present in the INCLUDE directory.
Main Function
A C/C++ program may consist of many functions, classes and other program elements,
but on startup, control always goes to main() function. The first statement executed by the
C/C++ compiler will be the one that is the first statement in function void main(void) or
void(main) or main().
In C/C++ all the statements of a function, either it is main() or any other should be
in blocks. A block starts with { (starting brace), then we write statements in the function,
and at the end we put } (closing brace), in order to tell the compiler that the above written
statements within the block are the statements of a function. The body of a function starts
from { and ends at }. Every starting brace should have a closing brace.
The statement cout<<”Welcome to C++”; displays the string constant
“Welcome to C++” on the screen. We can have one or more statements inside a function.
Statements tell the computer to do something. C/C++ statements are always terminated
by semicolon.
#include <stdio.h>
void main(void)
{
printf(“Welcome to C”);
}
Preprocessor Directive and is the only thing that should be present in the first column
Statement Terminator
<stdio.h> search function in the directory in which C in installed.
“stdio.h” search function in the directory which is presently in use.
Function body
First Program in C
#include <iostream.h>
void main(void)
{
cout<<“Welcome to C++”;
}
Preprocessor Directive and is the only thing that should be present in the first column
Statement Terminator
Function body
First Program in C++

Using Comments in the Program
There are two ways of specifying comments in C++.
i) Using //
ii) /* and */
All the lines between /* and */ are treated as comments and are normally used
when we want to specify many lines as comments. So if we want the C++ compiler to
treat some continuous lines as comments then instead of using // at the start of all those
lines, it is better to use /* from starting line and */ after the last line and all the lines
between starting and ending comments will be treated as comments and will not execute.
// It is a C++ Program
void main(void) //main function
{
/* These lines
are the
part of comments and
will not execute
*/
cout<<"We are studying C++";
}
Defining and using Integer Variables
1.cpp
void main(void)
{
int a;
int b;
a = 10;
b = a + 5;
cout<<"A is "<<a <<endl;
cout<<"B is "<<b <<endl;
}
Output
A is 10
B is 15

2.cpp
#include <conio.h>
void main(void)
{ int a,b;
a = 10; b = a + 5;
clrscr();
cout<<"A is "<<a <<" and B is "<<b<<endl;
cout<<"Press any key to finish";
getch();
}
Output
A is 10 and B is 15
Press any key to finish
Variable Definition and Declaration
3.cpp
#include <conio.h>
void main(void)
{ clrscr();
char first=65;
int second=964;
float third=5.543;
cout<<first<<endl<<second<<endl<<third;
getch();
}
Output
A
964
5.543
Using Escape Sequences in the Program
4.cpp
#include <conio.h>
void main(void)
{ clrscr();
cout<<"HellonHownArenYoun";
cout<<”HellontHownttArentttYoun”;
getch();
}
Output
Hello
How
Are
You
Hello
How
Are
You

Escape Sequences
is considered an escape sequence character that causes and escape from the normal
interpretation of a string so that the next character is recognized as having a special
meaning.
Following are the escape sequence characters along with their usage.
Escape Sequence Character
a Audible Alert
b Backspace
f Form feed
n New Line (Carriage Return + Line Feed)
r Return
t Tab
Backslash
’ Single quotation
” Double quotation
xDD i.e. xDB Hexadecimal Representation
Taking Input in the Program
5.cpp
#include <conio.h>
void main(void)
{ clrscr();
int a, b;
cout<<"Enter first value ";
cin>>a;
cout<<"Enter second value ";
cin>>b;
cout<<a<<" + "<<b<<" = "<<a+b;
getch();
}
Output
Enter first value 4
Enter second value 3
4 + 3 = 7

The const Qualifier
The keyword const (for constant) precedes the data type of a variable. It specifies that the
value of a variable will not change throughout the program.
Temperature Conversion Program
6.cpp
#include <conio.h>
void main(void)
{ clrscr();
int fah;
cout<<"Enter Temperature in Fahrenheit ";
cin>>fah;
int cel = (fah - 32) * 5/9;
cout<<"Equivalent temperare in Celcius is "<<cel;
getch();
}
Output
Enter Temperature in Fahrenheit 32
Equivalent temperare in Celcius is 0
Calculating the Area of a Circle
7.cpp
#include <conio.h>
void main(void)
{ clrscr();
float radius;
const float PIE = 3.14;
cout<<"Enter radius of circle ";
cin>>radius;
float area = PIE * radius * radius;
cout<<"Area of the circle is "<<area;
getch();
}
Output
Enter radius of circle 0.5
Area of the circle is 0.785
Type Conversion
8.cpp
#include <conio.h>
void main(void)
{ clrscr();
int count=7;
float weight=200.5;
double totalweight = count * weight;
cout<<"Total weight calculated is "<<totalweight;
getch();
}
Output
Total weight calculated is 1403.5
So, if we try to perform some
Arithmetic operation on
different data types, i.e. int,
float and double etc then C/C++
calculates the result of such type
of Arithmetic expression
without giving any error.

Casts
Cast is a way through which we change the type of the variable during the execution of
the program for a limited time, because variables previously defined type can not
calculate the values correctly due to its low range.
Arithmetic Operators
Following are the basic Arithmetic operators used in C/C++:
i) + (Addition)
ii) - (Subtraction)
iii) * (Multiplication)
iv) / (Division)
Apart from the specified basic operators, there are some other operators used in
C/C++, and are
v) % (Remainder or Modulus)
vi) ++ (Increment)
vii) -- (Decrement)
viii) += (Increment Assignment)
ix) -= (Decrement Assignment)
x) *= (Multiplication Assignment)
xi) /= (Division Assignment)
xii) %= (Remainder Assignment)
Increment and Decrement operators can be used in two ways, i.e.
i) Prefix
ii) Postfix
9.cpp
#include <conio.h>
void main(void)
{ clrscr();
int test=25000; //range is -32,768 to +32,767
test = (test * 10)/10;
cout<<"Result is "<<test<<endl;
test = 25000;
test = (long(test)*10)/10;
cout<<"Result now is "<<test;
getch();
}
Output
Result is -1214
Result now is 25000

10.cpp
#include <conio.h>
void main(void)
{ clrscr();
int a=5,b=2;
cout<<"A = 5 and B = 2"<<endl<<endl;
cout<<"A B"<<endl<<endl;
cout<<a<<" + "<<b<<" = "<<a+b<<endl;
cout<<a<<" - "<<b<<" = "<<a-b<<endl;
cout<<a<<" x "<<b<<" = "<<a*b<<endl;
cout<<a<<" / "<<b<<" = "<<a/b<<endl;
cout<<a<<" % "<<b<<" = "<<a%b<<endl<<endl;
a=5;
cout<<"Value of A now is "<<a<<endl<<endl;
cout<<"Prefix operator ++a gives "<<++a<<endl;
cout<<"Value of a after Prefix is "<<a<<endl<<endl;
cout<<"Postfix operator a++ gives "<<a++<<endl;
cout<<"Value of a after Postfix "<<a<<endl<<endl;
cout<<"Now for A = 5 and B = 2"<<endl;
a=5,b=2;
a+=b;
cout<<"a += b means value of a is "<<a<<endl;
a=5,b=2;
a-=b;
cout<<"a -= b means value of a is "<<a<<endl;
a=5,b=2;
a*=b;
cout<<"a *= b means value of a is "<<a<<endl;
a=5,b=2;
a/=b;
cout<<"a /= b means value of a is "<<a<<endl;
a=5,b=2;
a%=b;
cout<<"a %= b means value of a is "<<a<<endl;
getch();
}
Output
A = 5 and B = 2
A B
5 + 2 = 7
5 - 2 = 3
5 x 2 = 10
5 / 2 = 2
5 % 2 = 1
Value of A now is 5

Relational Operators
A relational operator compares two values. Comparisons involved in relation operators
can be
i) < Less than
ii) > Greater than
iii) == Equals to
iv) != Not equals
v) <= Less than or equals
vi) >= Greater than or equals
The result of comparison is either True or False. If a comparison provides 1, it
means True and if it provides 0, it means False.
Prefix operator ++a gives 6
Value of a after Prefix is 6
Postfix operator a++ gives 6
Value of a after Postfix 7
Now for A = 5 and B = 2
a += b means value of a is 7
a -= b means value of a is 3
a *= b means value of a is 10
a /= b means value of a is 2
a %= b means value of a is 1
11.cpp
#include <conio.h>
void main(void)
{ clrscr();
int number;
cout<<"Enter a Number ";
cin>>number;
cout<<"number < 10 = "<<(number<10)<<endl;
cout<<"number > 10 = "<<(number>10)<<endl;
cout<<"number == 10 = "<<(number==10)<<endl;
getch();
}
Output
Enter a Number 10
number < 10 = 0
number > 10 = 0
number == 10 = 1

Using Library Functions
12.cpp
#include <conio.h>
#include <math.h>
void main(void)
{ clrscr();
int a;
cout<<"Enter a value ";
cin>>a;
cout<<"Square Root of "<<a<<" is "<<sqrt(a);
getch();
}
Output
Enter a value 64
Square Root of 64 is 8
13.cpp
#include <conio.h>
#include <math.h>
void main(void)
{ clrscr();
float a;
cin>>a;
cout<<"Sine of "<<a<<" is "<<sin(a)<<endl;
cout<<"Cosine of "<<a<<" is "<<cos(a)<<endl;
cout<<"Tangent of "<<a<<" is "<<tan(a)<<endl;
getch();
}
Output
Enter a value 10
Sine of 10 is -0.544021
Cosine of 10 is -0.839072
Tangent of 10 is 0.648361

Loops
Loops cause a section of program to be repeated certain number of times. As long as
condition remains true, the repetition continues, when the condition becomes false, the
loop ends and the control passes to the statement following the loop.
There are three kinds of loops in C/C++.
i) for loop
ii) while loop
iii) do while loop
The for loop
The for loop executes a section of code a fixed number of times. for loop is used
normally when we know, before entering the loop, that how many times we want to
execute the code.
True
Initialization
Expression
Test
expression
Body of the
loop
Increment
/decrement
expression
Exit
False
Operation of for loop
for ( initialization expression ; test expression ; increment/decrement expression )
statement; //single statement in loop body
for ( initialization expression ; test expression ; increment/decrement expression )
{ statement 1;
statement 2;
.
.
.
statement n;
}
syntax of for loop
Multiple statements in loop body

14.cpp
#include <conio.h>
void main(void)
{ clrscr();
int sum=0;
for(int a=1;a<=10;a++)
{ cout<<a<<"t"<<(11-a)<<endl;
sum += a;
}
cout<<"Sum is "<<sum;
getch();
}
15.cpp
#include <conio.h>
void main(void)
{ clrscr();
int t;
cout<<"Enter Table value ";cin>>t;
cout<<t<<" x "<<a<<" = "<<(t*a)<<endl;
getch();
}
16.cpp
#include <conio.h>
void main(void)
{ clrscr();
int num, fact=1;
cout<<"Enter a number ";cin>>num;
for(int a=num;a>0;a--)
fact *= a;
cout<<"Factorial of "<<num<<" is "<<fact;
getch();
}
Nested for loop
17.cpp
#include <conio.h>
void main(void)
{ clrscr();
for(int b=1;b<=3;b++)
cout<<"A is "<<a<<" & B is "<<b<<endl;
getch();
}
Output
1 10
2 9
3 8
4 7
5 6
6 5
7 4
8 3
9 2
10 1
Sum is 55
Output
Enter Table value 7
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70
Output
Enter a number 4
Factorial of 4 is 24
Output
A is 1 & B is 1
A is 1 & B is 2
A is 1 & B is 3
A is 2 & B is 1
A is 2 & B is 2
A is 2 & B is 3

The while loop
Normally in for loop we have an idea that how many times we want to execute a section
of code but while loop is used when even before starting the loop we have no idea that
how many times a section of code will be executed.
Like for loop, while loop contains a test expression but there is no initialization or
increment/decrement expression etc.
True
False
Test
expression
Body of the
loop
Exit
Operation of while loop
while ( test expression )
while ( test expression )
{ statement 1;
statement 2;
.
.
.
statement n;
}
syntax of while loop
18.cpp
#include <conio.h>
void main(void)
{ clrscr();
int a=1;
while(a<=10)
{ cout<<a<<"t"<<(11-a)<<endl;
a++;
}
getch();
}
Output
1 10
2 9
3 8
4 7
5 6
6 5
7 4
8 3
9 2
10 1

19.cpp
#include <conio.h>
void main(void)
{ clrscr();
char ch='y';
int t, a;
while(ch!='n')
{ clrscr();
cout<<"Enter Table value ";cin>>t;
a=1;
while(a<=10)
{ cout<<t<<" x "<<a<<" = "<<t*a<<endl;
a++;
}
cout<<"Continue ";ch=getche();
}
cout<<"nProgram Finished";
getch();
}
20.cpp
#include<iostream.h>
#include<conio.h>
void main(void)
{ clrscr();
int a=15;
while(a<1 || a>10)
{ cout<<"Enter a value (1-10) ";
cin>>a;
}
cout<<"Value entered is between 1 - 10";
getch();
}
Output
Enter Table value 5
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50
Continue n
Program Finished
Output
Enter a value (1-10) 12
Enter a value (1-10) -5
Value entered is between 1 - 10

The do while loop
The do while loop is used when we want to guarantee that the loop body should execute
at least once, whatever the initial state of the test expression contains.
In do while loop, the test expression is placed at the end of the loop.
Body of the
loop
True
Test
expression
False
Exit
Operation of do while loop
do
while ( test expression ) ;
do
{ statement 1;
statement 2;
.
.
.
statement n;
}
while ( test expression );
syntax of do while loop
21.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a=1;
cout<<"ValuetSquaretCube"<<endl;
do
{ cout<<a<<"t"<<a*a<<"t"<<a*a*a<<endl;
a++;
}while(a<=10);
getch();
}
Output
Value Square Cube
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

22.cpp
#include<conio.h>
void main(void)
{ char ch;
int t;
do
{ clrscr();
cout<<"Enter Table value ";
cin>>t;
cout<<t<<" x "<<a<<" = "<<t*a<<endl;
cout<<"Continue ";
ch=getche();
}while(ch=='Y' || ch=='y');
cout<<"nThanks for using program";
getch();
}
Output
Enter Table value 4
4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
4 x 10 = 40
Continue n
Thanks for using program

Decision Making Statements
if statement
if statement is the simplest of the decision making statements. if statement executes a set
of commands when a specified condition is true. If specified condition is false then
simply the commands associated with if condition will not execute.
False
True
Test
expression
statement 1;
statement 2;
.
.
Exit
Operation of if statement
if ( test expression )
statement ; //single statement in if body
if (test expression)
{ statement 1;
statement 2;
.
.
.
statement n;
}
syntax of if statement
Multiple statements in if body

23.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a;
cout<<"Enter a value "; cin>>a;
if(a==10)
cout<<"Value entered is 10";
if(a<10)
cout<<"Value entered is less than 10";
if(a>10)
cout<<"Value entered is greater than 10";
getch();
}
24.cpp
#include<conio.h>
#include<process.h>
void main(void)
{ clrscr();
long n, j;
cout<<"Enter a number ";cin>>n;
for(j=2;j<n/2;j++)
if(n%j==0)
{ cout<<"It's not prime,
Divisible by "<<j<<endl;
getch();
exit(0);
}
cout<<"It's Primen";
getch();
}
// The exit() function causes the program to terminate, and value 0 is used here for successful
// termination.
Output
Enter a value 7
Value entered is less than 10
Enter a value 10
Value entered is 10
Enter a value 13
Value entered is greater than 10
Output
Enter a number 3
It's Prime
Enter a number 17
It's Prime
Enter a number 15
It's not prime, Divisible by 3
Enter a number 13
It's Prime
Enter a number 49
It's not prime, Divisible by 7

The if else statement
The if else statement executes one or more commands when a condition is true. If
condition is false then those commands are ignored and are not executed. if else is used
when we want some commands to be executed when a condition is true and if condition
is false then another set of commands should be executed.
Operation of if else statement
True
Test
expression
Body of if
statement 1;
statement 2;
Exit
False
Body of else
statement 1;
statement 2;
if ( test expression )
statement ; //single statement in if body
else
statement ; //single statement in else body
if (test expression)
{ statement 1;
statement 2;
.
.
statement n;
}
else
{ statement 1;
statement 2;
.
.
statement n;
}
syntax of if else statement
Multiple statements in if body
Multiple statements in else body

Counting words and characters in a C/C++ program
25.cpp
#include<conio.h>
void main(void)
{ int chcount=0;
int wdcount=1;
char ch='a';
clrscr();
while(ch!='r')
{ ch=getche();
if(ch==' ')
wdcount++;
else
chcount++;
}
cout<<"nWords = "<<wdcount;
cout<<"nCharacters = "<<(chcount-1);
getch();
}
Counting words and characters with different technique
26.cpp
#include<conio.h>
void main(void)
{ int chcount=0;
int wdcount=1;
char ch;
clrscr();
while((ch=getche()) !='r')
{ if(ch==' ')
wdcount++;
else
chcount++;
}
cout<<"nWords = "<<wdcount;
cout<<"nCharacters = "<<chcount;
getch();
}
Output
hello how are you
Words = 4
Characters = 14
Output
hello how are you
Words = 4
Characters = 14

27.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a, b, c;
cout<<"Enter values for A, B and C ";
cin>>a>>b>>c;
if(a==b)
if(b==c)
cout<<"A. B and C are Equal";
else
cout<<"B and C are not Equal";
else
cout<<"A and B are not Equal";
getch();
}
Defining Label
and use of switch, break and goto statements
28.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a, b;
char ch;
cout<<"Enter 1st value ";cin>>a;
cout<<"Enter 2nd value ";cin>>b;
again:
cout<<"+, -, x, / ";
ch=getche();
cout<<endl;
switch(ch)
{
case '+':
cout<<a<<" + "<<b<<" = "<<a+b<<endl;
break;
case '-':
cout<<a<<" - "<<b<<" = "<<a-b<<endl;
break;
case 'x':
cout<<a<<" x "<<b<<" = "<<a*b<<endl;
break;
case '/':
cout<<a<<" / "<<b<<" = "<<a/b<<endl;
break;
default:
cout<<"Wrong Choicen";
goto again;
}
getch();
}
Output
Enter values for A, B and C 5 5 8
B and C are not Equal
A and B are not Equal
A. B and C are Equal
A and B are not Equal
Output
Enter 1st value 5
Enter 2nd value 3
+, -, x, / ?
Wrong Choice
+, -, x, / @
Wrong Choice
+, -, x, / %
Wrong Choice
+, -, x, / &
Wrong Choice
+, -, x, / +
5 + 3 = 8

The switch statement
The switch statement is similar to the if else or else if construct but is more flexible. If
decision tree is large, and all the decisions depend on the value of the same variable, then
it is better to use switch statement instead of series of if else or else if statements.
The break statement
The break keyword causes the entire switch statement to exit. Control goes to the first
statement following the end of the switch statement.
If break statement is not used then the control passes down to the next case
statement and the statements that we do not want to execute, starts executing.
If the value of the switch variable doesn’t match any of the case constants then
control passes to the end of the switch without doing anything.
switch
variable equals
second case
body
True
False
Second
case body
switch
variable equals
third case
body
True
False
Third
case body
switch
variable equals
first case
body
True
False
First
case body
Default
body
Fourth
case body
switch
variable equals
fourth case
body
True
False
Exit
Operation of switch statement
switch(n)
{
case 1:
Statement;
Statement;
Break;
case 2:
Statement;
Statement;
Break;
case 3:
Statement;
Statement;
Break;
case 4:
Statement;
Statement;
Break;
default:
Statement;
Statement;
}
Integer or character variable
Integer or character
constant
first
case
body
causes exit
from switch
Integer or character
constant
second
case
body
causes exit
from switch
default
body
and no
break
statement
Syntax of switch statement

Using multiple cases in switch statement
29.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a, b;
char ch;
cout<<"1. Addn";
cout<<"2. Subtractn";
cout<<"3. Multiplyn";
cout<<"4. Dividen";
again:
cout<<"Enter your choice (1-4) ";
ch=getche();
cout<<endl;
switch(ch)
{
case '1':
case 'A':
case 'a':
cout<<a<<" + "<<b<<" = "<<a+b<<endl;
break;
case '2':
case 'S':
case 's':
cout<<a<<" - "<<b<<" = "<<a-b<<endl;
break;
case '3':
case 'M':
case 'm':
cout<<a<<" x "<<b<<" = "<<a*b<<endl;
break;
case '4':
case 'D':
case 'd':
cout<<a<<" / "<<b<<" = "<<a/b<<endl;
break;
default:
cout<<"Wrong Choicen";
goto again;
}
getch();
}
Output
Enter 1st value 5
Enter 2nd value 3
1. Add
2. Subtract
3. Multiply
4. Divide
Enter your choice (1-4) 7
Wrong Choice
Enter your choice (1-4) k
Wrong Choice
Enter your choice (1-4) S
5 - 3 = 2

The Conditional Operator
There is a compressed way of expressing the if else statement and is called the
conditional operator.
Operation of conditional operator
True
test
expression
Statement 1;
Exit
False
Statement 2;
Test-expression ? statement1 : statement2 ;
Syntax of conditional operator
Conditional operator
30.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a, b;
(a > b) ? cout<<"1st value is greater" : cout<<"2nd value is greater";
getch();
}
Output
Enter 1st value 5
Enter 2nd value 3
1st value is greater
Enter 1st value 3
Enter 2nd value 5
2nd value is greater

31.cpp
#include<conio.h>
void main(void)
{ clrscr();
for(int i=1;i<=8;i++)
{ for(int j=0;j<20;j++)
{ char ch=(j%4) ? ' ' : 'x';
cout<<ch;
}
cout<<endl;
}
getch();
}
Output
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x

Logical Operators
Other than Arithmetic operators, i.e. +, -, *, /, % etc and Relational Operators, i.e. <, >,
<=, >= etc, there is another family of operators called the Logical operators.
Logical operators allow the programmer to combine Boolean (True/False) values.
Operator Effect
&& Logical AND
|| Logical OR
! Logical NOT
Example of the use of Logical Operators is in program 22.cpp in which Logical
OR is used.
32.cpp
#include<conio.h>
void main(void)
{ clrscr();
int p;
do
{ cout<<"Enter your percentage (0-100) ";
cin>>p;
}
while(p<0 || p>100);
if(p>=90)
cout<<p<<"% = A+ Grade";
else if(p>=80 && p<90)
cout<<p<<"% = A Grade";
else if(p>=70 && p<80)
cout<<p<<"% = B Grade";
else if(p>=60 && p<70)
cout<<p<<"% = C Grade";
else if(p>=50 && p<60)
cout<<p<<"% = D Grade";
else
cout<<p<<"% = F Grade";
getch();
}
33.cpp
#include<conio.h>
void main(void)
{ clrscr();
char ch='y';
while(!(ch=='n'))
{ cout<<"nHellon";
cout<<"continue ";ch=getche();
}
cout<<"nEnd";getch();
}
Output
Enter your percentage (0-100) -5
Enter your percentage (0-100) 121
78% = B Grade
92% = A+ Grade
84% = A Grade
71% = B Grade
62% = C Grade
57% = D Grade
49% = F Grade
Output
Hello
continue a
Hello
continue y
Hello
continue k
Hello
continue n
End
Keeps on displaying Hello until ‘n’
is pressed

34.cpp
#include<conio.h>
void main(void)
{ clrscr();
char ch='y';
while(ch!='n')
{ cout<<"nHellon";
cout<<"continue ";ch=getche();
}
cout<<"nEnd";getch();
}
Output
Same program with same
output as 33.cpp but written
in different style

Operators Precedence
Operators precedence in C/C++ is
Operator Type Operators
Unary !, ++, --, -
Arithmetic *, /, %
+, -
Relational <, >, <=, >=
==, !=
Logical and &&
or ||
Conditional ? :
Assignment =, +=, -=, *=, /=, %=
If we want an expression to be evaluated first even its operators precedence is not
on the top then it can be done by placing parenthesis around it.

The continue statement
If we want to come out of the loop we use break statement, similarly if we want to go
back to the top of the loop, we use continue statement.
Condition true
continue
Operation of the continue statement
35.cpp
#include <conio.h>
void main(void)
{ long divident, divisor;
char ch;
do
{ clrscr();
cout<<"Enter Divident ";cin>>divident;
cout<<"Enter Divisor ";cin>>divisor;
if(divident==0 || divisor==0)
{ cout<<"Divident or Divisor can not be 0";
getch();
continue;
}
cout<<divident<<" / "<<divisor<<" = "<<divident / divisor<<endl;
cout<<divident<<" % "<<divisor<<" = "<<divident % divisor<<endl;
cout<<"Continue ";
ch=getche();
}while(ch!='n');
cout<<"nProgram Finished";
getch();
}
Output
Enter Divident 15
Enter Divisor 0
Divident or Divisor
can not be 0
Enter Divident 70
Enter Divisor 5
70 / 5 = 14
70 % 5 = 0
Continue y
Enter Divident 12
Enter Divisor 2
12 / 2 = 6
12 % 2 = 0
Continue n
Program Finished

The goto Statement
goto statement is mostly used in structured programming. In order to use goto statement,
we insert a label in our program code at the desired location. Label is a user defined name
terminated by a colon sign. The keyword goto is followed by the label name that takes
the control to the specified label, i.e.
statement;
statement;
goto again;
statement;
statement;
again:
statements in label again;
statements in label again;

Structures
Structure is a collection of variables that can be of the same or different data types. The
data items in a structure are called the members of the structure.
A user can define its own data types using structures. A structure in C/C++ is like
a record of other languages, i.e. Pascal etc.
A structure is defined with
the name of “part” that
consists of three members.
The structure specifier
doesn’t set aside any space
in memory. The structure
“part” is like a new data
type but we have not yet
created any variables of type
“part”.
struct structure-name
{ data-type variable-name;
data-type variable-name;
.
.
.
};
struct part
{ int modelnumber;
int partnumber;
float cost;
};
keyword name of the structure or tag
Structure
members
Terminating the structure specifier
S1.cpp
#include<conio.h>
struct Part
{ int mn;
int pn;
float cost;
};
void main(void)
{ clrscr();
Part p1;
p1.mn=6244;
p1.pn=373;
p1.cost-217.5;
cout<<"Model Number "<<p1.mn<<endl;
cout<<"Part Number "<<p1.pn<<endl;
cout<<"Cost is Rs. "<<p1.cost<<endl;
getch();
}
Output
Model Number 6244
Part Number 373
Cost is Rs.
8.697043e-12

Defining Structure Variables
A structure variable is defined the same way as a variable of any built-in data type i.e.
int age; // age is a variable of built-in data type Integer
part p1; //p1 is a variable of structure type part
Accessing Structure Members
The members of a structure variable are accessed by a dot operator, i.e.
p1.mn = 6244;
p1.pn = 373;
Combining Structure Specifier and Definition
Structure specifer and defining structure variables can be combined into a single
statement, i.e.
Initializing Structure Members
Structure members can be initialized when a structure variable is defined just as variables
can be initialized when it is defined, i.e. int a=13;
Similarly,
An important point to remember is that structure variables can be assigned to one
another when they are of the same structure type.
struct
{ int mn;
int pn;
float cost;
} p1, p2, p3;
Can be done without structure or tag
name, but its variables can not be
defined any where else in the program
Defined three variables, i.e. p1, p2 and p3
Part p1={6244, 373, 217.5};
Part p2;
p2 = p1;
mn pn cost
Assigns p1 to p2. The value of each member of p1
is assigned to the corresponding member of p2.

S2.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
void main(void)
{ clrscr();
Distance d1, d2, d3;
cout<<"Enter feet for 1st Distance ";
cin>>d1.feet;
cout<<"Enter inches for 1st Distance ";
cin>>d1.inches;
cout<<"Enter feet for 2nd Distance ";
cin>>d2.feet;
cout<<"Enter inches for 2nd Distance ";
cin>>d2.inches;
d3.inches = d1.inches + d2.inches;
d3.feet = 0;
if(d3.inches >= 12.0)
{ d3.inches -= 12.0;
d3.feet++;
}
d3.feet += d1.feet+ d2.feet;
cout<<"Total Distance is "<<d3.feet<<"'-"<<d3.inches<<""";
getch();
}
Output
Enter feet for 1st Distance 5
Enter inches for 1st Distance
7.5
Enter feet for 2nd Distance 6
Enter inches for 2nd
Distance 8.5
Total Distance is 12'-4"
Note
d3 = d1 + d2; is not allowed
as Arithmetic Operators, i.e.
+, - etc can not be used with
the data types that are
defined by the user.

Structures within Structures
Structures can be used inside a structure. Structures within structures are crated when we
need a structure to be used in another structure. The following program is an example of
the implementation of structures within structures.
Initializing Nested Structures
Nested structures can be initialized, the way non-nested structures are initialized. The
following example shows how the nested structures created in “s3.spp” is initialized.
S3.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
struct Room
{ Distance length;
Distance width;
};
void main(void)
{ clrscr();
Room dining;
dining.length.feet = 13;
dining.length.inches = 6.5;
dining.width.feet = 10;
dining.width.inches = 5.0;
float length = dining.length.feet + dining.length.inches / 12;
float width = dining.width.feet + dining.width.inches / 12;
cout<<"Dining Room Area is "<< length*width <<" Square Feet";
getch();
}
Output
Dining Room Area is
141.059036 Square
Feet
length
width
feet inches
inches
feet
Room dining = 13, 6.5 , 10, 5.0 ;

Enumerated Data Types
Structures can be looked as a way of providing user-defined data types. Another way of
defining our own data types is enumerated data type.
Enumerated data type is used when a user knows before a list of values that a data
type can use.
• In enum, every possible value should have a name, i.e. saturday, sunday etc
• Variable of enumerated data type, i.e. d1 and d2 can be given any of the value
listed in the enum specifier.
• A value that is not listed in enum specifier can not be assigned to an enum
variable.
• Arithmetic operators can be used with enum types, i.e. +, -, / etc
• Enumerated data types are treated internally as integers. Normally the first name
in the list is given value 0, 1 to second and so on.
enum variable-name { constant1, constant2, . . . . . };
List of constants separated by commas
terminator
S4.cpp
#include <conio.h>
enum dow{friday, saturday, sunday, monday, tuesday, wednesday, thursday};
void main(void)
{ clrscr();
dow d1, d2;
d1 = monday;
d2 = thursday;
int difference = d2 - d1;
cout<<"Day between Monday through Thursday are "<<difference<<endl;
if(d1<d2)
cout<<"Monday comes before Thursday";
getch();
}
Output
Day
between
Monday
through
Thursday
are 3
Monday
comes
before
Thursday

Specifying Integer Values
In enum specifier first member name gets a value 0, second gets 1 and so on. But the
order can be changed, i.e. instead of starting from 0, if user wants to start from 5, then 6
and so on, then it can be done the following way.
enum dow{friday=5, saturday, sunday, monday, tuesday, wednesday, thursday};
S5.cpp
#include <conio.h>
enum boolean{false, true};
void main(void)
{ clrscr();
char ch;
boolean muslim = false;
cout<<"Are you Muslim ";
ch=getche();
if(ch=='y' || ch=='Y')
muslim = true;
if(muslim)
cout<<"nYou are Muslim";
else
cout<<"nYou are not Muslim";
getch();
}
Output
Are you Muslim y
You are Muslim
Are you Muslim n
You are not Muslim

Functions
A group of statements that perform a specified operation is called a function. In a
function we group several program statements into a unit and give that unit a name that is
called function name. That function can be invoked any where in the program.
Program statements that appear in the program more than once are suitable for
creating a function. Function code is stored in only one place in the memory.
Another reason for creating functions is that a complex or bigger program code is
divided into different functions due to which it becomes easy to manage the program.
There are 3 things important related to a function.
i) Function Declaration
ii) Function Calling
iii) Function Definition
i) Function Declaration
Function Declaration is also called prototyping. Function declaration tells the
compiler that at some later point in the program a function will be called. i.e.
void line(void);
The void line(void); is a function declaration. The first void represents that
the return type of the function, void means no return type. The name of the
function is line. The void in the parenthesis indicates that line function doesn’t
take any arguments. Function declaration is terminated with a semicolon.
ii) Function Calling
Executing or invoking the function is called function calling, i.e.
line();
A function is called or executed by its name followed by the parenthesis.
The call is terminated by a semicolon.
When the function is called or invoked, then the control goes to the area of
the program where the function is defined, i.e. control starts executing the
statement that are part of the function. After executing the function, control
returns to statement following the function call.
iii) Function Definition
Function definition contains that actual code for the function. The first line of
function definition is called the function declarator, that is followed by the
function body. Function body is enclosed in braces. Function body contains
statements that makeup the function.
Function declarator should have the same name as specified in function
prototyping and should have the same number of arguments and return type as a
function prototype, i.e.

void line(void)
{ for(int a=1;a<=20;a++)
cout<<”*”;
cout<<endl;
}
F-1.cpp
#include<conio.h>
void line(void); //Function Declaration
void main(void)
{ clrscr();
line(); //Function Calling
cout<<"Hello"<<endl;
line();
cout<<"We are studying functions"<<endl;
line();
getch();
}
void line(void) //Function Declarator
{ for(int a=1;a<=20;a++)
cout<<"*";
cout<<endl;
}
Output
********************
Hello
********************
We are studying functions
********************

Eliminating the Declaration
Function declaration can be eliminated in the program if the function definition is
specified before the first function call. Although this approach is simpler but is not
flexible.
Passing Arguments to Functions
F-2.cpp
#include<conio.h>
void line(void) //Function Definition without Declaration
{ for(int a=1;a<=20;a++)
cout<<"xCD";
cout<<endl;
}
void main(void)
{ clrscr();
line();
line();
line();
getch();
}
Output
════════════════════
Hello
════════════════════
════════════════════

Passing by Value
An argument is a piece of data, i.e. a value passes from program to function, and these
passed values etc can be used by the function according to the requirements.
There are two ways in Passing by Value, through which arguments can be passed
to the functions, i.e.
i) Passing Constants to functions
ii) Passing Variables to functions
i) Passing Constants to functions
As the name represents, In passing constants to functions, a character, integer or
float constant is actually passed as argument to the function, i.e.
line(‘*’);
square(5);
F-3.cpp
#include<conio.h>
void chline(char, int);
void main(void)
{ clrscr();
chline('=',10); //Character and Integer constants passed
chline('*',20);
chline('-',10);
getch();
}
void chline(char ch, int n)
{ for(int a=1;a<=n;a++)
cout<<ch;
cout<<endl;
}
Output
==========
Hello
********************
----------

ii) Passing Variables to functions
In passing variables to functions, instead of passing a constant, the value that
needs to be passes as arguments is placed/stored in a variable, and that variable is
used as arguments, i.e.
line(a);
square(n);
Passing Structure Variables to functions
The way we pass constants or variables as arguments to functions of the default data
types, we have the capability of passing constants or variables of the structure types.
When passing constants of the structure type, the sequence of the members should
be the same as defined in the structures.
Passing Structure Variable to Functions
F-4.cpp
#include<conio.h>
void chline(char, int);
void main(void)
{ clrscr();
char ch; int n;
cout<<"Enter a character ";
cin>>ch;
cin>>n;
chline(ch, n); //Character and Integer variables passed
chline(ch, n);
chline(ch, n);
getch();
}
void chline(char ch, int n)
cout<<ch;
cout<<endl;
}
Output
Enter a character +
Enter a value 10
++++++++++
Hello
++++++++++
++++++++++

The way we pass variables of default data types to functions, we can pass variables of
structure types. Structures should be defined before the function declaration where
variables of that structure type is used.
Returning values from Functions
F-5.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
void showDistance(Distance);
void main(void)
{ clrscr();
Distance d1, d2;
cin>>d1.feet;
cin>>d1.inches;
cin>>d2.feet;
cin>>d2.inches;
cout<<"nFirst Distance is ";
showDistance(d1);
cout<<"nSecond Distance is ";
showDistance(d2);
getch();
}
void showDistance(Distance dd)
{ cout<<dd.feet<<"'-"<<dd.inches<<""";
}
Output
Enter inches for 1st Distance
6.5
Enter inches for 2nd
Distance 8.5
First Distance is 5'-6.5"
Second Distance is 7'-8.5"

When a function completes its execution, it can return a single value to the calling
program.
An important thing to note is that functions can return only a single value. If we
want our function to return more than one value, then we can use some other techniques,
i.e. If our function returns the value back to a structure variable, an if our structure is a
combination of many members of the same or different data types, then it means that one
structure variable will be containing more than one members and like this our return
values were more than once.
The return statement
F-6.cpp
#include<conio.h>
float p2k(float);
void main(void)
{ clrscr();
float pounds, kilograms;
cout<<"Enter weight in Pounds ";
cin>>pounds;
kilograms = p2k(pounds);
cout<<pounds<<" Pounds = "<<kilograms<<" Kilograms";
getch();
}
float p2k(float pounds)
{ float kilograms = 0.453592 * pounds;
return kilograms;
}
Output
Enter weight in Pounds 200
200 Pounds = 90.718399
Kilograms
Function will return a float type of value
Returned value will be stored in kilograms variable
return 0.453592 * pounds ;
or
return (0.453592 * pounds) ;

When we call a function than one or more arguments can be sent to a function, but a
function can only return one argument. Multiple arguments can not be returned from a
function using return statement, but can be made to do so if our return variable is of
structure type.
Functions return type should always be included in the function declaration. If
function doesn’t return anything then we use void to indicate that function will not return
a value.
If a functions return type is not specified in the function declaration then the
compiler assumes that functions return type is int. So, if a function is declared as, i.e.
test();
then it means that the function will return an integer type of value on completion,
as in its declaration, no return type was specified.
It is better that we always specify the return type even if it is int. This habit makes
the program listing consistent and readable.

Returning Structure Variables
The way functions return the values of default data types, we can create functions that
return variables of structure type.
F-7.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
Distance sumDistance(Distance, Distance);
void showDistance(Distance);
void main(void)
{ clrscr();
Distance d1, d2, d3;
cin>>d1.feet;
cin>>d1.inches;
cin>>d2.feet;
cin>>d2.inches;
d3 = sumDistance(d1, d2);
cout<<"nFirst Distance is ";
showDistance(d1);
cout<<"nSecond Distance is ";
showDistance(d2);
cout<<"nSum of Distance is ";
showDistance(d3);
getch();
}
Distance sumDistance(Distance dd1, Distance dd2)
{ Distance dd3;
dd3.inches = dd1.inches + dd2.inches;
dd3.feet = 0;
if(dd3.inches >= 12.0)
{ dd3.inches -=12.0;
dd3.feet++;
}
dd3.feet += dd1.feet + dd2.feet;
return dd3;
}
void showDistance(Distance dd)
{ cout<<dd.feet<<"'-"<<dd.inches<<""";
cout<<endl;
}
Output
Enter inches for 1st Distance 6.5
Enter inches for 2nd Distance 9.5
First Distance is 5'-6.5"
Second Distance is 8'-9.5"
Sum of Distance is 14'-4"

Passing by Reference
In passing arguments by reference, instead of passing a value to the function, its reference
that is the address of that variable is passed.
Passing by reference has two main advantages, i.e.
i) Function can access the actual variables of the calling function.
ii) Provides a mechanism for returning more than one value from the called function
to its calling function.
A reference provides an alias (different name or second name) for a variable.
F-8.cpp
#include<conio.h>
void swap(int&, int&);
void main(void)
{ clrscr();
int a, b;
cout<<"Enter value for a ";
cin>>a;
cout<<"Enter value for b ";
cin>>b;
cout<<"nBefore Swapping"<<endl;
cout<<"A is "<<a<<" and B is "<<b<<endl;
swap(a, b);
cout<<"nAfter Swapping"<<endl;
cout<<"A is "<<a<<" and B is "<<b<<endl;
getch();
}
void swap(int& aa, int& bb)
{ int t = aa;
aa = bb;
bb = t;
}
Output
Enter value for a 10
Enter value for b 20
Before Swapping
A is 10 and B is 20
After Swapping
A is 20 and B is 10
Function has not returned any value but
even then the variables in the main
function have changed value
Passing default data
types by reference

Passing Structures by Reference
F-9.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
void scale(Distance&, float);
void show(Distance);
void main(void)
{ clrscr();
Distance d1;
cout<<"Enter feet for distance ";
cin>>d1.feet;
cout<<"Enter inches for distance ";
cin>>d1.inches;
cout<<"Distance is ";
show(d1);
scale(d1,0.5);
cout<<"Distance now is ";
show(d1);
getch();
}
void scale(Distance& d, float factor)
{ float inches = (d.feet*12 + d.inches ) * factor;
d.feet = inches / 12;
d.inches = inches - d.feet * 12;
}
void show(Distance d)
{ cout<<d.feet<<"'-"<<d.inches<<""";
cout<<endl;
}
Output
Enter feet for distance 10
Enter inches for distance 6.6
Distance is 10'-6.6"
Distance now is 5'-3.299999"

Overloaded Functions
Or
Function Overloading
Overloaded functions perform different activities depending on the kind of data send to it.
F-10.cpp
#include<conio.h>
void line(void);
void line(int);
void line(char);
void line(int, char);
void line(char, int);
void main(void)
{ clrscr();
line(10);
line();
line('=',15);
line('*');
line(20,'-');
getch();
}
void line(void)
{ for(int a=1;a<=10;a++)
cout<<"*";
cout<<endl;
}
void line(int n)
cout<<"*";
cout<<endl;
}
void line(char c)
{ for(int a=1;a<=10;a++)
cout<<c;
cout<<endl;
}
void line(int n, char c)
cout<<c;
cout<<endl;
}
void line(char c, int n)
cout<<c;
cout<<endl;
}
Output
**********
**********
===============
**********
--------------------

Overloaded function or Function overloading means that more than one function
with the same name exists in the program. Same function name would be declared and
defined in the program more than once, differing in the number of arguments.
When the function will be called, then number of arguments will decide that
which function will be actually called, i.e.
void line();
void line(int);
void line(char);
void line(int, char);
void line(char, int);
We can see the above mentioned declarations that all five functions have the same
name, i.e. line, but every functions prototype is different from one another, and similarly,
when we’ll call the function line than its number of arguments will decide, which
function to execute.
Function definition doesn’t need to be in sequence the way functions are declared,
but only requirement is that the number of function definitions should be equal to the
number of function declarations.

Different types of Arguments in Overloaded Functions
or
Arguments of different data types in Overloaded Functions
In overloaded functions, the compiler can distinguish even if we provide different types
of arguments in the functions.
The following program has overloaded function with the name of show that has
two different types of arguments, i.e. one is of float type and other is of structure type. On
calling the function, the arguments decide that will function we want to overload. So, if
we send arguments of float type than the function having float type arguments is overload
or if we send structure type arguments, then function having structure type arguments is
overloaded.
F-11.cpp
#include<conio.h>
struct Distance
{ int feet;
float inches;
};
void show(Distance);
void show(float);
void main(void)
{ clrscr();
Distance d1; float allinches;
cout<<"Enter feet for distance ";
cin>>d1.feet;
cout<<"Enter inches for distance ";
cin>>d1.inches;
cout<<"Enter complete distance in inches ";
cin>>allinches;
cout<<<"nFirst distance is ";
show(d1);
cout<<<"nSecond distance is ";
show(allinches);
getch();
}
void show(Distance d1)
{ cout<<d1.feet<<"'-"<<d1.inches<<"""<<endl;
}
void show(float ai)
{ int feet = ai / 12;
float inches = ai - feet * 12;
cout<<feet<<"'-"<<inches<<"""<<endl;
}
Output
Enter feet for distance 5
Enter inches for distance 5.5
Enter complete distance in inches 95
First distance is 5'-5.5"
Second distance is 7'-11"

Default Arguments in Function Declaration and Calling
A function can be called without specifying all its arguments, if in function declaration
we provide default values for the arguments that are not specified.
When the function is called, the missing argument is assumed to be the last
argument. Missing arguments should always be the trailing arguments.
F-12.cpp
#include<conio.h>
void line(char='*', int=20);
void main(void)
{ clrscr();
line();
line('=');
line('-',10);
getch();
}
void line(char ch, int n)
cout<<ch;
cout<<endl;
}
Output
********************
====================
----------

Inline Functions
In order to prevent repeating some statement again and again in a program we create
function of those statements. Function reduces program code and program seems to be
well organized. Whenever a function is called, the control jumps from main program
code to the function code and this process requires saving the information of main
program and then loading the information of called function that reduces or wastes
sometime. If a function that has long code then it is only a small time but if a function is
small, i.e. only one or two statements than it is better to repeat it in the program instead of
creating its function as it will be wasting more time. Although in this way the program
code will become lengthier and program organization will not be as clear as it become in
the case of functions, but the benefit in this way will be reduced execution time. Program
will run faster but program listing will be longer and more complex
A solution to this problem is inline functions. Inline functions are written like
normal functions but compiles into inline code instead of into a function. The program
remains well organized as function is shown as a separate entity but when the program is
compiled, the function body is inserted into the program whenever a function call occurs.
Very small functions, i.e. which have one or two statements are candidates to be inlined.
For inline functions, the compiler must have seen the function definition (not only
the declaration), because it inserts the actual code into the program. So, for inline
function, function declaration can be eliminated. Inline keyword is used before that
function prototyping to tell the compiler that a function is inline, i.e.
inline float ps2kg(float pounds)
{ return 0.453592 * pounds;
}
F-13.cpp
#include<conio.h>
inline float p2k(float pounds) //inline function
{ return 0.453592 * pounds;
}
void main(void)
{ clrscr();
int pounds;
cout<<"Enter weight in pounds ";
cin>>pounds;
cout<<pounds<<" Pounds = "<<p2k(pounds);
cout<<" Kilograms";
getch();
}
Output
Enter weight in pounds 180
180 Pounds = 81.646561 Kilograms

Storage Classes of Variables
There are three storage classes of variables
i) Automatic Variables
ii) External Variables
iii) Static Variables
i) Automatic Variables
Variables defined within function body are called automatic variables. Keyword
auto can be used to specify an automatic variable, i.e.
void main(void)
{ auto int age;
Auto char grade;
.
.
.
}
void ps2kg(void)
{ auto float pounds;
.
.
}
As auto is default, i.e. a variable created within a function is always
automatic, even if it is not specified, so it is very rarely used. Automatic variable
is also called local variable as it is visible only locally in the function where it
was created. Local or Automatic variables are stored on the stack, that grows
downward in the memory.
Automatic variable or Local variable has two important characteristics, i.e.
Lifetime and Visibility.
Lifetime
An automatic variable is not created until the function in which it is defined is
called. A variable created in a function will occupy memory for storing values
only when the function in which it is defined will execute. The variable will be
destroyed and its value will be lost and the memory it has occupied will be
released as soon the control transfers from the function in which it was defined.
The time period between the creation and destruction of a variable is
called lifetime or duration. The lifetime of an automatic variable depends upon
the execution of the function in which it is defined. Limiting the lifetime of
automatic variables saves memory. If a function is not executing then the
variables it uses during execution are only needed when that function executes so
removing them when function is not executing frees up memory that can be used
by other functions.

Visibility
Variables visibility describes where within a program it can be accessed.
Automatic variables are only visible and can be accessed within the function in
which they are defined. So, the scope of automatic variable is the part of the
program where the variable is visible.
A programmer can be confident by limiting the visibility of the variables
that no function can accidentally change the values of variables defined in other
functions.
Limiting the visibility is an important feature of Object-Oriented
Programming. An automatic variable that is created but not initialized contains
garbage values.
ii) External Variables
External variables are defined outside of (external to) any function. An external
variable is visible to all the functions in a program. External variables are also
called Global Variables, as they are known by all the functions in a program.
External variables normally are defined at the beginning of the listing so they are
visible to all the functions.
#include <conio.h>
char ch=’a;
void getchar();
void putchar();
void main(void)
{ clrscr();
while(ch!=’r’)
{ getchar();
Putchar();
}
}
void getchar()
{ ch=getch();
}
void putchar()
{ cout<<ch;
}
An external variable is used when we want to access a variable in more
than one function. In OOP, external variables are not used frequently.

External or global variables are stored on the heap that grows upward in
the memory.
Lifetime
External variables exist for the life of the program. Memory space is set for them
when the program starts and continues in existence until the program ends.
Visibility
An external variable defined at the start of the program listing will be visible to all
the functions defined after the external variable.
An external variable that is created but not initialized contains 0.
iii) Static Variables
There are two types of static variables, i.e. Static Automatic Variables and
Static External Variables.
A static automatic variable has the visibility of a local variable but the
lifetime of an external variable. A static automatic variable is visible only inside
the function in which it is defined but remains in existence for the life of the
program.
Static automatic variables are used when we want a function to remember
a value. static keyword is used to create a static automatic variable. A static
automatic variable that is created but not initialized contains 0. The initialization
of static automatic variables takes place only once, and that is when the first time
their function is called.
F-14.cpp
#include<conio.h>
float getAverage(float);
void main(void)
{ clrscr();
float data=1, average;
while(data!=0)
{ cout<<"Enter a number ";
cin>>data;
average = getAverage(data);
cout<<"New Average is "<<average<<endl;
}
getch();
}
float getAverage(float newdata)
{ static float total = 0;
static int count = 0;
count++;
total += newdata;
return total / count;
}
Output
Enter a number 5
New Average is 5
Enter a number 15
New Average is 10
Enter a number 25
New Average is 15
Enter a number 35
New Average is 20
Enter a number 10
New Average is 18
Enter a number 20
New Average is 18.333334
Enter a number 30
New Average is 20
Enter a number 0
New Average is 17.5

Returning by Reference
As values can be passed by reference, similarly values can be returned by reference.
Returning by reference allows us to use a function call on the left side of equal sign, i.e.
A function declaration showing returning by reference is:
int& set(void);

Creating a Header File
//save this file "line.h" in INCLUDE directory
#include<conio.h>
void line(void)
{ for(int a=1;a<=20;a++)
cout<<"*";
cout<<endl;
}
void hello(void)
{ cout<<"nHello Hello Hellon";
}
//save this file “header.cpp”
#include<conio.h>
#include<line.h>
void main(void)
{ clrscr();
line();
hello();
line();
getch();
}
Output
********************
Hello Hello Hello
********************

Arrays
Array is a collection of variables of the same data type placed contiguously in memory.
The items or elements of array are accessed by index number.
Arrays can be used to store basic data types, i.e. int, char and float etc. Arrays can
also be used as data members in classes. Array can also be used to hold objects. Arrays
can also by used in structures, i.e. we can create an array of variable of structure types
and we can use array even inside the structures for defining its members etc.
ARR-1.cpp
#include<conio.h>
void main(void)
{ clrscr();
int t[7], sum=0;
{ cout<<"Enter Temperature for day "<<a+1<<" ";
cin>>t[a];
sum += t[a];
}
for(a=0;a<=6;a++)
cout<<"Temperature of day "<<a+1<<" is "<<t[a]<<endl;
cout<<"nAverage temperature is "<<sum/7;
getch();
}
ARR-2.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a[5], b[5];
for(int n=0;n<=4;n++)
{ cout<<"Enter value in element no. "<<n+1<<" ";
cin>>a[n];
b[n] = a[n] * a[n];
}
cout<<"Array AtArray B"<<endl;
for(n=0;n<=4;n++)
cout<<a[n]<<"t"<<b[n]<<endl;
getch();
}
Output
Enter Temperature for day 1 34
Temperature of day 1 is 34
Average temperature is 34
Output
Enter value in element no. 1 3
Array A Array B
3 9
4 16
5 25
6 36
7 49

Defining Arrays
Like other variables in C/C++, an Array must be defined before it can be used to store
information etc. Array definition is:
Array Elements
The items in an Array are called elements. (Items of a structure are called members).
The first element of array starts from 0, so an array of 5 elements has index
numbers 0 – 4.
Initializing Arrays
Arrays can be initialized just as a variable can be initialized at the time of creation.
Following example shows an int type of array having 5 elements is initialized.
int age[5] = { 27, 13, 31, 25, 37 };
int age[5];
Data type
of Array
Name of
Array
Bracket delimit
Array size
Size of
the Array
Array elements in Memory
Age[0]
Age[1]
Age[2]
Age[3]
Age[4]

Multidimensional Arrays
Arrays can be multidimensional. A two dimensional array consists of Rows and Columns
as we have them in a matrix.
Following example shows multidimensional array created as having 4 Rows and 3
Columns.
int matrix[4][3];
ARR-3.cpp
#include<conio.h>
const int ROW = 4;
const int COLUMN = 3;
void main(void)
{ clrscr();
int matrix[ROW][COLUMN];
for(int a=0;a<ROW;a++)
for(int b=0;b<COLUMN;b++)
{ cout<<"Enter ROW "<<a+1<<" COLUMN "<<b+1<<" ";
cin>>matrix[a][b];
}
for(a=0;a<ROW;a++)
{ for(b=0;b<COLUMN;b++)
cout<<matrix[a][b]<<"t";
cout<<endl;
}
getch();
}
Output
Enter ROW 1 COLUMN 1 1
1 2 3
4 5 6
7 8 9
10 11 12

Passing Arrays to Functions
Passing Arrays to Functions
ARR-4.cpp
#include<conio.h>
const int LENGTH=7;
void show(int[LENGTH]);
void main(void)
{ clrscr();
int t[LENGTH];
for(int a=0;a<LENGTH;a++)
{ cout<<"Enter Temperature for day "<<a+1<<" ";
cin>>t[a];
}
show(t);
getch();
}
void show(int temperature[LENGTH])
{ int s=0;
{ cout<<"nTemperature for day "<<a+1<<" is ";
cout<<temperature[a];
s += temperature[a];
}
cout<<"nSum of Temperatures is "<<s;
cout<<"nAverage of Temperature is "<<s/LENGTH;
}
Output
Temperature for day 1 is 23
Sum of Temperatures is 182
Average of Temperature is 26

Array of Structures
ARR-5.cpp
#include<conio.h>
const int LENGTH = 3;
struct part
{ int mn;
int pn;
float cost;
};
void main(void)
{ clrscr();
part p[LENGTH];
{ cout<<"nItem Number "<<a+1<<endl;
cout<<"Enter Model Number ";cin>>p[a].mn;
cout<<"Enter Part Number ";cin>>p[a].pn;
cout<<"Enter Cost ";cin>>p[a].cost;
}
clrscr();
for(a=0;a<LENGTH;a++)
{ cout<<"nItem Number "<<a+1<<endl;
cout<<"nModel Number "<<p[a].mn;
cout<<"nPart Number "<<p[a].pn;
cout<<"nCost is "<<p[a].cost<<" Rs. "<<endl;
}
getch();
}
Output
Item Number 1
Enter Model Number 10
Enter Part Number 100
Enter Cost 1000
Item Number 2
Enter Cost 2000
Item Number 3
Enter Cost 3000
Item Number 1
Model Number 10
Part Number 100
Cost is 1000 Rs.
Item Number 2
Model Number 11
Part Number 110
Cost is 2000 Rs.
Item Number 3
Model Number 12
Part Number 120
Cost is 3000 Rs.

Passing Array into another Array
ARR-6.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a[5], b[5];
for(int x=0;x<5;x++)
{ cout<<"Enter element no. "<<x+1<<" ";
cin>>a[x];
b[x] = a[x];
}
cout<<"nAtBn";
for(x=0;x<5;x++)
cout<<a[x]<<"t"<<b[4-x]<<endl;
getch();
}
ARR-7.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a[5], l, h;
for(int x=0;x<5;x++)
{ cout<<"Enter element no. "<<x+1<<" ";
cin>>a[x];
}
l = a[0], h=a[0];
for(x=0;x<5;x++)
{ if(a[x]<l)
l = a[x];
if(a[x]>h)
h = a[x];
}
for(x=0;x<5;x++)
cout<<a[x]<<endl;
cout<<"Highest Value entered is "<<h<<endl;
cout<<"Lowest value entered is "<<l<<endl;
getch();
}
Output
Enter element no. 1 1
A B
1 5
2 4
3 3
4 2
5 1
Output
5
78
3
256
17
Highest Value entered is 256
Lowest value entered is 3

Objects containing Arrays
ARR-8.cpp
#include<conio.h>
const int MAX=50;
class Stack
{ private:
int st[MAX];
int top;
public:
Stack()
{ top = -1;
}
void push(int var)
{ st[++top] = var;
}
int pop()
{ return st[top--];
}
};
void main(void)
{ clrscr();
Stack s1;
s1.push(11);
s1.push(22);
s1.push(33);
s1.push(44);
s1.push(55);
cout<<"1. "<<s1.pop()<<endl;
getch();
}
Output
1. 55
2. 44
3. 33
4. 22
5. 11

Array of Objects
ARR-9.cpp
#include<conio.h>
const int MAX=10;
class Distance
{ private:
int feet;
float inches;
public:
void getDist()
{ cout<<"nEnter feet ";cin>>feet;
cout<<"nEnter inches ";cin>>inches;
}
void showDist()
{ cout<<feet<<"'-"<<inches<<""";
}
};
void main(void)
{ clrscr();
Distance dist[MAX];
int n=0;
char ch;
cout<<endl;
do
{ cout<<"nEnter distance number "<<n+1;
dist[n++].getDist();
cout<<"Enter another ";cin>>ch;
}while(ch!='n');
for(int j=0;j<n;j++)
{ cout<<"nDistance number "<<j+1<<" is ";
dist[j].showDist();
}
getch();
}
Output
Enter distance number 1
Enter feet 4
Enter inches 5.5
Enter another y
Enter feet 3
Enter inches 5.9
Enter another y
Enter feet 6
Enter inches 6.5
Enter another n
Distance number 1 is 4'-5.5"

Arrays of Characters (Strings)
ARR-10.cpp
#include<conio.h>
void main(void)
{ clrscr();
char str[50];
cout<<"Enter a String ";
cin>>str;
cout<<"You Entered "<<str;
getch();
}
Output
Enter a String Hello
You Entered Hello
Enter a String Hello
Everyone
You Entered Hello
Enter a String
NationalUniversityOfModern
LanguagesH-
9IslamabadPakistan
You Entered
NationalUniversityOfModern
LanguagesH-
9IslamabadPakistan
H
e
l
l
o
0
.
.
.
.
.
Characters in
String
Terminating
0 or null byte
String
String
Buffer
str
Unused
part of
the
buffer

Reading Embedded Blanks
Avoiding Buffer Overflows
ARR-11.cpp
#include<conio.h>
void main(void)
{ clrscr();
char str[10];
cin.get(str,10); //get is a member function of
cout<<"You Entered "<<str; // the stream class of which
getch(); // cin is an object
}
Output
Enter a String How Are You
You Entered How Are Y
ARR-12.cpp
#include<iomanip.h>
#include<conio.h>
const int MAX=10;
void main(void)
{ clrscr();
char str[MAX];
cin>>setw(MAX)>>str;
getch();
}
Output
Enter a String abcdefghijklmnop
You Entered abcdefghi

String Constants
Reading Multiple Lines
ARR-13.cpp
#include<conio.h>
void main(void)
{ clrscr();
char str[] = "National University of Modern Languages";
// or
// char str[] = {'N','a','t', . . . . .};
cout<<str;
getch();
}
Output
National University of Modern
Languages
ARR-14.cpp
#include<conio.h>
const int MAX=200;
void main(void)
{ clrscr();
char str[MAX];
cin.get(str,MAX,'!');
getch();
}
Output
Enter a String National
University
of
Modern
Languages
!
You Entered National
University
of
Modern
Languages

Copying a String
ARR-15.cpp
#include<conio.h>
#include<string.h>
const int MAX=10;
void main(void)
{ clrscr();
char name1[MAX], name2[MAX];
cin.get(name1, MAX);
strcpy(name2, name1);
cout<<"Name 1 = "<<name1<<endl;
cout<<"Name 2 = "<<name2<<endl;
getch();
}
Output
Enter a String NUML
Name 1 = NUML
Name 2 = NUML

Arrays of Strings
ARR-16.cpp
#include<conio.h>
const int DAYS = 7;
const int LENGTH = 10;
void main(void)
{ clrscr();
char weekdays[DAYS][LENGTH] =
{"Friday","Saturday","Sunday","Monday",
"Tuesday","Wednesday","Thursday"};
for(int a=0;a<DAYS;a++)
cout<<weekdays[a]<<endl;
getch();
}
Output
Friday
Saturday
Sunday
Monday
Tuesday
Wednesday
Thursday
0
1
2
3
4
5
6
0 1 2 3 3 5 6 7 8 9
weekday[0]
weekday[1]
weekday[2]
weekday[3]
weekday[4]
weekday[5]
weekday[6]
F r i d a y
S a t u r d a y
S u n d a y
M o n d a y
T u e s d a y
W e d n e s d a y
T h u r s d a y a a
7
10

Pointers
A variable that holds an address value is called a pointer variable or pointer.
Pointers are used for
• Accessing Array elements
• Passing arguments to a function when the function needs to modify the original
argument
• Passing arrays and strings to functions
• Obtaining memory from the system
The address stored in a pointer should be of the same type as the pointer, i.e.
address of a float variable can not be assigned to a pointer of integer.
There is a general purpose pointer that can point to any data type and is called
“pointer to void”
P-1.cpp
#include<conio.h>
void main(void)
{ clrscr();
int v1=11, v2=22,v3=33;
cout<<"Value of v1 is "<<v1<<" and address is "<<&v1<<endl;
getch();
}
P-2.cpp
#include<conio.h>
void main(void)
{ clrscr();
int v1=11, v2=22;
cout<<"Value of v1 is "<<v1<<endl;
cout<<"Value of v2 is "<<v2<<endl;
cout<<"Address of v1 is "<<&v1<<endl;
cout<<"Address of v2 is "<<&v2<<endl;
int* p1; //Pointer to Integer
p1 = &v1; // Store address of v1 in pointer p1
cout<<"Value of p1 is "<<p1<<endl;
p1 = &v2;
cout<<"Value of p1 is "<<p1<<endl;
getch();
}
Output
Value of v1 is 11 and
address is 0x8fc3fff4
Output
Value of v1 is 11
Value of v2 is 22
Address of v1 is 0x8fc6fff4
Address of v2 is 0x8fc6fff2
Value of p1 is 0x8fc6fff4
Value of p1 is 0x8fc6fff2
Address of operator

P-3.cpp
#include<conio.h>
void main(void)
{ clrscr();
int v1=11, v2=22;
int* p1;
p1 = &v1; // Store address of v1 in pointer p1
cout<<"Value of v1 is "<<*p1<<endl;
p1 = &v2;
cout<<"Value of v2 is "<<*p1<<endl;
getch();
}
P-4.cpp
#include<conio.h>
void main(void)
{ clrscr();
int v1, v2;
int* p1;
p1 = &v1;
*p1 = 10;
cout<<"v1 = "<<v1<<endl;
v2 = *p1 + *p1 + 5;
cout<<"v2 = "<<v2<<endl;
getch();
}
P-5.cpp
#include<conio.h>
void main(void)
{ clrscr();
int i=10; float f=15.27;
int* pi; float* pf;
void* gp; //”pointer to void”, i.e. general purpose pointer
pi = &i; //correct
pf = &f; //correct
cout<<"nValue of i is "<<i<<endl;
cout<<"address of i is "<<pi<<endl;
cout<<"nvalue of f is "<<f<<endl;
cout<<"address of f is "<<pf<<endl;
// pi = &f; //incorrect
// pf = &i; //incorrect
gp = &i; //correct
// *gp = *gp * *gp; //incorrect
// cout<<"value of gp is "<<*gp<<endl; //incorrect
cout<<"naddress of gp is "<<gp<<endl;
gp = &f; //correct
// *gp = *gp * *gp; //incorrect
// cout<<"value of gp is "<<*gp<<endl; //incorrect
cout<<"naddress of gp is "<<gp<<endl;
getch();
}
Output
Value of v1 is 11
Value of v2 is 22
Output
v1 = 10
v2 = 25
Output
Value of i is 10
address of i is 0x8f7efff4
value of f is 15.27
address of f is 0x8f7efff0
address of gp is 0x8f7efff4
address of gp is 0x8f7efff0
When an asterisk is used before a variable
name, i.e. *p1, then it is called “Indirection
Operator”, i.e. the value of the variable
pointed to by.
So *p1 represents the value of the variable
pointed to by p1.

Pointer to Arrays
P-6.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a[5] = {15,35,24,87,42};
for(int b=0;b<5;b++)
cout<<*(a+b)<<endl;
getch();
}
P-7.cpp
This program sends the address of array to a function
that displays the array elements
#include<conio.h>
void show(int*);
void main(void)
{ clrscr();
int a[5] = {13,21,78,32,64};
show(a);
getch();
}
void show(int* c)
{ cout<<"Press any key to display array"<<endl;
getch();
cout<<*(c+b)<<endl;
}
Output
15
35
24
87
42
Output
Press any key to display
array
13
21
78
32
64
a[0]
a1]
a[2]
a[3]
a[4]
a
*(a+2)
*(a+b) is equivalent to a[b]

Pointer constants and pointer variables
P-8.cpp
#include<conio.h>
void main(void)
{ clrscr();
int a[5] = {13,21,78,32,64};
int* p;
p = a; //points to a
cout<<*(p++)<<endl;
getch();
}
P-9.cpp
Passing Reference as Arguments
#include<conio.h>
void square(int&);
void main(void)
{ clrscr();
int v = 5;
cout<<"Value is "<<v<<endl;
square(v);
cout<<"Square is "<<v<<endl;
getch();
}
void square(int& n)
{ n*=n;
}
P-10.cpp
Passing Pointer as Arguments
#include<conio.h>
void square(int*);
void main(void)
{ clrscr();
int v = 5;
cout<<"Value is "<<v<<endl;
square(&v);
cout<<"Square is "<<v<<endl;
getch();
}
void square(int* n)
{ *n = *n * *n;
}
Output
13
21
78
32
64
Output
Value is 5
Square is 25
Output
Value is 5
Square is 25
Passing variable by reference
Passing pointer as arguments

Pointers and Functions
P-11.cpp
#include<conio.h>
void cube(int*);
void main(void)
{ clrscr();
int a;
cout<<"Enter a Value ";
cin>>a;
cout<<"Cube of "<<a<<" is ";
cube(&a);
getch();
}
void cube(int* n)
{ *n = *n * *n * *n;
cout<<*n;
}
Output
Enter a Value 3
Cube of 3 is 27

New and Delete Operator
P-12.cpp
#include<conio.h>
#include<string.h>
void main(void)
{ clrscr();
char* name="National University of Modern Languages";
int l = strlen(name);
char* p;
p = new char[l];
strcpy(p,name);
cout<<"p = "<<p;
delete[] p;
getch();
}
Output
p = National University of
Modern Languages
Returns a pointer that points to a section of memory capable of
storing string name
Returns memory to the Operating System that was taken using
new operator

Pointers to Objects
P-13.cpp
#include<conio.h>
class Distance
{ private:
int feet;
float inches;
public:
void getDist()
{ cout<<"nEnter feet ";cin>>feet;
cout<<"Enter inches ";cin>>inches;
}
void showDist()
{ cout<<endl<<feet<<"'-"<<inches<<"""<<endl;
}
};
void main(void)
{ clrscr();
Distance d1;
d1.getDist();
d1.showDist();
Distance* dp;
dp = new Distance;
dp -> getDist(); // or (*dp).getDist();
dp -> showDist();
getch();
}
Output
Enter feet 5
Enter inches 5.5
5'-5.5"
Enter feet 6
Enter inches 6.5
6'-6.5"

Passing Array to Functions using Pointer notation
Strings as Function Arguments
P-14.cpp
#include<conio.h>
void square(int*);
void main(void)
{ clrscr();
int a[5]={0};
for(int n=0;n<5;n++)
{ cout<<"Enter element no. "<<n+1<<" ";
cin>>a[n];
}
square(a);
for(n=0;n<5;n++)
cout<<a[n]<<endl;
getch();
}
void square(int* v)
{ for(int i=0;i<5;i++)
*v++ *= *v;
}
Swapping Through Pointers
P-15.cpp
#include<conio.h>
void change(int*, int*);
void main(void)
{ clrscr();
int n1=99, n2=11;
int n3=22, n4=88;
cout<<"Befor Swapping"<<endl;
cout<<"n1 = "<<n1<<" n2 = "<<n2<<endl;
cout<<"n3 = "<<n3<<" n4 = "<<n4<<endl;
change(&n1,&n2);
change(&n3,&n4);
cout<<"After Swapping"<<endl;
cout<<"n1 = "<<n1<<" n2 = "<<n2<<endl;
cout<<"n3 = "<<n3<<" n4 = "<<n4<<endl;
getch();
}
void change(int* s1,int* s2)
{ int t = *s1;
*s1 = *s2;
*s2 = t;
}
Output
9
144
81
9
49
Output
Befor Swapping
n1 = 99 n2 = 11
n3 = 22 n4 = 88
After Swapping
n1 = 11 n2 = 99
n3 = 88 n4 = 22

Pointers and Strings
Pointers to String Constants
P-16.cpp
#include<conio.h>
void main(void)
{ clrscr();
char s1[]="NUML"; //Defined as Array
char* s2 ="NUML"; //Defined as Pointer
cout<<s1<<endl;
cout<<s2<<endl;
s2++; //Starts pointing to U instead of N in NUML
cout<<s2<<endl;
getch();
}
Output
NUML
NUML
UML

Strings as Function Arguments
P-17.cpp
#include<conio.h>
void dispString(char*);
void main(void)
{ clrscr();
char name[]="National University of Modern Languages";
dispString(name);
getch();
}
void dispString(char* s)
{ while(*s) //until null character
cout<<*s++; //print characters
}
Output
National University of
Modern Languages

Notes of programming

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Notes of programming (20)

More from Bilal Maqbool ツ (20)

Recently uploaded (20)

Notes of programming