C++ Character Set

Character set is a set of valid characters that a language can recognize.

Letters A-Z, a-z
Digits 0-9
Special Space + - * / ^ \ () [] {} = != <> ‘ “ $ , ; : % ! &
Characters ? _ # <= >= @
Formatting backspace, horizontal tab, vertical tab, form feed, and
characters carriage return

Tokens
A token is a group of characters that logically belong together. The programmer can write a
program by using tokens. C++ uses the following types of tokens.
Keywords, Identifiers, Literals, Punctuators, Operators.
1. Keywords
These are some reserved words in C++ which have predefined meaning to compiler called
keywords. Some commonly used Keyword are given below:
asm auto break case catch
char class const continue default
delete do double else enum
extern inline int float for
friend goto if long new
operator private protected public register
return short signed sizeof static
struct switch template this Try
typedef union unsigned virtual void
volatile while

2. Identifiers
Symbolic names can be used in C++ for various data items used by a programmer in his
program. A symbolic name is generally known as an identifier. The identifier is a sequence of
characters taken from C++ character set. The rule for the formation of an identifier are:
 An identifier can consist of alphabets, digits and/or underscores.
 It must not start with a digit
 C++ is case sensitive that is upper case and lower case letters are considered different from each
other.
 It should not be a reserved word.
3. Literals
Literals (often referred to as constants) are data items that never change their value during the
execution of the program. The following types of literals are available in C++.
 Integer-Constants
 Character-constants
 Floating-constants
 Strings-constants
Integer Constants
Integer constants are whole number without any fractional part. C++ allows three types of
integer constants.
Decimal integer constants : It consists of sequence of digits and should not begin with 0 (zero).
For example 124, - 179, +108.
Octal integer constants: It consists of sequence of digits starting with 0 (zero). For example.
014, 012.
Hexadecimal integer constant: It consists of sequence of digits preceded by ox or OX.
Character constants
A character constant in C++ must contain one or more characters and must be enclosed in single
quotation marks. For example 'A', '9', etc. C++ allows nongraphic characters which cannot be
typed directly from keyboard, e.g., backspace, tab, carriage return etc. These characters can be
represented by using an escape sequence. An escape sequence represents a single character. The
following table gives a listing of common escape sequences.
Escape Sequence Nongraphic Character
\a Bell (beep)
\n Newline
\r Carriage Return
\t Horizontal tab
\0 Null Character
Floating constants
They are also called real constants. They are numbers having fractional parts. They may be
written in fractional form or exponent form. A real constant in fractional form consists of signed
or unsigned digits including a decimal point between digits. For example 3.0, -17.0, -0.627 etc.
String Literals
A sequence of character enclosed within double quotes is called a string literal. String literal is
by default (automatically) added with a special character ‘\0' which denotes the end of the string.
Therefore the size of the string is increased by one character. For example "COMPUTER" will re
represented as "COMPUTER\0" in the memory and its size is 9 characters.
4. Punctuators/Seprators
The following characters are used as punctuators in C++.
Opening and closing brackets indicate single and
Brackets [ ]
multidimensional array subscript.
Opening and closing brackets indicate functions calls,; function
Parentheses ( )
parameters for grouping expressions etc.
Opening and closing braces indicate the start and end of a
Braces { }
compound statement.
Comma , It is used as a separator in a function argument list.
Semicolon ; It is used as a statement terminator.
Colon : It indicates a labeled statement or conditional operator symbol.
Asterisk * It is used in pointer declaration or as multiplication operator.
Equal sign = It is used as an assignment operator.
 Pound sign # It is used as pre-processor directive.

5. Operators
Operators are special symbols used for specific purposes. C++ provides six types of operators.
Arithmetical operators, Relational operators, Logical operators, Unary operators, Assignment
operators, Conditional operators, Comma operator
Operators are special symbols used for specific purposes. C++ provides six types of operators.
Arithmetical operators, Relational operators, Logical operators, Unary operators, Assignment
operators, Conditional operators, Comma operator
Arithmetical operators
Arithmetical operators +, -, *, /, and % are used to performs an arithmetic (numeric) operation.
You can use the operators +, -, *, and / with both integral and floating-point data types. Modulus
or remainder % operator is used only with the integral data type.
Operators that have two operands are called binary operators.
Relational operators
The relational operators are used to test the relation between two values. All relational operators
are binary operators and therefore require two operands. A relational expression returns zero
when the relation is false and a non-zero when it is true. The following table shows the relational
operators.
Relational Operators Meaning
< Less than
<= Less than or equal to
== Equal to
> Greater than
>= Greater than or equal to
!= Not equal to
Logical operators
The logical operators are used to combine one or more relational expression. The logical
operators are
Operators Meaning
|| OR
&& AND
! NOT
Unary operators
C++ provides two unary operators for which only one variable is required.
For Example
a = - 50;
a = + 50;
Here plus sign (+) and minus sign (-) are unary because they are not used between two variables.

