1 Revision Tour

WEL COME
PRAVEEN M JIGAJINNI
PGT (Computer Science)
MTech[IT],MPhil (Comp.Sci), MCA, MSc[IT], PGDCA, ADCA,
Dc. Sc. & Engg.
email: praveenkumarjigajinni@yahoo.co.in

INTRODUCTION
C ++ Programming language was
developed at AT & T Bells LAB early in
1980’s by BJARNE STROUSTRUP.
 STROUSTRUP added some features
to his favorite language Simula 67.
(Earliest OOP).
STROUSTRUP called “ C with Classes
”.
C++ ( C Plus Plus) is named by Rick
Masitti.

Born
December 30, 1950 ) (age 60)
Aarhus, Denmark
Occupation
College of Engineering Chair in
Computer Science Professor, Texas
A&M University USA
Known for The creation of C++
BJARNE STROUSTRUP

BJARNE STROUSTRUP
Bjarne Stroustrup giving a talk at Kent State
University on C++0x in 2007.

C++ CHARACTER SET
Letters:- A-Z, a-z
Digits:- 0 to 9
Special Symbols:- space + - / ( ) [ ] = !
= < > , ‘ “ $ # ; : ? &
White Spaces:- Blank Space , Horizontal
Tab, Vertical tab, Carriage Return.
Other Characters:- C++ can process any
of the 256 ASCII Characters as data or as
literal.

TOKENS
The Smallest individual unit in a program
is known as Token.
Lexical Unit is the another name given to
Token.
C++ has following Tokens
1) Key words 2) Identifiers 3) Literals
4) Punctuators 5) Operators

KEY WORDS
Key words are the words that convey
special meaning to the compiler.
Key words are also called as Reserved
words meaning their meaning is reserved
in C++.
Some of Key words are,
float int auto extern double
case do while goto…etc

IDENTIFIERS
Identifier is an arbitrary long sequence of
letters and digits.
The first character must be letter.
The underscore ( _ ) counts as letter.
Upper and Lower case letters are
different.
All characters are significant.

EXAMPLES OF
IDENTIFIERS
C++ is a Case Sensitive Language as it
treats upper case letters and lower case
letters differently.
Some Valid identifiers,
Myfile DATE9_7_8 z3t9x3
 MYFILE _DS _FXR
Some Invalid identifiers,
DATA-REC 28dre break

LITERALS
Literals often referred to as constants
These are the data items that never
change their value during the program
run.

TYPES OF C++
LITERALS
INTEGER – CONSTANT
CHARACTER – CONSTANT
FLOATING – CONSTANT
 STRING – LITERAL

INTEGER CONSTANT
These are the whole numbers without any
fractional part.
An integer constant must have at least
one digit and must not contain fractional
part.
It may contain + or - Sign.
A number with no sign is assumed as
positive.
Commas can not appear in integer
constant.

TYPES OF INTEGER
CONSTANTS
DECIMAL INTEGER CONSTANTS
OCTAL INTEGER CONSTANTS
HEXADECIMAL CONSTANTS

DECIMAL INTEGER
CONSTANT
An integer constant consisting of
sequence of digits is taken to be decimal
integer constant unless it begins with 0.
For instance 1234,56,+86,-56,-89,-22 are
decimal integer constant.

OCTAL INTEGER CONSANT
A sequence of digits starting with 0(digit
Zero) is taken to be an octal integer
constant.
 for instance Decimal 8 is written as 010
as octal integer
8 10 =10 8
Decimal 12 is written as
12 10 = 14 8

HEXADECIMAL INTEGER
CONSTANT
A Sequence of Digits preceded by 0x or
0X is taken to be an hexadecimal integer
constant.
For instance decimal 12 is written as
 1210 = 0XC
The Suffix l or L and u or U is attached to
any constant indicates as long and
unsigned respectively
For Example:- 12L,189U …etc

CHARACTER CONSTANT
A character constant is one character
enclosed within single quotes
Valid constants ‘a’ ‘z’ ‘k’
Invalid Constants a z k
In c++ character constant must have
single character and must be enclosed in
single quotes.

NONGRAPHIC CHARACTERS
Nongraphic character constants are those
characters that can not be typed directly
from the keyboard.
e.g backspace, tab, carriage return
C++ Allows programmers to have certain
nongraphic characters.

ESCAPE SEQUENCES
Escape sequences are nongraphic
character constants these are also called
as non printing characters.
These nongraphic characters are
represented by means of escape
sequence and is represented by a
backslash ( ) followed by a one or more
character.

ESCAPE SEQUCENCE IN C++
Escape Sequence Non Graphic Character
 a Bell
 b Back Space
 f Form Feed
 n New Line
 r Carriage Return
 t Horizontal Tab
 v Vertical Tab
 ’ Single Quote
 ” Double Quote
 ? Question Mark
 on Octal Number ( On represents
the number in octal)
 xHn Hexadecimal number
 0 Null

NOTE
THESE ESCAPE SQUENCES ARE USED IN
OUT PUT STATEMENT COUT
FOR EX:
cout<<“nt Wel Come”; // Right statement
cin>>”nt”>>n; - Wrong statement
Do not use in cin statements

FLOATING CONSTANTS
Floating constants are also called as Real
constants. These may be written in one of two of
forms called fractional form or exponent form.
A real constant in fractional form must have one
digit before a decimal point and at least one digit
after the decimal point. It may also have either
+ve or –ve sign preceding it. A real constant
with no sign is assumed to be positive.

EXAMPLES OF REAL CONSTANTS
The following are the valid real constants
in fractional form.
2.0 17.5 -89.9 -0.000732
The following are the invalid real constants
in fractional
7 7. +27/3 24.34.32
12,45,344.09

REAL CONSTANTS IN EXPONENT FORM
A Real constant in exponent form has two
parts
1. Mantissa
2. Exponent
Mantissa must be either an integer or
proper real constant. The mantissa is
followed by letter E or e and the exponent
must be an integer.

EXAMPLE OF REAL CONSTANTS
The floating point number 5.8 can be written as,
0.58 x 101
=0.58E01 or 0.58e01, here E01 or
e01 represents 101
0.58 E01
Mantissa part Exponent part
Valid Real Constants : 123E03, 0.76e02, -0.12e-2
Invalid Real Constants: 172.E03, 1.2E,0.4E2.3

STRING LITERAL
A String Literal is a sequence of
characters surrounded by double quotes
 A Multi character constants are treated as
string literals.
For Example: “abc” in the memory this
string is represented as “abc0” i.e along
with the terminating character (Slash
Zero).
String is an array of character.

PUNCTUATORS
Punctuators are also called as separators The
Followings are used as punctuators
Brackets [ ]
Parantheses ( )
Braces { }
Comma ,
Semicolon ;
Colon :
Asterisk *
Ellipsis …
Equal Sign =
Pound Sign #

OPERATORS
Operators are tokens that triggers some
computation when applied to a variable
and other objects in an function.
Unary Operators are those operators they
act upon one operand.
OR
operators that require one operator to
operate upon.

UNARY OPERATORS
& Address Operator
* Indirection Operator
+ Unary Plus
- Unary Minus
~ Bitwise Compliment
++ Increment Operator
-- Decrement Operator
! Logical Negation

BINARY OPERATORS
Binary Operators are those operators that
require two operands to operate upon.
Arithmetic Operators
+ Addition
- Subtraction
* Multiplication
/ Division
% Remainder or Modulus

SHIFT OPERATORS
<< (Shift Left)
>> (Shift Right)
For More information you will study in
future chapters.

LOGICAL OPERATORS
&& Logical AND
|| Logical OR

ASSIGNMENT OPERATORS
= Assignment Operator
*= Assign Product
/= Assign Quotient
%= Assign Remainder
+= Assign Sum
-= Assign Minus
<<= Assign Left Shift
>>= Assign Right Shift
&= Assign Bitwise AND
^= Assign Bitwise XOR
|= Assign Bitwise OR

Relational Operator
< Less than
> Greater than
<= Less than equal to
>= Greater than equal to
== Equal to
!= Not equal to

COMPONENT SELECTION OPERATORS
Direct component selector
Indirect component selector

CLASS MEMBER OPERATORS
:: Scope access or scope resolution
.* Difference pointer to class member
* Difference pointer to class member

CONDITIONAL OPERATOR
? :
Further Details you will study in
FLOW CONTROL CHAPTER

ORDER OF PRECEDENCE
( ) [ ]
! ~ + - ++ -- & *
* / %
+ -
<< >>
< <= >>=
== !=
&
^
|
&&
?:
= *= /= %= + = - = &= ^= | = < < = > >=

A FIRST LOOK AT CPP PROGRAM
// My First Program
# include <iostream.h>
int main ()
{
cout<<“Wel Come To C++ Programming”;
return 0;
}
The program produces the output as,
Wel Come To C++ Programming

FIRST PROGRAM
// My First C++ Program
This is the comment. All lines beginning with
// are the comments in the program.
The comments are the non executable
statements. When ever compiler identifies
this is comment then it ignores
// is the single line comment
Starting with /* and ended with */ is used for
multi line comments

FIRST PROGRAM
# include <iostream.h>
Statement begin with # (hash or pound) sign
are the directives for the preprocessor,
that means these statement are
processed before compilation takes place.
The # include <iostream.h> statement tells
compiler’s preprocessor to include the
header file iostream.h in the program

FIRST PROGRAM
int main()
This line indicates the beginning of the
main function. The main() function is the
point where C++ program begin their
execution.
return 0;
The return statement makes the main() to
finish and it returns a value.

NOTE
• Every Executable statement in the C++
must be terminated by a semi colon
;

Why iostream.h ?
• The header file iostream.h is included in
every C++ program to implement the
input/output facilities.
Input /output facilities are not defined in
the C++ language rather they are
implemented through a component of C++
standard library.