Assignment operator
The assignment operator '=' is used for assigning a variable to a value. This operator takes the
expression on its right-hand-side and places it into the variable on its left-hand-side. For
example:
m = 5;
The operator takes the expression on the right, 5, and stores it in the variable on the left, m.
x = y = z = 32;
This code stores the value 32 in each of the three variables x, y, and z.
in addition to standard assignment operator shown above, C++ also support compound
assignment operators.
Compound Assignment Operators
Operator Example Equivalent to
+= A+=2 A=A+2
-= A-=2 A=A-2
%= A%=2 A=A%2
/= A/ = 2 A=A/2
*= A*=2 A=A*2
Increment and Decrement Operators
C++ provides two special operators viz '++' and '--' for incrementing and decrementing the value
of a variable by 1. The increment/decrement operator can be used with any type of variable but it
cannot be used with any constant. Increment and decrement operators each have two forms, pre
and post.
The syntax of the increment operator is:
Pre-increment: ++variable
Post-increment: variable++
The syntax of the decrement operator is:
Pre-decrement: ––variable
Post-decrement: variable––
In Prefix form first variable is first incremented/decremented, then evaluated
In Postfix form first variable is first evaluated, then incremented/decremented
int x,y;
int i=10,j=10;
x = ++i; //add one to i, store the result back in x
y= j++; //store the value of j to y then add one to j
cout<<x; //11
cout<<y; //10
Conditional operator
The conditional operator ?: is called ternary operator as it requires three operands. The format of
the conditional operator is:
Conditional_ expression ? expression1 : expression2;
If the value of conditional expression is true then the expression1 is evaluated, otherwise
expression2 is evaluated.
int a = 5, b = 6;
big = (a > b) ? a : b;
The condition evaluates to false, therefore biggets the value from b and it becomes 6.

The comma operator

The comma operator gives left to right evaluation of expressions. When the set of expressions
has to be evaluated for a value, only the rightmost expression is considered.
int a=1, b=2, c=3, i; // comma acts as separator, not as an operator
i = (a, b); // stores b into i
Would first assign the value of a to i, and then assign value of b to variable i. So, at the end,
variable i would contain the value 2.
The sizeof operator
As we know that different types of Variables, constant, etc. require different amounts of memory
to store them The sizeof operator can be used to find how many bytes are required for an object
to store in memory. For example
sizeof (char) returns 1
sizeof (int) returns 2
sizeof (float) returns 4
If k is integer variable, the sizeof (k) returns 2.
the sizeof operator determines the amount of memory required for an object at compile time
rather than at run time.
The order of Precedence
The order in which the Arithmetic operators (+,-,*,/,%) are used in a. given expression is called
the order of precedence. The following table shows the order of precedence.
Order Operators
First ()
Second *, /, %
Third +, -

The following table shows the precedence of operators.

++, --(post increment/decrement)
Highest
++ (Pre increment) -- (Pre decrement), sizeof ( ), !(not), -(unary), + To
(unary)
Lowest
*,/, %
+, -
<, <=, >, >=
==,!=
&&
?:
=
Comma operator
Basic Data Types
C++ supports a large number of data types. The built in or basic data types supported by C++ are
integer, floating point and character. These are summarized in table along with description and
memory requirement
Type Byte Range Description
int 2 -32768 to +32767 Small whole number
long int 4 -2147483648 to +2147483647 Large whole number
float 4 3.4x10-38 to 3.4x10+38 Small real number
double 8 1.7x10-308 to 1.7x10+308 Large real number
long double 10 3.4x10-4932 to 3.4x10+4932 Very Large real number
char 1 0 to 255 A Single Character

Variables
It is a location in the computer memory which can store data and is given a symbolic name for
easy reference. The variables can be used to hold different values at different times during the
execution of a program.
To understand more clearly we should study the following statements:
Total = 20.00;
In this statement a value 20.00 has been stored in a memory location Total.
Declaration of a variable
Before a variable is used in a program, we must declare it. This activity enables the compiler to
make available the appropriate type of location in the memory.
float Total;
You can declare more than one variable of same type in a single single statement
int x,y;
Initialization of variable
When we declare a variable it's default value is undetermined. We can declare a variable with
some initial value.
int a = 20;
Input/Output (I/O)
C++ supports input/output statements which can be used to feed new data into the computer or
obtain output on an output device such as: VDU, printer etc. The following C++ stream objects
can be used for the input/output purpose.
cin console input
cout console output
cout is used in conjuction with << operator, known as insertion or put to operator.
cin is used in conjuction with >> operator, known as extraction or get from operator.
cout << “My first computer";
Once the above statement is carried out by the computer, the message "My first computer" will
appear on the screen.
cin can be used to input a value entered by the user from the keyboard. However, the get from
operator>> is also required to get the typed value from cin and store it in the memory location.
Let us consider the following program segment:
int marks;
 cin >> marks;
In the above segment, the user has defined a variable marks of integer type in the first statement
and in the second statement he is trying to read a value from the keyboard.

Constants
A number which does not change its value during execution of a program is known as a constant.
Any attempt to change the value of a constant will result in an error message. A constant in C++
can be of any of the basic data types, const qualifier can be used to declare constant as shown
below:
const float pi = 3.1415;
The above declaration means that Pi is a constant of float types having a value 3.1415.
Examples of valid constant declarations are:
const int rate = 50;
const float pi = 3.1415;
const char ch = 'A';

Conditional Statements
Sometimes the program needs to be executed depending upon a particular condition. C++
provides the following statements for implementing the selection control structure.
 if statement
 if else statement
 nested if statement
 switch statement
if statement
syntax of the if statement
if (condition)
{
statement(s);
}
From the flowchart it is clear that if the if condition is true, statement is executed; otherwise it is
skipped. The statement may either be a single or compound statement.
if else statement
syntax of the if - else statement
if (condition)
statement1;
else
statement2;
From the above flowchart it is clear that the given condition is evaluated first. If the condition is
true, statement1 is executed. If the condition is false, statement2 is executed. It should be kept in
mind that statement and statement2 can be single or compound statement.
if example if else example
if (x == 100) if (x == 100)
cout << "x is 100"; cout << "x is 100";
else
cout << "x is not 100";
Nested if statement
The if block may be nested in another if or else block. This is called nesting of if or else block.
syntax of the nested if statement
if(condition 1)
{
if(condition 2)
{
statement(s);
}
}
if(condition 1)
statement 1;
else if (condition 2)
statement2;
else
statement3;

if-else-if example
if(percentage>=60)
cout<<"Ist division";
else if(percentage>=50)
cout<<"IInd division";
else if(percentage>=40)
cout<<"IIIrd division";
else
cout<<"Fail" ;

switch statement
The if and if-else statements permit two way branching whereas switch statement permits
multiple branching. The syntax of switch statement is:
 switch (var / expression)
{
case constant1 : statement 1;
break;
case constant2 : statement2;
break;
.
.
default: statement3;
break;
}
The execution of switch statement begins with the evaluation of expression. If the value of
expression matches with the constant then the statements following this statement execute
sequentially till it executes break. The break statement transfers control to the end of the switch
statement. If the value of expression does not match with any constant, the statement with default
is executed.
Some important points about switch statement
 The expression of switch statement must be of type integer or character type.
 The default case need not to be used at last case. It can be placed at any place.
 The case values need not to be in specific order.

Flow of Control

Looping statement
It is also called a Repetitive control structure. Sometimes we require a set of statements to be
executed a number of times by changing the value of one or more variables each time to obtain a
different result. This type of program execution is called looping. C++ provides the following
construct
 while loop
 do-while loop
 for loop

While loop
Syntax of while loop
while(condition)
{
statement(s);
}
The flow diagram indicates that a condition is first evaluated. If the condition is true, the loop
body is executed and the condition is re-evaluated. Hence, the loop body is executed repeatedly
as long as the condition remains true. As soon as the condition becomes false, it comes out of the
loop and goes to the statement next to the ‘while’ loop.
 do-while loop
Syntax of do-while loop
do
{
statements;
} while (condition);
Note : That the loop body is always executed at least once. One important difference between
the while loop and the do-while loop the relative ordering of the conditional test and loop body
execution. In the while loop, the loop repetition test is performed before each execution the loop
body; the loop body is not executed at all if the initial test fail. In the do-while loop, the loop
termination test is Performed after each execution of the loop body. hence, the loop body is
always executed least once.

for loop
It is a count controlled loop in the sense that the program knows in advance how many times the
loop is to be executed.
syntax of for loop
for (initialization; decision; increment/decrement)
{
statement(s);
}
The flow diagram indicates that in for loop three operations take place:
 Initialization of loop control variable
 Testing of loop control variable
 Update the loop control variable either by incrementing or decrementing.
Operation (i) is used to initialize the value. On the other hand, operation (ii) is used to test
whether the condition is true or false. If the condition is true, the program executes the body of
the loop and then the value of loop control variable is updated. Again it checks the condition and
so on. If the condition is false, it gets out of the loop.

Jump Statements
The jump statements unconditionally transfer program control within a function.
 goto statement
 break statement
 continue statement
The goto statement
goto allows to make jump to another point in the program.
goto pqr;
pqr: pqr is known as label. It is a user defined identifier. After the execution of goto statement,
the control transfers to the line after label pqr.
The break statement
The break statement, when executed in a switch structure, provides an immediate
exit from the switch structure. Similarly, you can use the break statement in
any of the loop. When the break statement executes in a loop, it immediately exits from the loop.
The continue statement
The continue statement is used in loops and causes a program to skip the rest of the body of the
loop.
while (condition)
{
Statement 1;
If (condition)
continue;
statement;
}
The continue statement skips rest of the loop body and starts a new iteration.
The exit ( ) function
The execution of a program can be stopped at any point with exit ( ) and a status code can be
informed to the calling program. The general format is
exit (code) ;
where code is an integer value. The code has a value 0 for correct execution. The value of the
code varies depending upon the operating system.

Function
A function is a subprogram that acts on data and often returns a value. A program written with
numerous functions is easier to maintain, update and debug than one very long program. By
programming in a modular (functional) fashion, several programmers can work independently on
separate functions which can be assembled at a later date to create the entire project. Each
function has its own name. When that name is encountered in a program, the execution of the
program branches to the body of that function. When the function is finished, execution returns
to the area of the program code from which it was called, and the program continues on to the
next line of code.
Creating User-Defined Functions
Declare the function.
The declaration, called the FUNCTION PROTOTYPE, informs the compiler about the
functions to be used in a program, the argument they take and the type of value they return.
Define the function.
The function definition tells the compiler what task the function will be performing. The function
prototype and the function definition must be same on the return type, the name, and the
parameters. The only difference between the function prototype and the function header is a
semicolon.
The function definition consists of the function header and its body. The header is EXACTLY
like the function prototype, EXCEPT that it contains NO terminating semicolon.
//Prototyping, defining and calling a function
#include <iostream.h>
void starline(); // prototype the function
int main()
{
starline( ); // function call
cout<< "\t\tBjarne Stroustrup\n";
starline( ); // function call
return 0;
}

// function definition
void starline()
{
int count; // declaring a LOCAL variable
for(count = 1; count <=65; count++)
cout<< "*";
cout<<endl;
}

Argument To A Function
Sometimes the calling function supplies some values to the called function. These are known as
parameters. The variables which supply the values to a calling function called actual
parameters. The variable which receive the value from called statement are termed formal
parameters.
Consider the following example that evaluates the area of a circle.
#include<iostream.h>
void area(float);
int main()
{
 float radius;
cin>>radius;
area(radius);
return 0;
}
void area(float r)
{
cout<< “the area of the circle is”<<3.14*r*r<<”\n”;
}
Here radius is called actual parameter and r is called formal parameter.
Return Type Of A Function
// Example program
#include <iostream.h>