THE FUNTION OF I/O LIBRARY – iostream.h
1. At the lowest level, where the notion of data
type is missing and the files are treated as
streams of bytes, the I/O library manages the
transfer of these bytes.
2. At the user level where the notion of data type
is present, I/O library manages the interface
between these two levels i.e between user
level and the implementation level

PREDEFINED STREAMS IN I/O LIBRARY
At the lowest level files are implemented
as streams of bytes, then
What is STREAM?
A Stream is simply a sequence of bytes.
Input and output operations are
supported by the istream (input stream)
and ostream (output stream) classes.

PREDEFINED STREAMS IN I/O LIBRARY
The ostream output operation, referred to
as insertion and is performed by insertion
operator <<
The istream input operation, referred to as
extraction and is performed by extraction
operator >>

EXTRACTION AND INSERTION SYMBOLS
extraction operator Symbol is,
>>insertion operator symbol is,
<<

cin and cout statements
cin (pronounced as see-in) stands for
console input.
cout (pronounced as see-out) stands for
console output.

SYNTAX OF cin STATEMENT
The general format or the syntax of cin statement is,
cin>>variablename;
Or
cin>>variablename1>>variablename2>>variable
name3………>>variablenamen;
for example if four variables are to be input form the
keyboard then,
cin>>a>>b>>c>>d;
Or the same statement can be written as follows,
cin>>a;
cin>>b;
cin>>c;
cin>>d;

SYNTAX OF cout STATEMENT
• The general format or the syntax of cout statement is,
cout<<variablename;
Or
cout<<variablename1<<variablename2<<variable name3………
<<variablenamen;
for example if four variables are to be input form the keyboard
then,
cout<<a <<b <<c <<d;
Or the same statement can be written as follows,
cout<<a;
cout<<b;
cout<<c;
cout<<d;

cout STATEMENT
Another way of writing cout statement is,
cout<<string<<variablename;
where,
String is a sequence of characters enclosed
within a double quotation.
Variable name is the value of variable which
is to be printed after the message(string)

cout STATEMENT
totalamt;=6700;
cout<<“The Total Amount is = “<<totalamt;
Here, in this example
The Total Amount is= is the string
And the totalamt is the variable name, the
value of the total is printed
Out put of this statement is as follows
The total Amount is = 6700

cout STATEMENT
As studied escape sequences are used in out
put (cout) statements
• cout<<“ntBasic Pay=“<<basic<<“nt
DA=“<<da<<“nt HRA = “<<hra<<“nt Gross
Salary = “<<gs;
output of the above statement is,
Basic Pay=5900
DA=40
HRA =30
Gross Salary = 10030