int timesTwo(int num); // function prototype

int main()
{
int number, response;
cout<<"Please enter a number:";
cin>>number;
response = timesTwo(number); //function call
cout<< "The answer is "<<response;
return 0;
}
//timesTwo function
int timesTwo (int num)
{
int answer; //local variable
answer = 2 * num;
return (answer);
}
Calling Of A Function
the function can be called using either of the following methods:
i) call by value
ii) call by reference
Call By Value
In call by value method, the called function creates its own copies of original values sent to it.
Any changes, that are made, occur on the function’s copy of values and are not reflected back to
the calling function.

Call By Reference
In call be reference method, the called function accesses and works with the original values using
their references. Any changes, that occur, take place on the original values are reflected back to
the calling code.
Consider the following program which will swap the value of two variables.
using call by reference using call by value
#include<iostream.h> #include<iostream.h>
void swap(int &, int &); void swap(int , int );
int main() int main()
 { {
int a=10,b=20; int a=10,b=20;
swap(a,b); swap(a,b);
cout<<a<<" "<<b; cout<<a<<" "<< b;
return 0; return 0;
} }
void swap(int &c, int &d) void swap(int c, int d)
{ {
int t; int t;
t=c; t=c;
c=d; c=d;
d=t; d=t;
} }
output: output:
20 10 10 20
Function With Default Arguments
C++ allows to call a function without specifying all its arguments. In such cases, the function
assigns a default value to a parameter which does not have a mathching arguments in the
function call. Default values are specified when the function is declared. The complier knows
from the prototype how many arguments a function uses for calling.
Example :
float result(int marks1, int marks2, int marks3=75);
a subsequent function call
average = result(60,70);
passes the value 60 to marks1, 70 to marks2 and lets the function use default value of 75 for
marks3.
The function call
average = result(60,70,80);
passes the value 80 to marks3.
Inline Function
Functions save memory space because all the calls to the function cause the same code to be
executed. The functions body need not be duplicated in memory. When the complier sees a
function call, it normally jumps to the function. At the end of the function. it normally jumps
back to the statement following the call.
While the sequence of events may save memory space, it takes some extra time. To save
execution time in short functions, inline function is used. Each time there is a function call, the
actual code from the function is inserted instead of a jump to the function. The inline function is
used only for shorter code.
inline int cube(int r)
{
return r*r*r;
}
Some important points to be noted
 Function is made inline by putting a word inline in the beginning.
 Inline function should be declared before main() function.
 It does not have function prototype.
 Only shorter code is used in inline function If longer code is made inline then compiler ignores
the request and it will be executed as normal function.
Global Variable And Local Variable
Local Variable : a variable declared within the body of a function will be evaluated only within
the function. The portion of the program in which a variable is retained in memory is known as
the scope of the variable. The scope of the local variable is a function where it is defined. A
variable may be local to function or compound statement.
Global Variable : a variable that is declared outside any function is known as a global variable.
The scope of such a variable extends till the end of the program. these variables are available to
all functions which follow their declaration. So it should be defined at the beginning, before any
function is defined.
Array
An array is a collection of data elements of same data type. It is described by a single name and
each element of an array is referenced by using array name and its subscript no.
Declaration of Array
Type arrayName[numberOfElements];
For example,
int Age[5] ;
float cost[30];

Initialization of One Dimensional Array

An array can be initialized along with declaration. For array initialization it is required to place
the elements separated by commas enclosed within braces.
int A[5] = {11,2,23,4,15};
It is possible to leave the array size open. The compiler will count the array size.
int B[] = {6,7,8,9,15,12};
Referring to Array Elements
In any point of a program in which an array is visible, we can access the value of any of its
elements individually as if it was a normal variable, thus being able to both read and modify its
value. The format is as simple as:
name[index]

Examples:
cout<<age[4]; //print an array element
age[4]=55; // assign value to an array element
cin>>age[4]; //input element 4
Using Loop to input an Array from user
int age [10], i ;
for (i=0 ; i<10; i++)
{
 cin>>age[i];
}
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.
For example, the following function:
void print(int A[])
accepts a parameter of type "array of int" called A.
In order to pass to this function an array declared as:
int arr[20];
we need to write a call like this:
print(arr);
Here is a complete example:
#include <iostream.h>
void print(int A[], int length)
{
for (int n=0; n<length; n++)
cout << A[n] << " ";
cout << "\n";
}
int main ()
{
int arr[] = {5, 10, 15};
print(arr,3);
return 0;
}
Basic Operation On One Dimensional Array
Function to traverse the array A
void display(int A[], int n)
{
cout<<"The elements of the array are:\n";
for(int i=0;i<n;i++)
cout<<A[i];
}
Function to Read elements of the array A
void Input(int A[], int n)
{
cout<<"Enter the elements:";
for(int i=0;i<n;i++)
cin>>A[i];
}
Function to Search for an element from A by Linear Search
int Lsearch(int A[], int n, int Data)
{
int I;
for(I=0; I<n; I++)
{
if(A[I]==Data)
{
cout<<"Data Found at : "<<I;
return;
 }
}
cout<<"Data Not Found in the array"<<endl;
}
Function to Search for an element from Array A by Binary Search
int BsearchAsc(int A[], int n, int data)
{
int Mid,Lbound=0,Ubound=n-1,Found=0;
while((Lbound<=Ubound) && !(Found))
{
Mid=(Lbound+Ubound)/2; //Searching The Item
if(data>A[Mid])
Lbound=Mid+1;
else if(data<A[Mid])
Ubound=Mid-1;
else
Found++;
}
if(Found)
return(Mid+1); //returning 1ocation, if present
else
return(-1); //returning -1,if not present
}
Function to Sort the array A by Bubble Sort
void BSort(int A[], int n)
{
int I,J,Temp;
for(I=0;I<n-1;I++) //sorting
{
for(J=0;J<(n-1-I);J++)
if(A[J]>A[J+1])
{
Temp=A[J]; //swapping
A[J]=A[J+1];
A[J+1]=Temp;
}
}
}
Function to Sort the array ARR by Insertion Sort
void ISort(int A[], int n)
{
int I,J,Temp;
for(I=1;I<n;I++) //sorting
{
Temp=A[I];
J=I-1;
while((Temp<A[J]) && (J>=0))
{
A[J+1]=A[J];
J--;
}
A[J+1]=Temp;
}
}
Function to Sort the array by Selection Sort
void SSort(int A[], int n)
{
int I,J,Temp,Small;
for(I=0;I<n-1;I++)
{
Small=I;
for(J=I+1;J<n;J++) //finding the smallest element
if(A[J]<A[Small])
Small=J;
if(Small!=I)
{
Temp=A[I]; //Swapping
A[I]=A[Small];
A[Small]=Temp;
}
}
}
Function to merge A and B arrays of lenghts N and M
void Merge(int A[], int B[], int C[], int N, int M, int &K)
{
int I=0, J=0;
K=0; //Initialisation of counters for A, B, and C
while (I<N && J<M)
{
if (A[I]<B[J])
C[K++]=A[I++];
else if (A[I]>B[J])
C[K++]=B[J++];
else
{
C[K++]=A[I++];
J++;
}
}
for (int T=I;T<N;T++)
C[K++]=A[T];
for (T=J;T<M;T++)
C[K++]=B[T];
}

C-Strings (Character Arrays)

STRING: It is an array of type char.
Syntax for declaration
char <array/string name> [max. number of characters to be stored +1];
The number of elements that can be stored in a string is always n-1, if the size of the array
specified is n. This is because 1 byte is reserved for the NULL character '\0' i.e. backslash zero.
A string is always terminated with the NULL character.
Example:
char str[80];
In the above example, str can be used to store a string with 79 characters.
Initializing a string
A string can be initialized to a constant value when it is declared.
char str[ ] = "Good";
Or
char str[]={'G','o','o','d','\0'};
Here. 'G' will be stored in str[0], 'o' in str[1] and so on.
Note: When the value is assigned to the complete string at once, the computer automatically
inserts the NULL character at the end of the string. But, if it is done character by character, then
we have to insert it at the end of the string.
Reading strings with/without embedded blanks
To read a string without blanks cin can be used
cin>>str;
To read a string with blanks cin.getline() or gets() can be used.
cin.getline(str,80);
-Or-
gets(str);
Printing strings
cout and puts() can be used to print a string.
cout<<str:
Or
puts(str);
Note: For gets( ) and puts(), the header file stdio.h has to be included. puts() can be used to
display only strings. It takes a line feed after printing the string.
cin gets()
It can be used to take input of a value of It can be used to take input of a string.
any data type.
It takes the white space i.e. a blank, a It does not take the white space i.e. a
tab, or a new line character as a string blank, a tab, or a new line character, as a
terminator. string terminator.
It requires header file iostream.h It requires the header file stdio.h
Example: Example:
char S[80]; char S[80];
cout<<"Enter a string:”; cout<<"Enter a string:";
cin>>S; gets(S);

cout puts()
It can be used to display the value of any It can be used to display the value of a
data type. string.
It does not take a line feed after It takes a line feed after displaying the
displaying the string. string.
It requires the header file iostream.h It requires the header file stdio.h
 Example: Example:
char S[80]="Computers"; char S[80]="Computers";
cout<<S<<S; puts(S);
puts(S);
Output:
ComputersComputers Output:
Computers
Computers
Counting the number of characters in a string and printing it backwards
#include<iostream.h>
#include<stdio.h>
int main( )
{
char str[80];
cout<<"Enter a string:";
gets(str);
for(int l=0; str[l]!='\0';l++); //Loop to find length
cout<<"The length of the string is : "<<l<<endl ;
for(int i=l-1;i>=0;i--) //Loop to display the string backwards
cout<<str[i];
return 0;
}
Function to count the number of words in a string
void count(char S[])
{
int words=0;
for(int i=0;S[i]!='\0';i++)
{
if (S[i]==' ')
words++; //Checking for spaces
}
cout<<"The number of words="<<words+1<<endl;
}
Function to find the length of a string
int length(char S[ ])
{
for(int i=0;S[i]!='\0';i++);
return i;
}
Function to copy the contents of string S2 to S1
void copy(char S1[ ], char S2[ ])
{
for(int i=0;S2[i]!='\0';i++)
S1[i]=S2[i];
S1[i]='\0';
}
Function to concatenate the contents of string S2 to S1
void concat(char S1[ ], char S2[ ])
{
for(int l=0;S1[l]!='\0';l++);
for(int i=0;S2[i]!='\0';i++)
S1[l++]=S2[i];
 S1[l]='\0';
}
Function to compare strings STR1 to STR2.
The function returns a value>0 if //STR1>STR2, a value<0 if STR1<STR2, and value 0 if
STR1=STR2
int compare(char STR1[ ],char STR2[])
{
for(int I=0;STR1[I]==STR2[I] && STR1[I]!='\0'&&STR2[I]!='\0'; I++);
return STR1[I]-STR2[I];
}
To reverse the contents of string S and store it in string Rev
void Reverse(char S[], char Rev[])
{
for(int C1=0; S[C1]!='\0'; C1++);
C1--;
for(int C2=0;C1>=0;C2++,C1--)
Rev[C2]=S[C1];
Rev[C2]='\0';
}
Function to check whether a string S is a palindrome or not
int Palin(char S[])
{
for(int L=0;S[L]!='\0';L++); //To find length
for(int C=0;(C<L/2) && (S[C]==S[L-C-1]);C++);
return (C==L/2)?1:0; //Returns 1 if Palindrome else 0
}
Function to change the case of string S to uppercase
void Upper(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='a' && S[i]<='z')?(S[i]-32):S[i];
}
Function to change the case of string S to lower case
void Lower(char S[])
{
for(int i=0;S[i]!='\0';i++)
S[i] = (S[i]>='A' && S[i]<='Z')?(S[i]+32):S[i];
}
Function to extract n characters from left side of the string and store it in a different string.
Example: 4 characters from ENVIRONMENT=ENVI
int SLeft(char S[ ], int n, char result[ ])
{
for(int l=0;S[l]!='\0';l++);
if(n<=I) //characters extracted should be <=length
{
for(int i=0;i<n;i++)
result[i]=S[i];
result[i]='\0';
return 1;
}
else
return 0;
}
Function to extract n characters from right side of the string and store it in a different string.
Example: 4 characters from ENVIRONMENT=MENT
int SRight(char S[ ], int n, char result[ ])
{
for(int l=0;S[l]!='\0';l++);
if(n<=I) //characters extracted should be <=length
{
for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
result[j]=S[i];
result[j]='\0';
return 1;
}
else
return 0;
}
Function to extract n characters from specified location loc of the string and store it in a
different string.
Example: 4 characters from third location in string ENVIRONMENT= VIRO
int substring(char S[ ], int n, int loc, char result[ ])
{
for(int l=0;S[l]!='\0';l++);
if(n<=I) //characters extracted should be <=length
{
for(int j=0;i=l-n;S[i]!=’/0’;i++,j++)
result[j]=S[i];
result[j]='\0';
return 1;
}
else
return 0;
}

Two Dimensional Array

It is a collection of data elements of same data type arranged in rows and columns (that is, in two
dimensions).
Declaration of Two-Dimensional Array
Type arrayName[numberOfRows][numberOfColumn];
For example,
int Sales[3][5];

Initialization of Two-Dimensional Array

An two-dimensional array can be initialized along with declaration. For two-dimensional array
initialization, elements of each row are enclosed within curly braces and separated
by commas. All rows are enclosed within curly braces.
int A[4][3] = {{22, 23, 10},
{15, 25, 13},
{20, 74, 67},
{11, 18, 14}};
Referring to Array Elements
To access the elements of a two-dimensional array, we need a pair of indices: one for
the row position and one for the column position. The format is as simple as:
name[rowIndex][columnIndex]

Examples:
cout<<A[1][2]; //print an array element
A[1][2]=13; // assign value to an array element
cin>>A[1][2]; //input element
Using Loop to input an Two-Dimensional Array from user
int mat[3][5], row, col ;
for (row = 0; row < 3; row++)
for (col = 0; col < 5; col++)
cin >> mat[row][col];
Arrays as Parameters
Two-dimensional arrays can be passed as parameters to a function, and they are passed by
reference. When declaring a two-dimensional array as a formal parameter, we can omit the size
of the first dimension, but not the second; that is, we must specify the number of columns. For
example:
void print(int A[][3],int N, int M)
In order to pass to this function an array declared as:
int arr[4][3];
we need to write a call like this:
print(arr);
Here is a complete example:
#include <iostream.h>
void print(int A[][3],int N, int M)
{
for (R = 0; R < N; R++)
for (C = 0; C < M; C++)
cout << A[R][C];
}
int main ()
{
int arr[4][3] ={{12, 29, 11},
{25, 25, 13},
{24, 64, 67},
{11, 18, 14}};
print(arr,4,3);
return 0;
}
Function to read the array A
void Read(int A[][20], int N, int M)
{
for(int R=0;R<N;R++)
for(int C=0;C<M;C++)
{
cout<<"(R<<','<<")?";
cin>>A[R][C];
}
}
Function to display content of a two dimensional array A
void Display(int A[][20],int N, int M)
{
for(int R=0;R<N;R++)
{
for(int C=0;C<M;C++)
cout<<setw(10)<<A[R][C];
cout<<endl;
}
}
Function to find the sum of two dimensional arrays A and B
void Addition(int A[][20], int B[][20],int N, int M)
{
for(int R=0;R<N;R++)
for(int C=0;C<M;C++)
C[R][C]=A[R][C]+B[R][C];
}
Function to multiply two dimensional arrays A and B of order NxL and LxM
void Multiply(int A[][20], int B[][20], int C[][20],int N, int L, int M)
{
for(int R=0;R<N;R++)
for(int C=0;C<M;C++)
{
C[R][C]=0;
for(int T=0;T<L;T++)
C[R][C]+=A[R][T]*B[T][C];
}
}
Function to find & display sum of rows & sum of cols. of a 2 dim. array A
void SumRowCol(int A[][20], int N, int M)
{
 for(int R=0;R<N;R++)
{
int SumR=0;
for(int C=0;C<M;C++)
SumR+=A[R][C];
cout<<"Row("<<R<<")="<<SumR<<endl;
}
for(int R=0;R<N;R++)
{
int SumR=0;
for(int C=0;C<M;C++)
SumR+=A[R][C];
cout<<"Row("<<R<<")="<<SumR<<endl;
}
}
Function to find sum of diagonal elements of a square matrix A
void Diagonal(int A[][20], int N, int &Rdiag, int &LDiag)
{
for(int I=0,Rdiag=0;I<N;I++)
Rdiag+=A[I][I];
for(int I=0,Ldiag=0;I<N;I++)
Ldiag+=A[N-I-1][I];
}
Function to find out transpose of a two dimensional array A
void Transpose(int A[][20], int B[][20],int N, int M)
{
for(int R=0;R<N;R++)
for(int C=0;C<M;C++)
B[R][C]=A[C][R];
}