COMMENTS
The comments are the non executable
statements. When ever compiler identifies
this is comment then it ignores. There are
two types of comments in C++
Single Line Comment (//)
Multi Line Comment (starts with /* and
ends with */

COMMENTS
The comments are the non executable statements.
When ever compiler identifies this is comment
then it ignores. Single Lien Comment Example
// My First C++ Program
This is the comment. All lines beginning with // are
the comments in the program.
Starting with /* and ended with */ is used for multi
line comments
Multi Line Comment Example
/* Write a CPP Program that calculates the sum
and average of three numbers*/

I/O OPERATORS
Input coming from the user’s terminal
referred to as standard input is tied to the
predefined iostream cin and output
directed to the user’s terminal, referred to
as standard output, is tied to the
predefined iostream cout.

OUTPUT OPERATOR “<<’’
The output operator (“<<’’) (“put to’’), also
called as stream insertion operator is used
to direct a value to the standard output
device.
For example
cout<<“The Sum of 5 + 2 = “;
cout<< 5 + 2 ;
The statement will produce following output
The Sum of 5 + 2 = 7

OUTPUT OPERATOR <<
Now observe the output of following statement.
cout<< “The Sum of 5 + 2 is “;
cout<< 5 + 2;
cout<<“n”;
cout<<“The Result pf 8 – 2 is“;
cout<<8 – 2 ;
The Output of abve set of statements will be as
follows,
The Sum of 5 + 2 is 7
The Result pf 8 – 2 is 6

OUTPUT OPERATOR <<
The same statements can be written by using
single cout statement
cout<< “The Sum of 5 + 2 is
<< 5 + 2<<“n”
<<“The Result pf 8 – 2 is“<<8 – 2 ;
The Output will be same but code is reduced.
The Sum of 5 + 2 is 7
The Result pf 8 – 2 is 6
Note: Stream insertion operator >> signifies that
the insert the value that follows in to the stream
named cout.

/* Write a C ++ Program that
prints the sum of two values */
#include <iostream.h> // for I/O Operation
#include<conio.h>// for clrscr() and getch() functions.
Int main()
{ cirscr() ;
int value1, value2, sum ;
cout << “Enter First Value:”;
cin>>value1;
cout<<“Enter Second Value:”;
cin>>value2;

Program contd..
sum=value1+value2;
cout<<“The Sum of two given values is : “;
cout<<sum;
return 0;
}
Definition: Variable refers to a storage area whose
contents can vary during processing. In this
example sum , value1 , valu2 are the variables.
NOTE: The Stream extraction operator >>, signifies “extract the next
value” from the stream named cin and assign it to the next named
variable

OUTPUT OF PROGRAM
The output produced by the program is as
follows,
Enter the First value: 6
Enter the Second value : 7
The Sum of the given value is : 13

CASCADING I/O OPERATOR
• The Multiple use of input or output operators
(“>>” or “>>”) in one statement is called
cascading of I/O operators.
• For Example OUTPUT OPERATOR
cout<<“The sum of “;
cout<<value1;
cout<< “and “;
cout<<value2;
cout<<“ is “;
cout<<value1+value2;
This can be using cascading of output operator as,
cout<<“The sum of “<<value1<< “and “<<value2<<“ is “
<<value1+value2;

CASCADING I/O OPERATOR
• For Example INPUT OPERATOR
cout<<“Enter the two values “;
cin>>value1;
cin>>value2;
This can be using cascading of input operator as,
cout<<“Enter the two values “;
cin>>value1>>value2;

INVOKING TURBO C++
• To invoke ( load ) Turobo C++ Editor, Click on
start and type cmd and press enter key. Go to
root directory c and then type the following
commands.
C:>cd tc
C:tc>cd bin
C:tcbin>tc
After typing these commands at dos prompt
you will see an C++ editor on the screen.

C++ EDITOR
Use F5 to Maximize Window and F6 to navigate between opened files

COMPILING PROGRAM ALT + C or press ALT + F9

RUNING PROGRAM ALT + R or CTRL + F9

ROLE OF COMPILER
• A part of the compiler’s job is to analyze the
program code for “Correctness” if the
meaning of the program is correct then
compiler will not detect errors.
Types of Errors are,
1. Syntax Errors
2. Semantic Errors
3. Type of Errors
4. Run Time Errors.
5. Logical Errors

SYNTAX ERROR
Syntax errors refer to formal rules
governing the construction of valid
statements in a language.
Syntax errors occur when rules of a
programming language are misused i.e.,
when a grammatical rule of C++ is
violated.

1. SYNTAX ERROR
• For instance in the following program segment,
main()
{
int a,b:
cin>>a>>b;
cout<<a+b,
return 0;
}

2. SEMANTICS ERROR
• Semantics error occur when statements
are not meaningful
Semantics refers to the set of rules which
give the meaning of the statement.
For example,
Sita plays Guitar
This statement is syntactically and
semantically correct and it has some
meaning.

2. SEMANTICS ERROR
See the following statement,
Guitar plays sita
is syntactically correct (syntax is correct) but
semantically incorrect. Similarly, there are
semantics rules of programming language,
violation of which results in semantical errors.
X * Y = Z
will result in semantical error as an expression
can not come on the left side of an assignment
statement.

3. TYPE ERRORS
Data in C++ has an associated data type.
The value 7, for instance, is an integer and
‘a’ is a character constant “Hi” is a string. If
a function is given wrong type of data,
then Type Error is assigned by compiler
For Example :
char a[]=“Hi”;
pow(a,2);
This will result in type error.

4. RUNTIME ERRORS
A Run time error is that occurs during execution
of the program. It is caused because of some
illegal operation taking place.
For example
1. If a program is trying to open a file which does
not exists or it could not be opened(meaning file
is corrupted), results into an execution error.
2. An expression is trying to divide a number by
zero are RUN TIME ERRORS.

5. LOGICAL ERRORS
• A Logical Error is that error which is causes a
program to produce incorrect or undesired
output.
for instance,
ctr=1;
while(ctr>10)
{
cout<<n *ctr;
ctr=ctr+1;
}

MORE ABOUT COMPILER
• A Compiler reports an error by flashing an error
message. An Error message contains a line
number and a brief description of the error.
A second thing, a compiler does is, it translates
the corrected program text into object or
assembly instruction text understood by the
compiler, this process of translation is called
code generation. After code generation actual
program execution takes place.

CONCEPT OF DATA
TYPES
Data can be of many types e.g. character,
string, integer, real etc.
C++ like any other language provides
ways and facilities to handle different
types of data by providing data types.

DATA TYPES ( def. )
• DATA TYPES are means to
identify the type of data and
associated operations of handling
it.

C++ DATA TYPES
C++ data types are of two types:
Fundamental types
Derived types

FUDAMENTAL DATA
TYPES
There are 5 fundamental data types:
1. int
2. float
3. double
4. void
5. char

DERIVED DATA TYPES
Derived data types constructed from fundamental
data types are:
1. Array
2. Functions
3. Pointers
4. References
5. Constants
6. Classes
7. Structures
8. Unions
9. enumerations

FUNDAMENTAL DATA
TYPES
Fundamental (atomic) data
types are those that are not composed of
other data types.

INT
• Int data type (for integers). Integers are
whole numbers (without any fractional
part).
• Ex:123,-789 etc.

/* PROGRAM THAT
ILLUSTRATES INT DATA TYPE*/
#include<iostream.h>
void main()
{
int n=45;
cout<<“the integer value is “<<n;
getch();
}
NOTE: n is an integer number which holds 2
bytes of memory. the value ranges from
-32768 to +32767.

CHAR
• Char data type (for characters).
Characters can store any member of
the C++ implementation’s basic
character set.

CHAR
• Char type is often said to be an integer
type.
• Because they are represented by
associated number code (ascii code).
• ASCII code stores numbers codes for 256
known characters.

PROGRAM
void main()
{
char c=‘a’;
cout<<“the char value is “<<c;
getch();
}
Note:c is a character type data defined by char
keyword which holds 1 byte of memory and it
stores a single character.

PROGRAM
• The above program initialises a character
variable ch with character ‘a’. The second
statement of main() initialisses integer
variable num with the associated number
code of ch. (ch is having ‘a’ and
associated ASCII code of ‘A’ is 65).

FLOAT
Float data type (for floating-
point numbers). A number having
fractional part is known as floating point
number.

/* Program that illustrates
float data type*/
void main()
{
float n=45.123;
cout<<“the float value is “<<n;
getch();
}
NOTE: n is a floating-point number which holds
4 bytes of memory. the value ranges from
–3.4 x 10 –38
to 3.4 x 10 38
–1 and digits of
precision is 7

MORE ABOUT FLOAT
DATA TYPE
• Floating point numbers have two
advantages over integers.
1. They can represent values between the
integers.
2. They can represent a greater range of
values.

MORE ABOUT FLOAT
DATA TYPE
• But they one disadvantage also.
Floating-point operations are usually slower
than integer operations.

DOUBLE
Double data type (for double
precision floating-point numbers). The data
type double is also used for handling floating-
point numbers. But it is treated as a distinct data
type because it occupies twice as much memory
as type float, and stores floating-point with much
larger range and precision (significant numbers
after decimal point). It stands for double
precision floating-point.it is used when type float
is too small or insufficiently precise.

DOUBLE
• Type double is slower than float.
• You must use the smallest data type
which is sufficient.
NOTE: double type number which holds 8
bytes of memory. the value ranges from
17 x 10 –308
to 3.4 x 10 308
–1 and digits of
precision is 15

VOID
Void data type(for empty set of
values and non-returning functions).
The void type specifies an empty set of
values. It is used as the return type for
functions that do not return a value. No
object of type void may be declared.

DATA TYPE
MODIFIERS
A modifier is used to alter the meaning
of base type to fit various situations more
precisely.

MODIFIERS
List of modifiers
1. signed
2. unsigned
3. long
4. short

INTEGER TYPE
MODIFIERS
By using different numbers of bytes to
store values, c++ offers three types of
integers:
1. Short
2. Long
3. int

INTEGER TYPE
MODIFIERS
Type Size(bytes) Range
short 2 -32768 to 32767
long 4 -2,147,483,648 to
2,147,483,647
int 2 -32768 to 32767

CHARACTER TYPE
MODIFIERS
The char type is really another integer type (as
inside memory it actually holds numbers i.e.
equivalent codes of characters/symbols).
The char type can also be signed or unsigned.
Unlike int, char is neither signed or unsigned by
default.
The unsigned char represents the range 0 to
255 and signed represents the range -128 to
127.

FLOATING-POINT
TYPE MODIFIERS
• C++ has three floating-point types:
1. float
2. double
3. long double

DERIVED DATA TYPES
ARRAYS
• Arrays refer to a named list of a finite
number n of similar data elements.
• Arrays can be one dimensional, two
dimensional, or multi dimensional.
Further discussion in a different chapter.

FUNCTIONS
• A function is named part of program that
can be invoked from other parts of
program as often needed.

POINTERS
• A pointer is a variable that holds a
memory address.
• The address is usually the location of
another variable in memory.
• If one variable contains the address of
another variable, it is said to point to the
second.

REFERENCE
• A reference is an alternative name for an
object. It provides an alias for a previously
defined variable.
Syntax
type &ref-var =var-name;

TAKE A NOTE
NOTE
There can be no references to
references, no arrays of references, and
no pointers to references.

CONSTANTS
• The keyword const can be added to the to
the variable to make an object a constant
rather than a variable.
• Thus, the value of named constant cannot
be altered during the program run.

SYNTAX
• The general form of constant declaration is
given below:
• const type name = value;
• Where const is the keyword that must be
used for declaring a constant, type is any
valid c++ data type, name is the name of the
constant and value is the constant value of
the data type.
• For ex: const int upperage =50;
Declares a constant named as upperage of
type interger that holds value 50.

Be careful!!!!
• A constant must be initialized at the time
of declaration.
• If you give only const in place of const int,
it means the same.
NOTE the const modifier on it’s own is
equivalent to const int.

USER DEFINED
DERIVED DATA TYPES
• There are some derived dat types that
are defined by the user. These are :
1. Class
2. structure
3. union
4. enumeration

CLASS
• A class represents a group of similar
objects.
• A class bears the same relationship to an
object that a type does to a variable.
• Note :-- The class describes all the
properties of a data type, and an object is
an entity created according that
description.

STRUCTURE
A structure is collection of variables (of
different data types) referenced under one
name, providing a convenient means of
keeping related information togrther.
For ex:-
Insert a program

DIFFERNCES
• A structure is different from an array in the
sense that an array represents an aggregate
of elements of same type whereas a structure
represents an aggregate of elements of
(nearly) arbitrary types.
• A structure is different from a class in the
sense that a class can represent data
elements as well as their associated
functions whereas a structure can represent
only data elements, not their associated
functions.

UNION
• A union is a memory location that is
shared by two or more different variables,
generally of different types at different
times.
• The keyword union is used for declaring
and crating a union.

ENUMERATION
• An alternative method for naming integer
constants is often more convenient than
const.
• This can be achieved by creating
enumeration using keyword enum.
• Ex:

WHY SO MANY DATA
TYPES?
• The reason for providing so many data
types is to allow programmer to take
advantage of hardware characteristics.
Machines are significantly different in their
memory requirements, memory access
times (time taken to read memory), and
computation speeds.

VARIABLES
• Variables represent named storage locations,
whose value can be manipulated during program
run.
• There are two values associated with a symbolic
variable :
1. Its data value, stored at some location in memory.
This is sometimes referred to a s a variable’s
rvalue (pronounced “are-value” ).
2. Its location value ;i.e., the address in memory at
which its data value is stored. This is sometimes
referred to as a variable’s lvalue (pronounced as
“el-value” ).

NOTE
• Remember that constant values and
constant identifiers (declared with const
keyword ) are not lvalues and can only
appear to the right side of an assignment
operator.

DECLARATION OF A
VARIABLE
• Any variable in c++ takes the following:-
• Type name
• Where type is valid c++ data type
• Name is any name you give to the
variable(an identifier).

SYNTAX
• Syntax of variable in c++ :--
type var-name = value;
Here type is a keyword
Var-name is an identifier
=is an assignment operator
Value is the value you assign to the
variable.

INITIALIZATION OF A
VARIABLE
• A variable with a declared first value is
said to be an initialised variable.
• C+= supports two forms of variable
initialization at the time of variable
definition:
• Int val =1001;
• And
• Int val (1001);

NOTE
• Please note that an small l (small L ) or L
suffix on an integer means the integer is a
type long constant, a u or U suffix
indicates an unsigned int constant and ul
or lu indicates a type unsigned long
constant.
• A variable can be declared anywhere in
the c++ program but before its first
reference.

DYNAMIC
INITIALIZATION
• One additional feature of c++ is that it permits
initialization of variable at run time.this is
referred to as dynamic initialization.
• Ex:--
• float avg;
• avg=sum/count;
• The above two statement can be combined
into one as follows :--
• float avg=sum/count;

THE ACCESS MODIFIER
CONST
• If you use modifiers const or constants before a
variable’s definition, it modifies its access type i.e., the
access of the const variable is read only; it can only be
read and written on to.
• For ex:--
• Int val=10;
• The above statement initiates a variable vak which
holds 10.
• Now
• Const int val=10;
• The difference is that the const will never change
throughout the program run whereas simply int val will
change as required .

FORMATTING OUTPUT
• C++ offers various i/o manipulators ;two of
which are setw() and setprecision().
• In order to use these manipulator you
must include header file iomanip.h.

SETW() MANIPULATOR
The setw manipulator sets the width of the
field assigned for the output.
How to use it?
cout<<setw(6) <<“R” ;
The above statement will produce following
output :--
_ _ _ _ _R (each underscore represents a
blank.)

NOTE
• The setw() manipulator does not stick
from one cout statement to the next.

SETPRECISION()
MANIPULATOR
• The setprecision() manipulator sets the
total number of digits to be displayed
when floating point numbers are printed.
• For ex:--
• Cout<<setprecision(5)<<123.456 ;
• Will print the following output to the screen
(notice the rounding)
123.46

SETPRECISION
()contd…
 The setprecision() manipulator can also be used to set
the number of decimal places to be displayed.
 But In Order To Implement It you need to set an ios
flag.
 The flag is set with the following statement :
cout.setf(ios::fixed) ;
 Now setprecision will set the number of decimal
places.
For ex:--
cout<<setprecision(5)<<12.3456789;
Output will be
12.34567

ADDITIONAL IOS
FLAGS
 These are the format options. Other format options can be
one of the following:
 Left ---left -justify the following
 Right---right-justify the following
 Showpoint---display decimal point and trailing zeroes for all
floating point numbers, even if the decimal places are not
needed
 Uppercase---display the “e” in E-notation as “E” rather than
“e”
 Showpos---display a leading plus sign before positive values
 Scientific---display floating-point numbers in scientific
(“E”)notation
 Fixed---display floating-point numbers in normal notation – no
trailing zeroes and no scientific notation

NOTE
• You can remove these options by
replacing setf used with cout, recall
cout.setf) with unsetf.
• Please note that the manipulator
setprecision does sticks that is, the same
format is forwarded for next cout
statements. (it is sticky).s

FLOW CONTROL
• In a program statement may be executed
sequentially, selectively or iteratively.
• Every program language provides
constructs to support sequence, selection
or iteration.

SEQUENCE
• Sequence construct mean statement are
executed sequentially.
• Every program begins with the first
statement of main(). Each statement in
turn executed sequentially when the final
statement of main() is executed the
program is done.

THE SEQUENCE
CONSTRUCT
Statement 1
Statement 2
Statement 3

SELECTION
• The Selection construct means the execution of
statement(s) depending upon a condition-test. If
a condition evaluates to true, a course-of-action
(a set of statements) is followed otherwise
another course-of-action (a different
set of statements).
• This construct(selection construct) is also called
decision construct because it helps in making
decision about which set-of-statements is to be
executed.

THE SELECTION
CONSTRUCT.
Condition ? Statement 1 Statement 2
Statement 1
Statement 2

ITERATION
• Iteration construct means repetition of
set of statements depending upon a
condition test. Till the time of condition
is true. ( or false depending upon the
loop). A set of statements are repeated
again and again. As soon as the
condition become false (or true), the
repetition stops. The iteration condition
is also called ”Looping Construct”.

THE ITERATION
CONSTRUCT
Condition ?
Statement 1
Statement 2
The Loop Body
True
False

THE SELECTION STATEMENT – if
Statement
• An if statement test a particular condition,
if the condition evaluated to true, a course
of action is followed, i.e., a statement or a
set of statement is executed. Otherwise if
the condition evaluated to false then the
course of action is ignored.

SYNTAX OF
IF STATEMENT
• if (condition)
statement 1;
The statement may consist of single or
compound. If the condition evaluates
non zero value that is true then the
statement 1 is executed otherwise if the
condition evaluates zero i.e., false then
the statement 1 is ignored.

Example of if statement
Example 1:
if (age>18)
cout<<“The person is eligible for vote”
Example 2:
if(ch==‘ ‘)
spaces++;

Flow chart of if statement
if Condition ? Statement 1 Statement 2
Statement 1
Statement 2
else
true

IF - ELSE FORMAT
if (condition)
{
Statement 1
Statement 2
}
else
{
Statement 1
Statement 2
}

Example of if-else
If (basic>8000)
{
total_da=(40*basic)/100
gross=total_da + basic
}
else
{
total_da=(40*basic)/100
gross=total_da + basic
}

NESTED IFs
• A nested if is an if that has another if in its
body or in its else body. The nested if can
have one of the following three forms
Form 1 :
if (expression 1)
{
if (expression 2)
statement 1
else
statement 2
}
else
body of else

NESTED IF contd..
• Form 2:
if (expression 1)
{
if (expression 2)
statement 1
else
statement 2
……….
}
else
{
if (expression 2)
statement 1
else
statement 2
……….
}

NESTED IF contd..
• Form 3:
if (expression 1)
{
body of if
}
else
{
if (expression 2)
statement 1
else
statement 2
……….
}

Program to create the equivalent of
a four function calculator
#include<conio.h>
int main()
{
clrscr();
char ch;
float a,b, result;
cout<<"Enter the two values" ;
cin>>a>>b;
cout<<"Enter the Operator [ + - * / ] : ";

Program Contd..
cin>>ch;
if(ch=='+')
result=a+b;
else
if(ch=='-')
result=a-b;
else
if(ch=='*')
result=a*b;
else
if(ch=='/')

Program Contd..
result=a/b;
else
cout<<"Unknown Operation ";
cout<<"nThe Resultis : "<<result;
getch();
return 0;
}

THE if-else-if LADDER
• A common programming construct in C++ is the
if-else-if ladder, which is often also called as the
if-else-if ladder because of its appearance. It
takes the following general form.
if (expression 1) statement 1;
else
if (expression 2) statement 2
else
if (expression 3) statement 3
……….
else
Statement 4;

THE ? : ALTERNATIVE
TO if
• C++ has an operator that can be
alternative to if statement. The
conditional operator ? :
• This operator can be used to replace the if
statement of C++.

CONDITIONAL
OPERATOR ? :
if (expression 2)
statement 1
else
statement 2
• The above form of if else statement can
be replaced as,
expression1?expression2:expression3;

CONDITIONAL
OPERATOR ? :
• For example
int c;
if (a>b)
c=a;
else
c=b;
This can be alternatively written as,
int c;
c=a>b?a : b;

COMPARISON OF if AND ?
:
1. compared to if –else sequence, ?: offers more concise,
clean and compact code, but it is less obvious as compared to
if.
2. Another difference is that the conditional operator ?:
produces an expression, and hence a single value can be
assigned or incorporated into a larger expression, where as if
is more flexible. if can have multiple statements multiple
assignments and expressions (in the form of compound
statement) in its body.
3. When ?: operator is used in its nested form it becomes
complex and difficult to understand. Generally ?: is used to
conceal (hide) the purpose of the code.

THE switch STATEMENT
• C++ provides multiple- branch selection
statement known as switch
This selection statement
successively tests the value of an
expression against the list of integer or
character constants. When a match is
found, the statements associated with that
construct are executed.

THE switch STATEMENT
• The syntax is,
switch(expression)
{
case constant 1 :statement sequence 1;
break;
case constant 2 : statement sequence 2;
break;
case constant n-1 :statement sequence n-1;
break;
default: statement sequence n;
break;
}

fall through
• The expression is evaluated and its values are
matched against the values of the constants specified
in the case statements. When the match is found, the
statement sequence associated with that case is
executed until the break statement or the end of
switch statement is reached. If a case statement
does not include break statement then the control
continues right on the next case statement(s) until
either a break is encountered or end of switch is
reached this situation(missing break in case
statement) is known as “fall through”.

default STATEMENT
• The default statement gets executed when
there is no match found. The default is
optional, and if it is missing then no action
takes place if all matches fail.

Example of switch
#include<conio.h>
void main()
{
clrscr();
int dow;
cout<<“Enter the number of week’s day”;
cin>>dow;
switch(dow)
{
case 1 : cout<<“n Sunday”;
break;

Example of switch
case 2 : cout<<“n Monday”;
break;
case 3 : cout<<“n Tuesday”;
break;
case 4 : cout<<“n Wednesday”;
break;
case 5 : cout<<“n Thursday”;
break;

Example of switch
case 6 : cout<<“n Friday”;
break;
case 7 : cout<<“n Saturday”;
break;
default :cout<<“Wrong number of day”
break;
}
getch();
}

OUT PUT
Enter the number of week’s day 5
Thursday

THE switch Vs. if-else
• The switch and if-else are selection statements
and they both let you select an alternative out of
many alternatives by testing an expression.
However there are some differences in their
operation and they are,
1. The switch statement differs from the if
statement in that switch can only test for equality
where as if can evaluate a relational or logical
expressions i.e multiple conditions.

2. The switch statement selects its
branches by testing the value of same
variable (against the set of constants)
where as the if else construction lets you
to use a series of expressions that may
involve unrelated variables and complex
expressions.

3. The if-else is more versatile of two statements
where as switch cannot. Each switch case label
must be a single value.
4. The if-else statement can handle floating
point tests also apart from integer and
character tests where as switch cannot handle
floating point tests. The case labels of switch
must be an integer or character.

The Nested Switch
• Like if statement, switch can also be
nested. For example following code
fragment is perfectly all right in C++.

The Nested Switch
switch (a)
{
case 1: switch(b)
{
case 0 : cout<<“Divide by zero error”;
break;

The Nested Switch
case 1 : res=a/b;
break;
} // inner switch end
break; // outer switch case 1’s break
case 2 : //outer switch case 2
……
……
} // outer switch end.

More about Switch
1. A switch statement can only work for
equality comparisons.
2. Now two case labels in the same switch
can have the identical values but in case
of nested witch the case constants of
inner and outer switch can contain
common values.

More about Switch
3. If a characters constants are used in
switch statements, they are automatically
converted into integers (equivalent ASCII
codes).
4. The switch statement is more efficient
than if in a situation that supports the
nature of switch operation.

More about Switch
• For example a statement that tests values
against a set of constants like this,
if (wish==‘a’)
{ …..
.….
}
else if (wish ==‘b’)
{ …..
…..
}

More about Switch
else if (wish ==‘c’)
{ …..
…..
}
else
{ …..
…..
}

More about Switch
is better written as a switch statement as,
switch(wish)
{ case ‘a’: ……
..….
break;
case ‘b’ : ……
..….
break;

More about Switch
case ‘c’: ……
..….
break;
default : ……
..….
break;
} //end of switch body

NOTE
Always put break
statement after the
last case statement
in switch.

ITERATION STATEMENT
• The iteration statement allows instructions to be
executed until a certain condition is to be
fulfilled.
• The iteration statements are also called as
loops or Looping statements.
• C++ provides three kinds of loops
• for
• while
• do-while

Elements that control a
Loop
• Every loop has its elements that
control and govern its execution.
Generally a loop has four elements that
have different purposes, they are,

1. INITILIZATION EXPRESSIONS
Before entering in a loop, its control
variable must be initialized. The
initialization expression executed at
only once.

2. TEST EXPRESSION
• The test expression is an expression
whose truth values decides weather the
loop- body will be executed or not. If the
test expression evaluates to true I.e., the
loop gets executed, otherwise the loop
terminated.

3. UPDATED EXPRESSION
The update expression change the
value(s) of loop variable(s). The update
expression(s) is executed; at the end of
the loop after the loop-body is executed.

4. THE BODY OF THE LOOP
The statements that are executed
repeatedly as long as the value of
expression is non zero. If it evaluates to
zero then the loop is terminated.

THE for LOOP
The for loop is the easiest to understand of
the C++ loops. The general form of for
loop is,
for(initialization expression(s); test expression;update expression)
body of for loop

Example :for LOOP
For example:
int main()
{
int i;
for (i=1; i<=10; ++i) // do not give semicolon here.
cout<<“n”<<i;
return 0;
}
NOTE: NO SEMICOLON IN FOR STATEMENT

Example :for LOOP
Initilization exp Test Exp Update Exp
for ( i=1; i<=10; ++i)
cout<<“n”<<i; Body of the loop

THE for LOOP VARIATIONS
• C++ offers several variations that increase
the flexibility and applicability of for loop

1.MULTIPLE
INITIALIZATION & UPDATE
EXPRESSIONS.
• A for loop may contain multiple
initialization and multiple update
statements.
For example:
for(i=1,sum=0;I<=n; sum+=i,++i)
cout<<“n”<<i;

2. PREFER PREFIX
INCREMENT / DECREMENT
OPERATOR OVER POSTFIX
WHEN TO BE USED ALONE.• When you have to simply increment or
decrement value of variable by one, then
prefer prefix over postfix that is for ++i or –
i. The reason being that when used alone,
prefix faster executed than postfix. i.e.,
• for(i=1;i<n;++i) // prefer this
Over this, for(i=1;i<n;i++)

3. OPTIONAL EXPRESSIONS
• In a for loop initialization expression, test
expression and update expression are optional.
i.e., you can skip any or all of these expressions.
• for example you have initialize the variables you
want to scrap off the initialization expression
then you can write as,
• for(; test expression;update expression)

3. OPTIONAL EXPRESSIONS
For example,
int i=0,sum=0;
for(;i<=n; sum+=i,++i)
cout<<“n”<<i;

4. INFINITE LOOP
• An infinite for loop can be created by omitting
the test expressions.
• For example,
for(j=25; ; --i)
cout<<“An infinite Loop”;
Similarly the following for loop also infinite loop
for( ; ;)
cout<<“Endless for loop;
NOTE: PRESS CTRL + BREAK TO TERMINATE
THE PROGRAM EXECUTION

5. EMPTY FOR LOOP
• If a loop does not contain any statement in its
loop-body, it is said to be an empty for loop.
• For example,
• for( j = 20; ( j ) ; --j ); // j tests for non
//zero value of j.
• See here the loop body contains null statement.
An empty for loop has an application in pointer
manipulation where you need to increment or
decrement the pointer position without doing
anything else.

TIME DELAY LOOPS
• Time delay loops are often used in the
programs. It is created by using for loop
• for example,
• For(t=0;t<300;++t);
That means if you put a semicolon after for’s
parenthesis it repeats only for counting the
control variable and if you put a block of
statements after such a loop then it is not a part
of for loop.

TIME DELAY LOOPS
For example,
for(i=0;i<10;++i) ; this semicolon ends
the loop here only.
{
cout”I=“<<i;<<endl; this is not a body of
} for loop.

6. DECLARATION OF
VARIABLES IN THE LOOP• C++ allows to declare variables anywhere
in a program. So they are generally
declared immediately before there first
reference.
• For example
for(int i=0;i<10;++i)
NOTE : Variables can be accessed only in
the block where it has been declared.

VARIABLE’S SCOPE
• The program area inside which a variable
can be accessed, is called variable’s
scope.

THE SCOPE OF LOCAL
LOOP VARIABLE
• Up till now, a variable declared in the for
or while loop could be accessed after the
statement because the variable
declaration had not taken place within the
braces of the loop block, the item would
still be in scope when the loop terminates.
That means the same variable could not
be declared in another loop in the same
scope.

THE SCOPE OF LOCAL
LOOP VARIABLE
• For example,
for(char ch=‘a’; ch<=‘z’; ++ch)
{
……
……
}
cout<<ch; // ch was still valid. It was still in the
//scope
for(char ch=‘a’; ch<=‘z’; ++ch) // Wrong!!!
{
……
……
}

THE SCOPE OF LOCAL
LOOP VARIABLE
• As per the latest ANSI/ISO specifications,
the variables declared inside the
parenthesis of for and while loops are not
accessible after the loop is over.but this
would be implemented in newer versions
of the compilers.

THE while LOOP – AN
ENTRY CONTROLLED LOOP• The second loop available in C++ is the while
loop. The while loop is an entry controlled loop
the syntax of while is,
while(expression)
Loop body
Where, loop body contain the single statement
or set of statements (compound statement) or
an empty statement. The loop iterates while the
expression evaluates to true, when expression
becomes false the loop terminates.

VARIATIONS IN while
LOOP
• A while loop can also have variations.it
can be
1. Empty loop : it does not contain any
statement in its body.
2. An infinite loop : while can be infinite if
you forget to update expression inside
the body of the loop.

EXAMPLE : EMPTY LOOP
….
….
long wait=0;
while (++wait<10000)
The above given is the TIME DELAY
LOOP. It is useful for pausing the program
for some time.

EXAMPLE : INFINITE
LOOPj=0
while(j<=n)
cout<<“n”<< j * j ;
j++;
….
….
The above loop is an infinite loop as a only one
statement taken into a loop’s body

EXAMPLE : FINITE LOOP
j=0
while(j<=n)
{
cout<<“n”<< j * j ;
j++;
}
….
….
The above loop is an finite loop. It will terminate
as soon as the value of j exceeds the n.

THE do-while LOOP – AN
EXIT CONTROLLED LOOP
• Unlike the for and while the do-while loop is an
exit controlled loop. i.e., it evaluates its test
expression at the bottom of the loop after
executing its loop –body statements.
• The syntax is,
do
{
Statements
}while(test expression); // here semicolon must

THE do-while LOOP – AN
EXIT CONTROLLED LOOP
char ch=‘A’;
do {
cout<<“n”<<ch;
ch++;
} while (ch<=‘Z’);
The above code prints the character from ‘A’
onwards util the condition ch<=‘Z’ becomes false.
The most common use of the do-while loop is in
menu selection routine, where the menu is flashed at
once and depending upon the users response either
it is repeated or terminated.

NESTED LOOPS
• A loop can contain another loop in its body. This
form of a loop is called nested loop. In nested
loop the inner loop must terminate before the
outer loop.
for(i=1;i<=5;i++)
{ cout<<“n”;
for(j=1;j<=i;j++)
cout<<“* “;
}
The above prints following out put
*
* *
* * *
* * * *
* * * * *

COMPARISON OF LOOPS
• The for loop is appropriate when you know in
advance how many times the loop will be
executed.
• The other two loops while and do-while are
more suitable in the situations where it is
known before –hand when the loop will
terminate. The while should be preferred
when you may not want to execute the loop
body even once (in case test condition is
false), and the do-while loop should be
preferred when you are sure you want to
execute the loop body at least once.

JUMP STATEMENT - goto
• The goto statement is rarely used in the
programming.
• A goto statement can transfer the program
control anywhere in the program. The target
destination of a goto statement is marked by
the label. The syntax is,
goto label; //here you put semicolon
…….
…….
…….
label : //here you put colon

JUMP STATEMENT
• C++ has the four statements that perform an
unconditional branch. They are,
1. return
2. goto
3. break
4. continue
In addition to four statements C++ library
function provides exit() that helps you break out
of the program.

JUMP STATEMENT – goto
Example
A=0;
start :
cout<<“n”<<++a;
if(a<50) goto start;

NOTE:
Label may not immediately precede the closing
right brace. If so then a null statement may be
used.
For example
…….
{ goto last;
…..
…..
last: // wrong!
}

NOTE:
For example
…….
{ goto last;
…..
…..
last: ; // null statement right!
}

NOTE:
• goto statement may not jump forward over the
variable definition.
main()
{
goto last; // Wrong! Jumping over the variable definition
char ch=‘a’;
……
last:
}

break STATEMENT
The break statement enables the
program to skip over the part of the code.
A break statement terminates the smallest
enclosing while,do-while for or switch
statement,

break STATEMENT
-EXAMPLE
while (test expression)
{
statement
if(val>2000)
break;
…..
statement;
}
statement 3;

break STATEMENT
-EXAMPLE
for( int;test expression;update expression)
{
statement
if(val>2000)
break;
…..
statement;
}
statement 3;

break STATEMENT
-EXAMPLE
do {
statement
if(val>2000)
break;
…..
statement;
} while (test expression);
statement 3;

THE continue STATEMENT
• The continue statement is the another
jump statement like the break as the both
the statements skips over the part of code
but the continue statement is some what
different than the break. Instead of forcing
for termination it forces for the next
iteration of the loop to take place.

THE continue
STATEMENT EXAMPLE
while (test expression)
{
statement
if(condition)
continue;
…..
statement;
}
statement 3;

THE continue
STATEMENT EXAMPLE
for (int; test expression; updateexpression )
{
statement
if(condition)
continue;
…..
statement;
}
statement 3;

THE continue
STATEMENT EXAMPLE
do
{
statement
if(condition)
continue;
…..
statement;
} while (test expression);
statement 3;

THE exit() FUNTION
• The exit() function causes the program to
terminate as soon as it is encountered.
• The exit() function is a C++ standard
library function defined in process.h file.
which must be included in the program
that uses exit() function

EXAMPLE-exit()
FUNCTION
// Program to check entered number is prime number or not
#include<conio.h>
#include<process.h>
void main()
{
int num,i;
clrscr();
cout<<"Enter the Number: ";
cin>>num;
for(i=2; i<=num/2;++i)
{
cout<<"n Not a Prime Number";
exit(0);
}
cout<<"n It is Prime Number";
getch();
}
Enter the Number: 4
Not a Prime Number

INTRODUCTION
• In computer science, library is a collection
of subprograms used to develop software.
• Libraries are not independent programs,
rather they are helper code used in other
independent programs

What is Library?
A Library is a collection of
subprograms used to develop other
programs and software.
C++ Library functions stores function in
same category.(i.e., Mathematical
Functions, String Functions etc..) under
separate file known as header files

stdio.h
• This header file defines types and macros
needed for the standard I/O package.

stdio.h
clearerr fclose fcloseall fdopen feof ferror
fflush fgetc fgetchar fgetpos fgets fileno
flushall fopen fprintf fputc fputchar fputs
fread freopen fscanf fseek fsetpos ftell
fwrite getc getchar gets getw perror
printf putc putchar puts putw remove
rename rewind rmtmp scanf setbuf setvbuf
sprintf sscanf strerror _strerror tempnam tmpfile
tmpnam ungetc unlink vfprintf vfscanf vprintf
vscanf vsprintf vsscanf

string.h
• This header file declares several string
manipulation and memory manipulation
routines.

string.h
_fmemccpy _fmemchr _fmemcmp _fmemcpy _fmemicmp
_fmemset _fstrcat _fstrchr _fstrcmp _fstrcpy
_fstrcspn _fstrdup _fstricmp _fstrlen _fstrlwr
_fstrncat _fstrncmp _fstrnicmp _fstrncpy _fstrnset
_fstrpbrk _fstrrchr _fstrrev _fstrset _fstrspn
_fstrstr _fstrtok _fstrupr memccpy memchr
memcmp memcpy memicmp memmove memset
movedata movmem setmem stpcpy strcat
strchr strcmp strcmpi strcpy strcspn
strdup _strerror strerror stricmp strlen
strlwr strncat strncmp strncmpi strncpy
strnicmp strnset strpbrk strrchr strrev
strset strspn strstr strtok strxfrm
strupr

math.h
abs acos, acosl asin, asinl
atan, atanl atan2, atan2l atof, _atold
cabs, cabsl ceil, ceill cos, cosl
cosh, coshl exp, expl fabs, fabsl
floor, floorl fmod, fmodl frexp, frexpl
hypot, hypotl labs ldexp, ldexpl
log, logl log10, log101 matherr, _matherrl
modf, modfl poly, polyl pow, powl
pow10, pow10l sin, sinl sinh, sinhl
sqrt, sqrtl tan, tanl tanh, tanhl

stdlib.h
• This header file declares several
commonly used routines like conversion
routines. The function contained in stdlib.h
are,

stdlib.h
abort abs atexit atof atoi
atol bsearch calloc div ecvt
exit _exit fcvt free _fullpath
gcvt getenv itoa labs ldiv
lfind _lrotl _lrotr lsearch ltoa
_makepath malloc max mblen mbtowc
mbstowcs min putenv qsort rand
random randomize realloc _rotl _rotr
_searchenv _splitpath srand strtod strtol
_strtold strtoul swab system time
ultoa wctomb wcstombs

iostream.h
• The header file declares the basic C++
streams input/output routines. Some of the
functions defined in it are,

iostream.h
open close get getline read write put
seekg seekp telg telp ignore pick putback
flush rdstate bad eof fill good

STRING AND CHARACTER
RELATED FUNCTIONS
• The string related functions are defined in
the string.h standard library header file
and the character related functions are
defined in the ctype.h header file.

int isalnum(int ch)
• The isalnum() function returns nonzero
if its arguments is a letter or digit. If the
character is not an alpha numeric
isalnum() returns zero.
• For example
char ch;
cin>>ch;
if(isalnum(ch)) cout<<“alpha numeric”;

int isalpha(int ch)
• This function returns non zero if ch is an
alphabet, otherwise it returns zero.
if(isalpha(ch))
cout<< “it is alphabeatic” ;

Int isdigit (int ch)
• Returns nonzero if ch is a digit (i.e.,0-
9).Otherwise it returns zero.
if (isdigit(ch))
cout<< “It is digit”;

int islower (int ch)
• Returns nonzero if ch is a lowercase
letter ; otherwise it returns zero.
if (islower (ch))
cout<< “Lowercase letter”;

int isupper (int ch)
• This function returns nonzero if ch is
uppercase ; otherwise, it returns zero.
if (isupper (ch))
cout<< “uppercase character” ;

int toupper (int ch)
• This function returns the uppercase
equivalent of ch if ch is a letter ; otherwise,
ch is returned unchanged.
char ch=‘a’;cout<<toupper (ch);
(it will print A).

int tolower (int ch)
• This function returns the lowercase
equivalent of ch if ch is a letter; otherwise
ch is returned unchanged.
char ch =‘a’;cout<<tolower (ch);
(It will print a.)

Function Definition
• Using functions we can structure our programs in a
more modular way, accessing all the potential that
structured programming can offer to us in C++.
A function is a group of statements that is executed
when it is called from some point of the program.
The following is its format:

type name ( parameter1, parameter2, ...)
{
statements
}
where:
• type is the data type specifier of the data returned by the function.
• name is the identifier by which it will be possible to call the
function.
• parameters (as many as needed): Each parameter consists of a
data type specifier followed by an identifier, like any regular
variable declaration (for example: int x) and which acts within the
function as a regular local variable. They allow to pass arguments
to the function when it is called. The different parameters are
separated by commas.
• statements is the function's body. It is a block of statements
surrounded by braces { }.
Function Definition

Here you have the first function
example:
// function example
#include <iostream>
int addition (int a, int b)
{
int r;
r=a+b;
return (r);
}
int main ()
{
int z;
z = addition (5,3);
cout << "The result is " << z;
return 0;
}

WORKING OF FUNCTION
• We can see how the main function begins by
declaring the variable z of type int. Right
after that, we see a call to a function called
addition. Paying attention we will be able to
see the similarity between the structure of
the call to the function and the declaration of
the function itself some code lines above:
The parameters and arguments have a clear
correspondence. Within the main function
we called to addition passing two values: 5
and 3, that correspond to the int a and int b
parameters declared for function addition

WORKING OF FUNCTION
•
At the point at which the function is called from
within main, the control is lost by main and
passed to function addition. The value of both
arguments passed in the call (5 and 3) are copied
to the local variables int a and int b within the
function.
Function addition declares another local variable
(int r), and by means of the expression r=a+b, it
assigns to r the result of a plus b. Because the
actual parameters passed for a and b are 5 and 3
respectively, the result is 8.
The following line of code:
• return (r);

WORKING OF FUNCTION
• finalizes function addition, and returns the control back to
the function that called it in the first place (in this case,
main). At this moment the program follows its regular
course from the same point at which it was interrupted by
the call to addition. But additionally, because the return
statement in function addition specified a value: the
content of variable r (return (r);), which at that moment had
a value of 8. This value becomes the value of evaluating the
function call.
So being the value returned by a function the value given to
the function call itself when it is evaluated, the variable z
will be set to the value returned by addition (5, 3), that is 8.
To explain it another way, you can imagine that the call to a
function (addition (5,3)) is literally replaced by the value it
returns (8).
The following line of code in main is:
cout << "The result is " << z;

FUNCTION PROTOTYPE
A Function Prototype is a
declaration of the function that tells
the program about the type of the
value returned by the function and
the type of argument.

DECLARING FUNCTIONS
Until now, we have defined all of the
functions before the first appearance of calls to
them in the source code. These calls were
generally in function main which we have always
left at the end of the source code. If you try to
repeat some of the examples of functions
described so far, but placing the function main
before any of the other functions that were called
from within it, you will most likely obtain
compiling errors. The reason is that to be able to
call a function it must have been declared in
some earlier point of the code, like we have done
in all our examples.
FUNCTION
PROTOTYPE

But there is an alternative way to avoid writing
the whole code of a function before it can be used in
main or in some other function. This can be
achieved by declaring just a prototype of the
function before it is used, instead of the entire
definition. This declaration is shorter than the entire
definition, but significant enough for the compiler to
determine its return type and the types of its
parameters.
FUNCTION
PROTOTYPE

Its form is:
type name ( argument_type1, argument_type2, ...);
It is identical to a function definition, except that it
does not include the body of the function itself (i.e.,
the function statements that in normal definitions
are enclosed in braces { }) and instead of that we
end the prototype declaration with a mandatory
semicolon (;).
FUNCTION
PROTOTYPE

The parameter enumeration does not need to
include the identifiers, but only the type specifiers.
The inclusion of a name for each parameter as in the
function definition is optional in the prototype
declaration. For example, we can declare a function
called protofunction with two int parameters with
any of the following declarations:
int protofunction (int first, int second);
int protofunction (int, int);
FUNCTION
PROTOTYPE

// declaring functions prototypes
#include <iostream>
void odd (int a);
void even (int a);
int main ()
{
int i;
do {
cout << "Type a number (0 to exit): ";
cin >> i;
odd (i);
} while (i!=0);
return 0;
}
FUNCTION
PROTOTYPE

void odd (int a)
{
if ((a%2)!=0) cout << "Number is odd.n";
else even (a);
}
void even (int a)
{
if ((a%2)==0) cout << "Number is even.n";
else odd (a);
}
FUNCTION
PROTOTYPE

This example is indeed not an example of
efficiency. I am sure that at this point you can
already make a program with the same result, but
using only half of the code lines that have been used
in this example. Anyway this example illustrates how
prototyping works. Moreover, in this concrete
example the prototyping of at least one of the two
functions is necessary in order to compile the code
without errors.
FUNCTION
PROTOTYPE

The first things that we see are the declaration of functions odd
and even:
void odd (int a);
void even (int a);
This allows these functions to be used before they are defined, for
example, in main, which now is located where some people find it
to be a more logical place for the start of a program: the beginning
of the source code.
Anyway, the reason why this program needs at least one of the
functions to be declared before it is defined is because in odd
there is a call to even and in even there is a call to odd. If none of
the two functions had been previously declared, a compilation
error would happen, since either odd would not be visible from
even (because it has still not been declared), or even would not be
visible from odd (for the same reason).
FUNCTION
PROTOTYPE

Having the prototype of all functions
together in the same place within the
source code is found practical by some
programmers, and this can be easily
achieved by declaring all functions
prototypes at the beginning of a
program.
FUNCTION
PROTOTYPE

DEFAULT ARGUMENTS
When declaring a function we can specify a
default value for each of the last parameters.
This value will be used if the corresponding
argument is left blank when calling to the
function. To do that, we simply have to use
the assignment operator and a value for the
arguments in the function declaration. If a
value for that parameter is not passed when
the function is called, the default value is
used, but if a value is specified this default
value is ignored and the passed value is
used instead. For example:

// default values in functions
#include <iostream.h>
int divide (int a, int b=2)
{
int r;
r=a/b;
return (r);
}
int main ()
{
cout << divide (12);
cout << endl;
cout << divide (20,4);
return 0;
}
DEFAULT ARGUMENTS

As we can see in the body of the program there are
two calls to function divide. In the first one:
divide (12)
we have only specified one argument, but the
function divide allows up to two. So the function
divide has assumed that the second parameter is 2
since that is what we have specified to happen if this
parameter was not passed (notice the function
declaration, which finishes with int b=2, not just int
b). Therefore the result of this function call is 6
(12/2).
DEFAULT ARGUMENTS

In the second call:
divide (20,4)
there are two parameters, so the
default value for b (int b=2) is ignored
and b takes the value passed as
argument, that is 4, making the result
returned equal to 5 (20/4).
DEFAULT ARGUMENTS

CONSTANTS
By constant arguments meant that the
function can not modify these arguments. If you
pass constant values to the function, then the
function can not modify the values as the values
are constants.
In order to make the argument constant to
the function we can use the keyword const as
shown bellow,
int sum(const int a , const int b);

CALL BY VALUE
Until now, in all the functions we have seen, the
arguments passed to the functions have been
passed by value. This means that when calling a
function with parameters, what we have passed
to the function were copies of their values but
never the variables themselves. For example,
suppose that we called our first function addition
using the following code:
int x=5, y=3, z;
z = addition ( x , y );
What we did in this case was to call to function
addition passing the values of x and y, i.e. 5 and 3
respectively, but not the variables x and y
themselves.

CALL BY VALUE
What we did in this case was to call to
function addition passing the values of x
and y, i.e. 5 and 3 respectively, but not the
variables x and y themselves.

CALL BY VALUE
This way, when the function addition is
called, the value of its local variables a and b
become 5 and 3 respectively, but any
modification to either a or b within the function
addition will not have any effect in the values of
x and y outside it, because variables x and y
were not themselves passed to the function, but
only copies of their values at the moment the
function was called.

CALL BY VALUE
But there might be some cases where you
need to manipulate from inside a function
the value of an external variable. For that
purpose we can use arguments passed by
reference, as in the function duplicate of
the following example:

CALL BY REFERENCE
The call by reference method uses a different
mechanism. In place of passing value to the
function being called.
A reference is an alias (i.e different name) for
a predefined variable.

CALL BY REFERENCE
There might be some cases where you
need to manipulate from inside a function
the value of an external variable. For that
purpose we can use arguments passed by
reference, as in the function duplicate of
the following example:

CALL BY REFERENCE
// passing parameters by reference
#include <iostream>
void duplicate (int& a, int& b, int& c)
{
a*=2;
b*=2;
c*=2;
}
int main ()
{
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}

CALL BY REFERENCE
The first thing that should call your attention is that in
the declaration of duplicate the type of each parameter was
followed by an ampersand sign (&). This ampersand is what
specifies that their corresponding arguments are to be
passed by reference instead of by value.
When a variable is passed by reference we are
not passing a copy of its value, but we are somehow
passing the variable itself to the function and any
modification that we do to the local variables will have an
effect in their counterpart variables passed as
arguments in the call to the function.

CALL BY REFERENCE
To explain it in another way, we associate
a, b and c with the arguments passed on the
function call (x, y and z) and any change that
we do on a within the function will affect the
value of x outside it. Any change that we do
on b will affect y, and the same with c and z.
That is why our program's output, that shows
the values stored in x, y and z after the call to
duplicate, shows the values of all the three
variables of main doubled.

CALL BY REFERENCE
If when declaring the following function:
void duplicate (int& a, int& b, int& c)
we had declared it this way:
void duplicate (int a, int b, int c)

CALL BY REFERENCE
// more than one returning value
#include <iostream>
using namespace std;
void prevnext (int x, int& prev, int& next)
{
prev = x-1;
next = x+1;
}
int main ()
{
int x=100, y, z;
prevnext (x, y, z);
cout << "Previous=" << y << ", Next=" << z;
return 0;
}

CALLING FUNCTION WITH
ARRAYS
Arrays as parameters
At some moment we may need to pass an array
to a function as a parameter. In C++ it is not possible
to pass a complete block of memory by value as a
parameter to a function, but we are allowed to pass
its address. In practice this has almost the same
effect and it is a much faster and more efficient
operation.
In order to accept arrays as parameters the only
thing that we have to do when declaring the function
is to specify in its parameters the element type of the
array, an identifier and a pair of void brackets []. For
example, the following function:

ARRAYS
void procedure (int arg[])
accepts a parameter of type "array of int"
called arg. In order to pass to this function
an array declared as:

ARRAYS
int myarray [40];
it would be enough to write a call like
this:.
procedure (myarray);

ARRAYS
// arrays as parameters
#include <iostream>
using namespace std;
void printarray (int arg[], int length) {
for (int n=0; n<length; n++)
cout << arg[n] << " ";
cout << "n";
}
int main ()
{
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
printarray (firstarray,3);
printarray (secondarray,5);
return 0;
}

ARRAYS
As you can see, the first parameter (int arg[]) accepts any array whose
elements are of type int, whatever its length. For that reason we have
included a second parameter that tells the function the length of each
array that we pass to it as its first parameter. This allows the for loop
that prints out the array to know the range to iterate in the passed
array without going out of range.
In a function declaration it is also possible to include
multidimensional arrays. The format for a tridimensional array
parameter is:
base_type[][depth][depth]
for example, a function with a multidimensional array as argument
could be:
void procedure (int myarray[][3][4])

ARRAYS
First Way
void main()
{
int age[10];
cout<<“enter the elements”;
for(i=0;i<n;i++)
cin>>age[i];
display(age);
}
See for passing array, only its name (age)
is passed as an argument
void display (int a[10])
{
for (i=0;i<10;i++)
cout<<“n”<<a[i];
}
See receiving parameter has
been declared with its size

ARRAYS
Second way
void main()
{
int age[10];
for(i=0;i<n;i++)
cin>>age[i];
display(age);
}
void display (int a[ ] )
{
for (i=0;i<10;i++)
}
been declared without specifying
its size

ARRAYS
Third way
void main()
{
int age[10];
for(i=0;i<n;i++)
cin>>age[i];
display(age);
}
void display (int *a )
{
for (i=0;i<10;i++)
}
been declared as pointer of same
base type

RECURSION
Recursivity is the property that functions have to be
called by themselves. It is useful for many tasks, like
sorting or calculate the factorial of numbers. For
example, to obtain the factorial of a number (n!) the
mathematical formula would be:
n! = n * (n-1) * (n-2) * (n-3) ... * 1
more concretely, 5! (factorial of 5) would be:
5! = 5 * 4 * 3 * 2 * 1 = 120
and a recursive function to calculate this in C++
could be:

RECURSION
// factorial calculator
#include <iostream>
long factorial (long a)
{
if (a > 1)
return (a * factorial (a-1));
else
return (1);
}
int main ()
{
long number;
cout << "Please type a number: ";
cin >> number;
cout << number << "! = " << factorial (number);
return 0;
}

RECURSION
Notice how in function factorial we
included a call to itself, but only if the
argument passed was greater than 1,
since otherwise the function would
perform an infinite recursive loop in which
once it arrived to 0 it would continue
multiplying by all the negative numbers
(probably provoking a stack overflow error
on runtime).
This function has a limitation because of
the data type we used in its design (long)
for more simplicity. The results given will
not be valid for values much greater than
10! or 15!, depending on the system you
compile it.

RETURNING FROM A
FUNCTION
As invoking a function is important,
returning from a function is equally
important as it not only terminates the
functions execution but also passes
the control back to the calling function.

THE RETURN STATEMENT
The return statement is useful in
two ways. First an immediate exit
from the function is caused as soon
as the return statement is
encountered and the control is
passes back to statement following
the called function in the calling
code. The general format of return
statement is ,
return(value);

SCOPE OF
VARIABLE
The scope of variables declared within a
function or any other inner block is only their
own function or their own block and cannot be
used outside of them. For example, in the
previous example it would have been
impossible to use the variables a, b or r directly
in function main since they were variables local
to function addition. Also, it would have been
impossible to use the variable z directly within
function addition, since this was a variable local
to the function main.

SCOPE OF VARIABLE
Therefore, the scope of local variables is
limited to the same block level in which they
are declared. Nevertheless, we also have the
possibility to declare global variables; These
are visible from any point of the code, inside
and outside all functions. In order to declare
global variables you simply have to declare
the variable outside any function or block;
that means, directly in the body of the
program.

INLINE FUNCTION
The inline specifier indicates the compiler that inline substitution is
preferred to the usual function call mechanism for a specific function. This
does not change the behavior of a function itself, but is used to suggest to
the compiler that the code generated by the function body is inserted at
each point the function is called, instead of being inserted only once and
perform a regular call to it, which generally involves some additional
overhead in running time.
The format for its declaration is:
inline type name ( arguments ... )
{
Statements
}
and the call is just like the call to any other function. You do not have to
include the inline keyword when calling the function, only in its declaration.
Most compilers already optimize code to generate inline functions when it is
more convenient. This specifier only indicates the compiler that inline is
preferred for this function.

STRUCTURES
In C++ language, custom data types can be
created to meet users requirements in 5 ways:
class, structure, union, enumeration and typedef.
Structures are one of the 2 important building
blocks in the understanding of classes and
objects. A structure is a collection of data and
functions. In other words, we can say, a structure
plus related functions make a class. Technically
,there is no difference between a structure and a
class. In fact,a structure is a class declared with
keyword struct and by default, all members are
public in a structure whereas all members are
private by default in the class.

STRUCTURES
Sometimes, some logically related elements need
to be treated under one unit. For instance, the
elements storing a student’s information (e.g.,
rollno, name, class, marks, grade) need t be
processed together under one roof. Similarly,
elements keeping a date’s information (e.g., day,
month, and year) need to be processed together.
To handle and serve to such situation, C++ offers
structures.
Thus it can be said that ,
A C style structures is a collection of variables
referenced under one name.

STRUCTURES
The following code fragment shows
how to define a structure (say date).
The keyword struct tells the compiler
that a structure is being defined.
struct date { short day;
short month;
short year;};

STRUCTURES
In the above definition, the date is a structure tag and it identifies this
particular data structure and its type specifier. Also remember, at this point of
time (i.e., after the above definition), no structure variable has been declared,
that is , no memory space has bee reserved. Only the form of the data has
been defined. To declare a structure variable having the data form as defined
by date, we will write
Date joining_date;
This declares a structure variable joining_date of type date. Thus, the
complete structure definition is as follows:
struct date
{
short day ;
short month;
short year;
};
Date joining _date ;
Now, the structure joining date will be having its elements as day month and
year. The c++ compiler automatically allocates sufficient memory to
accommodate all of the element variable that make up a structure variable.

STRUCTURES
Technically ,there is no difference
between a structure and a class. In fact,
a structure is a class declared with
keyword struct and by default, all
members are public in a structure
whereas all members are private by
default in the class.

STRUCTURE
In simple terms structure can
be defined as,
It is a collection of variables
referenced under one name.

REFERENCING STRUCTURE
ELEMENTS
The Structure variable name is
followed by a period (.) and the element
name references to that individual
structure element.
The syntax of accessing structure
element is,
structure-name.element-name

REFERENCING STRUCTURE
ELEMENTS
The structure members are treated like
other variables. Therefore , to print the year
of joining date, we can write,
cout<<joining_date.year;
In the same fashion to read the members
of the structure we can write,
cout<<joining_date.day>>joining_date.month;
cout<<joining_date.year;

NESTED STRUCTURES
A structure can be nested inside another.
Following code fragment illustrates it;
struct addr
{
int houseno;
char area[26];
char city[26];
char state[26];
};
struct emp
{
int empno;
char name[26];
char desig[16];
addr address;
float basic;
}worker;
See the address is structure
variable itself and is member
of another structure

ACCESSING NESTED
STRUCTURE MEMBERS
The members of the structures are
accessed using dot operator. To access the
city member of address structure which is an
element of another structure worker we shall
write
worker.address.city
To initialize houseno member of address
structure, element of worker structure, we
can write as follows,
worker.address.houseno=1694

ARRAYS OF STRUCTURE
Since array can contain similar elements the
combination having structures within an array is
an array of structure
To declare the array of structure, you must
first define a structure and then array variable of
that type. For instance, to store addresses of 100
members of council, you need to create an
array
addr mem_addr[100];
This creates 100 sets of variables that are
organised as defined in the structure.
To access we can write,
cout<<mem_addr[7].houseno;
This statement is to print house no position of 8

ARRAYS WITHIN
STRUCTURE
A structure can have an array as one of its elements.
For example,
struct student
{
int rollno;
char name[20];
float marks[5];
};
student learning;
The above declared structure variable learner is of structure type
student that contains an element which is an array of 5 floats to store
marks of student 5 different subjects
To reference marks of 3rd
subject of structure learner, we shall write,
learner.marks[2]

PASSING STRUCTURES TO
FUNCTIONS
Structures can be passed to a functions by
value as well as by reference method.
In Call By Value, the called function copies
the passed structure then remains unaffected.
In Call By Reference, the called function
declares a reference for the passed structure
and refers to the original structure elements
through its reference.

PROGRAM
struct emp
{
int empno;
char name[25];
double salary;
};
void reademp(Emp &e)
{
cout <<“Enter Employee No”; cin>>e.empno;
cout<<“Enter the Employee Name”; cin>>e.name;
cout<<“Enter the salary “ ; cin>>e.salary;
}

PROGRAM (contd…)
void showemp(Emp e)
{
cout<<“Employee Details”;
cout<<“Employee Number<<e.empno”;
cout<<“Name”<<e.name;
cout<<“Salary “<<e.salary;
}
void main()
{
emp e1;
reademp(e1);
showemp(e1);
}

INTRODUCTION
An array is a collection of variables
of same type that are referenced by a
common name .
C++ allows more type of data i.e its
derived data type.(integer and floating
point).

TYPES OF ARRAYS
1.SINGLE DIMENTION ARRAY
It is simplest type of array . indices
no starts with 0.
An array must be defined before it
can be used to store information . Ex.
Type array-name[size]
The data type of array elements is
known as the base type of the array.

TYPES OF ARRAYS
1.SINGLE DIMENTION ARRAY
MEMORY REPRESENTATION OF SINGLE
DIMENTION ARRAYS
Single dimension arrays are essentially
list of information of same type and stored in
contiguous memory location in their index
order. Ex .
Char grade [8];
Will have element grade[0] at first location
Grade[1] in the next position.

TYPES OF ARRAYS
.
Adderess 2000 2001 2002 20003 20004
The amount of storage required to hold
an array is directly related to its type
and size can be computed on the
following formule
Total bytes=sizeof(type)*size of array.
Grade[0] Grade[1] Grade[2] Grade[3] Grade[4]

STRING AS AN ARRAY
C++ does not have string data type
rather it implements string as a single –
dimension character array. A string is
defined as a character array that is
terminated by a null character. Ex.
To declare an character array that
hold 10 character string we would write
Char strg[11] ;

TWO DIMENSIONAL ARRAY
A two dimensional array is an array in
which each element is itself an array. Ex
An array A[m][n] is an m by n table with
m rows and n columns containing m*n table.
0 N-1
0
M-1

PROCESSING 2 D ARRAY
We use nested loops to process 2 d array. one
loop process the rows and another columns .If
outer loops is for rows and inner loop for columns
then each row index,all columns are processed
and then the same process is repeated.
int A [2] [3];
int I,j;
For(i=0;i<2;++i)
{
for (j=0;j <3 ; ++j)
{ cout<<“enter element”;
cin >> A [ i ] [ j ] ;
}
}

MEMORY REPRESENTATION
OF 2D ARRAY
Two dimension array are stored in a row
column matrix, where the first index
represents the row and second indicates the
row. This means that the second index
changes faster than first index when
accessing the elements in an array order.
The formula to calculate the total number
of bytes of two d array are:
Total bytes=no of rows *no of columns*size of base

MATRICES AS 2DARRAYS
Matrix is a set of mn numbers arranged
in a rectangular array of m rows and n
columns. Such matrix is called m by n
matrix.
int Mat [5] [4] ; //if matrix contains integers
Or
float Mat [5] [4] ;

ARRAY OF STRINGS
An array of string is a two dimensional
character array . The size of the first index
determines the number of strings and size
of second index determines maximum
length of each string.

ARRAY INITIALIZATION
C++ provides the facility of an array
initialization at the time of declaration. The
arrays are initialization in the same way as
other variable.ex .
Type array – name [size1]…..[size N]
Following code initialises an integer
array with 12 elements
Int days of months [12]={31,28,31,30,31,31,30,31,30,31}
This would place 31 is month [0]0,28 is
month [2].

ARRAY INITIALIZATION
Character arrays can be also initialized like:
Char string [10]=“program”;
Will initialize it as
Char string [10]=“{‘p’ , ‘r’ , ‘o’ , ‘g’ , ,’r’ , ‘a’ ,’m’, 0}
Two dimension will do it in:
Int cube [ 5 ] [2]= { 1 ,1,
2 , 8
3, 27
4, 68
5, 25
};

UNSIZE ARRAY
INITIALIZATION
C++ allows you to skip the size of an
array is the initialization . This is called an
unsize array. C++ calculates is size and
creates it as required.
char s1 [ ] =“first string”;
int val[ ]={2, 3, 4, 5, 6, 7, 8, 9};
float amount [ ]={2341.57, 1900.70, 3986.65 ,
4466.65 , 5151.56};

ARRAY
C++ interprets an array name as the
address of its first element. C++ treats the
name of an array as if it were a pointer.
When an array is used as an argument
to a function, only the address of the array
gets passed not a copy of the entire array.

AN INTERESTING THING
ABOUT AN ARRAY
Since name of an array is pointer to its
first element ,the array name +1gives the
address of the next element.+2 gives the
address of the third element. So for an int
array Val[10] ,if you pass val+2 as an
argument to the function the array is passed
But from its third element onward. Ex.
biggest =large(amount+5 , i+2) ;

1 Revision Tour

More Related Content

What's hot (20)

Similar to 1 Revision Tour (20)

More from Praveen M Jigajinni (20)

Recently uploaded (20)

1 Revision Tour