3rd unit
OOP Concepts
Paradigm-: It means organizing principle of a program. It is an approach to programming.
Procedural Paradigm
In procedural programming paradigm, the emphasis is on doing things i.e., the procedure or the
algorithm. The data takes the back seat in procedural programming paradigm. Also, this
paradigm does not model real world well.
Object Oriented programming
The object oriented programming paradigm models the real world well and overcomes the
shortcomings of procedural paradigm. It views a problem in terms of objects and thus
emphasizes on both procedures as well as data.
The following are the basic concepts used in object-oriented programming.
Object-: An object is an identifiable entity with some characteristics and behavior.
Class-: A class represents a group of objects that share common properties, behavior and
relationships.
Data Abstraction-: Abstraction refers to act of representing essential features without including
the background details or explanations.
Encapsulation-: The wrapping up of data and associated functions into a single unit is known as
Encapsulation. Encapsulation implements data abstraction.
Modularity-: Modularity is the property of a system that has been decomposed into a set of
cohesive and loosely coupled modules.
Inheritance-: It is the capability of one class of things to inherit capabilities or properties from
another class.
Base and sub classes-: The class whose properties are inherited is called base class (or
superclass) and the class that inherits the properties is known as derived class(or subclass).
Derived Class :- The class, which inherits from other classes is called derived class or Subclass.
Polymorphism-: It is the ability for a message or data to be processed in more than one form.
Polymorphism is a property by which the same message can be sent to objects of several
different classes. Polymorphism is implemented in C++ through virtual functions and
overloading- function overloading and operator overloading.
Advantages of Object oriented programming.
Software complexity can be easily managed
Object-oriented systems can be easily upgraded
It is quite easy to partition the work in a project based on object
class enforce data-hiding, abstraction & encapsulation
A class groups its members into three sections : private, protected, and public. The private and
protected members remain hidden from outside world. Thus through private and protected
members, a class enforces data-hiding.
The outside world is given only the essential and necessary information through public members,
rest of the things remain hidden, which is nothing but abstraction. Abstraction means
representation of essential features without including the background details and explanation.

Class & Objects

The mechanism that allows you to combine data and the function in a single unit is called a class.
Once a class is defined, you can declare variables of that type. A class variable is called object or
instance. In other words, a class would be the data type, and an object would be the variable.
Classes are generally declared using the keyword class, with the following format:
class class_name
{
private:
members1;
protected:
members2;
public:
members3;
};
Where class_name is a valid identifier for the class. The body of the declaration can contain
members, that can be either data or function declarations, The members of a class are classified
into three categories: private, public, and protected. Private, protected, and public are reserved
words and are called member access specifiers. These specifiers modify the access rights that the
members following them acquire.
private members of a class are accessible only from within other members of the same class.
You cannot access it outside of the class.
protected members are accessible from members of their same class and also from members of
their derived classes.
Finally, public members are accessible from anywhere where the object is visible.
By default, all members of a class declared with the class keyword have private access for all its
members. Therefore, any member that is declared before one other class specifier automatically
has private access.
Here is a complete example :
class student
{
private :
int rollno;
float marks;
public:
void getdata()
{
cout<<"Enter Roll Number : ";
cin>>rollno;
cout<<"Enter Marks : ";
cin>>marks;
}
void displaydata()
{
cout<<"Roll number : "<<rollno<<"\nMarks : "<<marks;
}
};

Object Declaration
Once a class is defined, you can declare objects of that type. The syntax for declaring a object is
the same as that for declaring any other variable. The following statements declare two objects of
type student:
student st1, st2;
Accessing Class Members
Once an object of a class is declared, it can access the public members of the class.
st1.getdata();
Defining Member function of class
You can define Functions inside the class as shown in above example. Member functions defined
inside a class this way are created as inline functions by default. It is also possible to declare a
function within a class but define it elsewhere. Functions defined outside the class are not
normally inline.
When we define a function outside the class we cannot reference them (directly) outside
of the class. In order to reference these, we use the scope resolution operator, ::
(double colon). In this example, we are defining function getdata outside the class:
void student :: getdata()
{
cout<<"Enter Roll Number : ";
cin>>rollno;
cout<<"Enter Marks : ";
cin>>marks;
}
The following program demostrates the general feature of classes. Member function initdata() is
defined inside the class. Member funcitons getdata() and showdata() defined outside the class.
class student //specify a class
{
private :
int rollno; //class data members
float marks;
public:
void initdata(int r, int m)
{
rollno=r;
marks=m;
}
void getdata(); //member function to get data from user
void showdata();// member function to show data
};

void student :: getdata()

{
cout<<"Enter Roll Number : ";
cin>>rollno;
cout<<"Enter Marks : ";
cin>>marks;
}

void student :: showdata()

{
cout<<"Roll number : "<<rollno<<"\nMarks : "<<marks;
}

int main()
{
student st1, st2; //define two objects of class student
st1.initdata(5,78); //call member function to initialize
st1.showdata();
 st2.getdata(); //call member function to input data
st2.showdata(); //call member function to display data
return 0;
}
Constructor and Destructor
Constructor
It is a member function having same name as it’s class and which is used to initialize the objects
of that class type with a legel initial value. Constructor is automatically called when object is
created.
Types of Constructor
Default Constructor-: A constructor that accepts no parameters is known as default constructor.
If no constructor is defined then the compiler supplies a default constructor.
student :: student()
{
rollno=0;
marks=0.0;
}
Parameterized Constructor -: A constructor that receives arguments/parameters, is called
parameterized constructor.

student :: student(int r)
{
rollno=r;
}
Copy Constructor-: A constructor that initializes an object using values of another object
passed to it as parameter, is called copy constructor. It creates the copy of the passed object.

student :: student(student &t)

{
rollno = t.rollno;
}
There can be multiple constructors of the same class, provided they have different signatures.
Destructor
A destructor is a member function having sane name as that of its class preceded by ~(tilde) sign
and which is used to destroy the objects that have been created by a constructor. It gets invoked
when an object’s scope is over.

~student() { }
Example : In the following program constructors, destructor and other member functions are
defined inside class definitions. Since we are using multiple constructor in class so this example
also illustrates the concept of constructor overloading
#include<iostream.h>

class student //specify a class

{
private :
 int rollno; //class data members
float marks;
public:
student() //default constructor
{
rollno=0;
marks=0.0;
}
student(int r, int m) //parameterized constructor
{
rollno=r;
marks=m;
}
student(student &t) //copy constructor
{
rollno=t.rollno;
marks=t.marks;
}
void getdata() //member function to get data from user
{
cout<<"Enter Roll Number : ";
cin>>rollno;
cout<<"Enter Marks : ";
cin>>marks;
}
void showdata() // member function to show data
{
cout<<"\nRoll number: "<<rollno<<"\nMarks: "<<marks;
}
~student() //destructor
{}
};

int main()
{
student st1; //defalut constructor invoked
student st2(5,78); //parmeterized constructor invoked
student st3(st2); //copy constructor invoked
st1.showdata(); //display data members of object st1
st2.showdata(); //display data members of object st2
st3.showdata(); //display data members of object st3
return 0;
}
Inheritance
Inheritance:It is the capability of one class to inherit properties from another class.
Base Class: It is the class whose properties are inherited by another class. It is also called Super
Class.
Derived Class:It is the class that inherit properties from base class(es).It is also called Sub Class.
Forms Of Inheritance
Single Inheritance: It is the inheritance hierarchy wherein one derived class inherits from one
base class.
Multiple Inheritance:It is the inheritance hierarchy wherein one derived class inherits from
multiple base class(es)
Hierarchical Inheritance: It is the inheritance hierarchy wherein multiple subclasses inherits
from one base class.
Multilevel Inheritance: It is the inheritance hierarchy wherein subclass acts as a base class for
other classes.
Hybrid Inheritance:The inheritance hierarchy that reflects any legal combination of other four
types of inheritance.

Visibility Mode:It is the keyword that controls the visibility and availability of inherited base
class members in the derived class.It can be either private or protected or public.
Private Inheritance:It is the inheritance facilitated by private visibility mode.In private
inheritance ,the protected and public members of base class become private members of the
derived class.
Public Inheritance:It is the inheritance facilitated by public visibility mode.In public inheritance
,the protected members of base class become protected members of the derived class and public
members of the base class become public members of derived class.;
Protected Inheritance:It is the inheritance facilitated by protected visibility mode.In protected
inheritance ,the protected and public members of base class become protected members of the
derived class.
Derived class visibility
Base Class
Public Private Protected
Visibility
derivation derivation derivation
Private Not inherited Not inherited Not inherited
Protected Protected Private Protected
Public Public Private Protected

Containership:When a class contains objects of other class types as its members, it is called
containership.It is also called containment,composition, aggregation.
Execution of base class constructor
 Method of inheritace Order of execution
class B : public A { }; A(); base constructor
B(); derived constructor
class A : public B, public C B();base (first)
C();base (second)
A();derived constructor
When both derived and base class contains constructors, the base constructor is executed first
and then the constructor in the derived class is executed. In case of multiple inheritances, the
base classes are constructed in the order in which they appear in the declaration of the derived
class.
Overriding of method(function) in inheritance
We may face a problem in multiple inheritance, when a function with the same name appears in
more than one base class. Compiler shows ambiguous error when derived class inherited by
these classes uses this function.
We can solve this problem, by defining a named instance within the derived class, using the class
resolution operator with the function as below :
class P : public M, public N //multiple inheritance
{
public :
void display() //overrides display() of M and N
{
M::display()
}
};
we can now used the derived class as follows :
void main()
{
P obj;
obj.display();
}
Virtual Base Class
Multipath inheritance may lead to duplication of inherited members from a grandparent base
class. This may be avoided by making the common base class a virtual base class. When a class
is made a virtual base class, C++ takes necessary care to see that only one copy of that class is
inherited.
class A
{
....
....
};
class B1 : virtual public A
{
....
....
};
class B2 : virtual public A
{
....
....
};
class C : public B1, public B2
{
.... // only one copy of A
.... // will be inherited
};