Oops Complete Notes

lOMoARcPSD|51362898
Oops complete Notes
object oriented programming using C++ (Chaudhary Charan Singh University)
Scan to open on Studocu
Studocu is not sponsored or endorsed by any college or university

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)
lOMoARcPSD|51362898
Object Oriented Programming

UNIT – 1
Procedure/ structure oriented Programming

• Conventional programming, using high level languages such as COBOL, FORTRAN and C, is
commonly known as procedure-oriented programming (POP).
• In the procedure-oriented approach, the problem is viewed as a sequence of things to be done such as
reading, calculating and printing. A number of functions are written to accomplish these tasks.
• The primary focus is on functions.
Object Oriented Programming

• Emphasis is on data rather than procedure.
• Programs are divided into what are known as objects.
• Data is hidden and cannot be accessed by external functions.
• Objects may communicate with each other through functions.
• New data and functions can be easily added whenever necessary.
Basic Concepts of Object-Oriented Programming

Objects
Objects are the basic runtime entities in an object oriented system. They may represent a person, a
place, a bank account, a table of data or any item that the program has to handle.
Class
Object contains data, and code to manipulate that data. The entire set of data and code of an object can
be made a user-defined data type with the help of a class.
Data Encapsulation
The wrapping up of data and functions into a single unit is known as encapsulation.

lOMoARcPSD|51362898
The data is not accessible to the outside world, only those function which are wrapped in the can access
it.
These functions provide the interface between the object’s data and the program.
This insulation of the data from direct access by the program is called data hiding or information
hiding.
Data Abstraction
Abstraction refers to the act of representing essential features without including the background details
or explanations.
Since classes use the concept of data abstraction, they are known as Abstract Data Types (ADT).
Inheritance
Inheritance is the process by which objects of one class acquire the properties of objects of another
class.
In OOP, the concept of inheritance provides the idea of reusability. This means we can add additional
features to an existing class without modifying it.
Polymorphism
Polymorphism, a Greek term means to ability to take more than one form.
An operation may exhibits different behaviors in different instances. The behavior depends upon the
type of data used in the operation.
For example consider the operation of addition for two numbers; the operation will generate a sum. If
the operands are string then the operation would produce a third string by concatenation.
The process of making an operator to exhibit different behavior in different instances is known
operator overloading.
Similarities between C and C++ are:

 Both the languages have a similar syntax.
 Code structure of both the languages are same.
 The compilation of both the languages is similar.
 They share the same basic syntax. Nearly all of C’s operators and keywords are also present in
C++ and do the same thing.
 C++ has a slightly extended grammar than C, but the basic grammer is the same.
 Basic memory model of both is very close to the hardware.
 Same notions of stack, heap, file-scope and static variables are present in both the languages.
Differences between C and C++ are:

lOMoARcPSD|51362898
C C++
C was developed by Dennis Ritchie between the C++ was developed by Bjarne Stroustrup in
year 1969 and 1973 at AT&T Bell Labs. 1979.
C does no support polymorphism, encapsulation, C++ supports polymorphism, encapsulation,
and inheritance which means that C does not and inheritance because it is an object oriented
support object oriented programming. programming language.
C is a subset of C++. C++ is a superset of C.
C contains 32 keywords. C++ contains 52 keywords.
For the development of code, C C++ is known as hybrid language because C++
supports procedural programming. supports both procedural and object oriented
programming paradigms.
Data and functions are separated in C because it is Data and functions are encapsulated together in
a procedural programming language. form of an object in C++.
C does not support information hiding. Data is hidden by the Encapsulation to ensure
that data structures and operators are used as
intended.
Built-in data types is supported in C. Built-in & user-defined data types is supported
in C++.
C is a function driven language because C is a C++ is an object driven language because it is
procedural programming language. an object oriented programming.
Function and operator overloading is not Function and operator overloading is supported
supported in C. by C++.
C is a function-driven language. C++ is an object-driven language
Functions in C are not defined inside structures. Functions can be used inside a structure in C++.
Namespace features are not present inside the C. Namespace is used by C++, which avoid name
collisions.
Header file used by C is stdio.h. Header file used by C++ is iostream.h.
Reference variables are not supported by C. Reference variables are supported by C++.
Virtual and friend functions are not supported by Virtual and friend functions are supported by
C. C++.
C does not support inheritance. C++ supports inheritance.
Instead of focusing on data, C focuses on method C++ focuses on data instead of focusing on
or process. method or procedure.
C provides malloc() and calloc() functions C++ provides new operator for memory
for dynamic memory allocation, and free() for allocation and delete operator for memory de-
memory de-allocation. allocation.
Direct support for exception handling is not Exception handling is supported by C++.
supported by C.
scanf() and printf() functions are used for cin and cout are used for input/output in C++.
input/output in C.
Output and Input Statement in C++ : Cin and cout

An Output statement is used to print the output on computer screen. cout is an output statement.
cout<<”Srinix College of Engineering”; prints Srinix College of Engineering on computer screen.
cout<<”x”; print x on computer screen.
cout<<x; prints value of x on computer screen.
cout<<”\n”; takes the cursor to a newline.
cout<< endl; takes the cursor to a newline. We can use endl (a manipulator) instead of \n.

lOMoARcPSD|51362898
<< (two "less than" signs) is called insertion operator.

An Input statement is used to take input from the keyboard. cin is an input statement.
cin>>x; takes the value of x from keyboard.
cin>>x>>y; takes value of x and y from the keyboard.
WAP to accept an integer from the keyboard and print the number when it is
multiplied by 2.
Solution:
#include <iostream.h>
void main ()
{
int x;
cout << "Please enter an integer value: ";
cin >>x;
cout <<endl<< "Value you entered is " <<x;
cout << " and its double is " <<x*2 << ".\n";
}
Output:
Please enter an integer value:
5
Value you entered is 5 and its double is 10.
New and Delete operators
There are two ways to allocate memory:
(i) Static memory allocation
(ii) Dynamic memory allocation
(i) Static memory allocation
To allocate memory at the time of program compilation is known as static memory allocation.
i.e. int a[10];
it allocates 20 bytes at the time of compilation of the program. Its main disadvantage is wastage or
shortage of memory space can takes place.
(ii) Dynamic memory allocation
To allocate memory at the time of program execution is known as dynamic memory allocation. C++
provides two dynamic allocation operators: new and delete. These operators are used to allocate and
free memory at run time. Dynamic allocation is an important part of almost all real-world programs.
These are included for the sake of compatibility with C. However, for C++ code, you should use the
new and delete operators because they have several advantages. The new operator allocates memory
and returns a pointer to the start of it. The delete operator frees memory previously allocated using new.
The general forms of new and delete are shown here:
p_var = new type;
delete p_var;
Here, p_var is a pointer variable that receives a pointer to memory that is large enough to hold an item
of type type.

lOMoARcPSD|51362898
Memory Allocation to an integer.

Solution:
void main()
{
int *p;
try
{
p = new int;
}
catch (bad_alloc xa)
{
cout << "Allocation Failure\n";
return 1;
}
*p = 100;
cout << "At " << p << " ";
cout << "is the value " << *p << "\n";
delete p;
}
This program assigns to p an address in the heap that is large enough to hold an integer. It then assigns
that memory the value 100 and displays the contents of the memory on the screen. Finally, it frees the
dynamically allocated memory. Remember, if your compiler implements new such that it returns null
on failure, you must change the preceding program appropriately.The delete operator must be used
only with a valid pointer previously allocated by using new. Using any other type of pointer with delete
is undefined and will almost certainly cause serious problems, such as a system crash.
Comparison between new, delete and malloc(), free
Although new and delete perform functions similar to malloc() and free(), they have several
advantages. First, new automatically allocates enough memory to hold an object of the specified type.
You do not need to use the sizeof operator. Because the size is computed automatically, it eliminates
any possibility for error in this regard. Second, new automatically returns a pointer of the specified
type. You don't need to use an explicit type cast as you do when allocating memory by using malloc().
Finally, both new and delete can be overloaded, allowing you to create customized allocation systems.
Although there is no formal rule that states this, it is best not to mix new and delete with malloc() and
free() in the same program. There is no guarantee that they are mutually compatible.
The Placement Forms of new and delete

There is a special form of new, called the placement form, that can be used to specify an alternative
method of allocating memory. It is primarily useful when overloading the new operator for special
circumstances. There is a default implementation of the placement new operator, which has this general
form:
p_var = new (location) type;
Here, location specifies an address that is simply returned by new. There is also a placement form of
delete, which is used to free memory allocated by the placement form of new.

lOMoARcPSD|51362898
UNIT – 2
Encapsulation and Data Hiding
Encapsulation Definition:
Encapsulation is a process of capsulation of data and methods into a combined single unit. In C++,
encapsulation is used along with the classes concept.
Bundling of data and methods (functions) as a single unit is known as encapsulation.
Encapsulation represents the information of variables (attributes) in terms of data and, methods
(functions) and its operations in terms of purpose.
 Encapsulation is the process of combining data and function into a single unit called class.
 Encapsulation is a powerful feature that leads to information hiding and abstract data type.
 They encapsulate all the essential properties of the object that are to be created.
 Using the method of encapsulation the programmer cannot access the class directly.
Data Hiding Definition:

Data hiding is a technique especially practised in object-oriented programming (OOP).Data hiding is
hiding the details of internal data members of an object.
 Data hiding is also known as Information hiding.
 Sometimes Data Hiding includes Encapsulation. Thus Data Hiding is heavily related to
Abstraction and Encapsulation.
 Data Hiding is the one most important OOP mechanism. Which is hide the details of the class
from outside of the class.
 The Class used by only a limited set of variables and functions, others are hidden by the class.
Access Specifiers in C++

lOMoARcPSD|51362898
Access specifiers define how a member's variables and member's functions of a class can be accessed
from outside the class. However, all members of a class can be accessed from within the class without
any restriction.
Class members can be declared as public, protected or private access specifiers, which is used to build
the encapsulation capabilities of the class.
There are three access specifiers: Private, Public, Protected
 Private members: These can be accessed only from within the members of the same class.
 Protected members: These can be accessed only from within other members of the same class
and its derived classes.
 Public members: These can be accessed from anywhere where the object is accessible.
By declaring the member variables and functions as a private in a class, the members are hidden from
outside the class.Those private members and data cannot be accessed by the object directly.
Encapsulation Example:
class Square {
private:
int Num;
public:
void Get() {
cout << "Enter Number:";
cin>>Num;
}
void Display() {
cout << "Square Is:" << Num*Num;
}
};
void main() {
Square Obj;
Obj.Get();
Obj.Display();
getch()
}
In the above example, the variable “Num” is private. Hence this variable can be accessed only by the
members of the same class and is not accessible anywhere else. Hence outside the classes will be
unable to access this variable Which is called data hiding.
At the same time, “Square” class contains two other methods namely “Get” and “Display” which has
public members. Here “Get” method just prints the value while “Display” method prints the square of
the value in the variable “Num”. Here the class “Square” implements Data Encapsulation concept by
capsulation of the value in the variable “Num” and thus allowing the user only to perform a restricted
set of operations on the hidden variable “Num”.
Features and Advantages of Data Encapsulation:

Encapsulation is used to reduce the complexity and improve reusability.
Encapsulation defines the interface clearly which improves the readability and understandability.
Encapsulation helps to hide important data and ensures enhanced Security.
The member variables and members are bundled into a single unit as a class which makes the
maintenance easy.

lOMoARcPSD|51362898
The encapsulated classes are straightforward and are easy to manage and improve the future
development of the application.
Class and Object
A class is a way to bind the data and its associated functions together. It allows the data and functions to
be hidden, if necessary, from external use. A class declaration is similar syntactically to a structure.
 The variables declared inside the class definition are known as data members and the functions
declared inside a class are known as member functions.
 Wrapping of data and function and function into a single unit (i.e. class) is known as data
encapsulation.
 By default the data members and member function of a class are private.
 Private data members can be accessed by the functions that are wrapped inside the class.
General form of a class declaration is:

class class_name
{
private:
Variable declaration/data members; Private members can be accessed only from
Function declaration/ member functions; within
protected: the class.
Variable declaration/data members;
Function declaration/ member functions; Protected members can be accessed by own class
public: and its derived classes.
Variable declaration/data members;
Function declaration/ member functions; Public members can be accessed from outside the
}; class also.
Steps to write a C++ program using class and object:

1. Header files
2. Class definition
3. Member function definition
4. void main function
Write a program to find sum of two integers using class and object.
Solution:
#include<iostream.h>
class Add
{
int x, y, z;
public:
void getdata()
{
cout<<”Enter two numbers”;
cin>>x>>y;
}
void calculate(void);
void display(void);
};

lOMoARcPSD|51362898
void Add :: calculate()

{
z=x+y;
}
void Add :: display()
{
cout<<z;
}
void main()
{
Add a;
a.getdata();
a.calculate();
a.display();
}
Output:
Enter two numbers 5 5
10
A member function can be defined:

(i) Inside the class definition
(ii) Outside side the class definition using scope resolution operator (::).
 Here in the above example we are defining the member function getdata() inside the class
definition. And we are defining the member functions calculate() and display(), outside the class
definition using the scope resolution operator.
 Here void Add :: calculate() means the scpoe of member function calculate() is inside the class
Add or we can say the function calculate() belongs to the class Add. :: is the scope resolution
operator which tells the scope of a member function.
 We cannot directly call a function, we can call it using object (through . operator) of the class in
which the function is declared.
How to access member of a class?

To access member of a class dot operator is used. i.e.
object-name.data-member and
object-name.member-function
Application of Scope resolution operator (::)

_ It is used to specify scope of a member function.
_ It is used to access a global variable.
Object as Function argument

Write a program to add two time objects (in the form hh:mm).
Solution:
class time
{
int hours, minutes;

lOMoARcPSD|51362898
public:
void gettime(int h, int m)
{
hours=h;
minutes=m;
}
void sum(time, time);
void display(void);
};
void time :: sum (time t1, time t2)
{
minutes=t1.minutes+t2.minutes;
hours=minutes/60;
minutes=minutes%60;
hours=hours+t1.hours+t2.hours;
}
void time :: display()
{
cout<<hours<<” : ”<<minutes<<endl;
}
void main()
{
time T1, T2, T3;
T1.gettime(2,45);
T2.gettime(3,30);
T3.sum(T1, T2);
T1.display();
T2.display();
cout<<"Addition of above two time is ";
T3.display();
}
Output:
2 : 45
3 : 15
Addition of above two time is 6:15
Array of object
Collection of similar types of object is known as array of objects.
Write a program to input name and age of 5 employees and display them.
Solution:
class Employee
{
char name[30];
int age;
public:
void getdata(void);
void putdata(void);
};

lOMoARcPSD|51362898
void Employee:: getdata(void)

{
cout<<”Enter Name and Age:”;
cin>>name>>age;
}
void Employee:: putdata(void)
{
cout<<name<<”\t”<<age<<endl;
}
void main()
{
Employee e[5];
int i;
for(i=0; i<5; i++)
{
e[i].getdata();
}
for(i=0; i<5; i++)
{
e[i].putdata();
}
}
Output:
Enter Name and Age: Rajib 25
Enter Name and Age: Sunil 27
Enter Name and Age: Ram 23
Enter Name and Age: Bibhuti 26
Enter Name and Age: Ramani 32
Rajib 25
Sunil 27
Ram 23
Bibhuti 26
Ramani 32
Constructor
 A constructor is a special member function whose task is to initialize the object of a class.
 Its name is same as the class name.
 A constructor does not have a return type.
 A constructor is called or invoked when the object of its associated class is created.
 It is called constructor because it constructs the values of data members of the class.
 A constructor cannot be virtual (shall be discussed later on).
 A constructor can be overloaded.
There three types of constructor:

(i) Default Constructor
(ii) Parameterized Constructor
(iii) Copy constructor
Default Constructor

lOMoARcPSD|51362898
The constructor which has no arguments is known as default constructor.
Demonstration of default Constructor.

Solution:
class Add
{
int x, y, z;
public:
Add(); // Default Constructor
void display(void);
};
Add::Add()
{
x=6;
y=5;
}
{
z=x+y;
}
{
cout<<z;
}
void main()
{
Add a;
a.calculate();
a.display();
}
Output:
11
Note: Here in the above program when the statement Add a; will execute (i.e. object is created), the
default constructor Add () will be called automatically and value of x and y will be set to 6 and 5
respectively.
Parameterized constructor
The constructor which takes some argument is known as parameterized constructor.
Write a program to initialize two integer variables using parameterized constructor and add
them.
Solution:
class Add
{

lOMoARcPSD|51362898
int x, y, z;
public:
Add(int, int);
void display(void);
};
Add :: Add(int a, int b)
{
x=a;
y=b;
}
{
z=x+y;
}
{
cout<<z;
}
void main()
{
Add a(5, 6);
a.calculate();
a.display();
}
Output:
11
Note: Here in the above program when the statement Add a(5, 6); will be executed (i.e. object creation),
the parameterized constructor Add (int, int) will be called automatically and value of x and y will be set
to 5 and 6respectively.
A parameterized constructor can be called:

(i) Implicitly: Add a(5, 6);
(ii) Explicitly :Add a=Add(5, 6);
If the constructor has one argument, then we can also use object-name=value-of-argument; instead of
object-name (value-of-argument); to initialize an object.
What is Dynamic Initialization of an object?

The initialization of an object at the time of execution of program is known as dynamic initialization of
an object. It is achieved by parameterized constructor.
Copy Constructor
The constructor which takes reference to its own class as argument is known as copy constructor.
Write a program to initialize two integer variables using parameterized

constructor. Copy given integers into a new object and add them.
Solution:

lOMoARcPSD|51362898
class Add
{
int x, y, z;
public:
Add()
{
}
Add(int a, int b)
{
x=a;
y=b;
}
Add(Add &);
void display(void);
};
Add :: Add(Add &p)
{
x=p.x;
y=p.y;
cout<<”Value of x and y for new object: ”<<x<<” and ”<<y<<endl;
}
{
z=x+y;
}
{
cout<<z;
}
void main()
{
Add a(5, 6);
Add b(a);
b.calculate();
b.display();
}
Output:
Value of x and y for new object are 5 and 6
11
Note: Here in the above program when the statement Add a(5, 6); will execute (i.e. object creation), the
parameterized constructor Add (int, int) will be called automatically and value of x and y will be set to
5 and 6respectively. Now when the statement Add b(a) ; will execute, the copy constructor Add(Add&)
will be called and the content of object a will be copied into object b.
What is Constructor Overloading?

lOMoARcPSD|51362898
If a program contains more than one constructor, then constructor is said to be overloaded.
Destructor
 It is a special member function which is executed automatically when an object is destroyed.
 Its name is same as class name but it should be preceded by the symbol ~.
 It cannot be overloaded as it takes no argument.
 It is used to delete the memory space occupied by an object.
 It has no return type.
 It should be declared in the public section of the class.
Demonstration of Destructor.
Solution:
class XYZ
{
int x;
public:
XYZ( );
~XYZ( );
void display(void);
};
XYZ::XYZ( )
{
x=9;
}
XYZ:: ~XYZ( )
{
cout<<”Object is destroyed”<<endl;
}
void XYZ::display()
{
cout<<x;
}
void main()
{
XYZ xyz;
xyz.display();
}
Output:
9
Object is destroyed
Inline function
In C++, we can create short functions that are not actually called, rather their code is expanded in line
at the point of each invocation. This process is similar to using a function-like macro. To cause a
function to be expanded in line rather than called, precede its definition with the inline keyword.
 A function which is expanded in a line when it is called is called inline function.
 It executes faster than other member function.

lOMoARcPSD|51362898
 It can be recursive.
 Its body does not contain if else, switch, loop, goto statement.
 The inline keyword is preceded by function definition.
Why inline function is used?

Whenever a function is called, control jumps to definition part of the function. During this jumping of
control, a significant amount of time is required. For functions having short definition if it is called
several time, huge amount of time will be lost. Therefore we declare such function as inline so that
when the function is called, rather than jumping to the definition of function, function definition is
expanded in a line wherever it is called.
Write a program to find area of a circle using inline function.

Solution:
inline float area(int);
void main()
{
int r;
cout<<“ Enter the Value of r: ”;
cin>>r;
cout<<” Area is: “ << area(r);
}
inline float area (int a)
{
return(3.14*a*a);
}
Output:
Enter the Value of r:
7
153.86
Friend Function
 Scope of a friend function is not inside the class in which it is declared.
 Since its scope is not inside the class, it cannot be called using the object of that class
 It can be called like a normal function without using any object.
 It cannot directly access the data members like other member function and it can access the data
members by using object through dot operator.
 It can be declared either in private or public part of the class definition.
 Usually it has the objects as arguments.
Demonstration of Friend Function.

Solution:
class Add
{
int x, y, z;
public:
Add(int, int);

lOMoARcPSD|51362898
friend int calculate(Add p);

};
Add :: Add(int a, int b)
{
x=a;
y=b;
}
int calculate(Add p)
{
return(p.x+p.y);
}
void main()
{
Add a(5, 5);
cout<<calculate(a);
}
Output:
10
Note: Here the function calculate () is called directly like normal function as it is declared as friend.
Friend Classes
It is possible for one class to be a friend of another class. When this is the case, the friend class and all
of its member functions have access to the private members defined within the other class.
class TwoValues
{
int a;
int b;
public:
TwoValues(int i, int j)
{
a = i;
b = j;
}
friend class Min;
};
class Min
{
public:
int min(TwoValues x);
};
int Min::min(TwoValues x)
{
return x.a < x.b ? x.a : x.b;
}
int main()

lOMoARcPSD|51362898
{
TwoValues ob(10, 20);
Min m;
cout << m.min(ob);
return 0;
}
Output:
10
Note: In this example, class Min has access to the private variables a and b declared within the
TwoValues class.
Static Data Members

 The data member of a class preceded by the keyword static is known as static member.
 When we precede a member variable's declaration with static, we are telling the compiler that only
one copy of that variable will exist and that all objects of the class will share that variable. Hence
static variables are called class variables.
 Unlike regular data members, individual copies of a static member variable are not made for each
object. No matter how many objects of a class are created, only one copy of a static data member
exists. Thus, all objects of that class use that same variable.
 All static variables are initialized to zero before the first object is created.
 Normal data members are called object variable but static data members are called class variables.
Demonstration of static data members.

Solution:
class A
{
int p;
static int q;
public:
A();
void incr(void);
void display(void);
};
A :: A()
{
p=5;
}
int A:: q=10;
void A:: incr()
{
p++;
q++;
}
void A:: display()
{

lOMoARcPSD|51362898
cout<<p<<”\t”<<q<<endl;
}
void main()
{
A a1, a2, a3;
a1.incr();
a1.display();
a2.incr();
a2.display();
a3.incr();
a3.display();
}
Output:
6 11
6 12
6 13
Note: Here p is a normal variable, whose value is 5 for all 3 objects a1, a2 and a3 (For each object,
separate copy of p exists). But q is static variable or member, whose initial value is 10 and a single copy
of q exists for all the objects.
Static Member function/method

 A static function can have access to only other static members (functions or variables) declared in
the same class. (Of course, global functions and data may be accessed by static member functions.)
 It is accessed by class name and not by object’s name i.e. class-name::function-name;
 The function name is preceded by the keyword static.
 A static member function does not have this pointer.
 There cannot be a static and a non-static version of the same function.
 A static member function may not be virtual.
 Finally, they cannot be declared as const or volatile.
Demonstration of static member function.

Solution:
class ABC
{
public:
static int add(int, int);
};
int ABC:: add(int a, int b)
{
return(a+b);
}
void main()
{
ABC abc;
int res;

lOMoARcPSD|51362898
res=ABC :: add(30, 40);

cout<<res;
}
Output:
70
C++ Garbage Collection

Garbage collection is a memory management technique. It is a separate automatic memory
management method which is used in programming languages where manual memory management is
not preferred or done. In the manual memory management method, the user is required to mention the
memory which is in use and which can be deallocated, whereas the garbage collector collects the
memory which is occupied by variables or objects which are no more in use in the program. Only
memory will be managed by garbage collectors, other resources such as destructors, user interaction
window or files will not be handled by the garbage collector.
Few languages need garbage collectors as part of the language for good efficiency. These languages are
called as garbage-collected languages. For example, Java, C# and most of the scripting languages needs
garbage collection as part of their functioning. Whereas languages such as C and C++ support manual
memory management which works similar to the garbage collector. There are few languages that
support both garbage collection and manually managed memory allocation/deallocation and in such
cases, a separate heap of memory will be allocated to the garbage collector and manual memory.
Some of the bugs can be prevented when the garbage collection method is used. Such as:
 dangling pointer problem in which the memory pointed is already deallocated whereas the pointer
still remains and points to different reassigned data or already deleted memory
 the problem which occurs when we try to delete or deallocate a memory second time which has
already been deleted or reallocated to some other object
 removes problems or bugs associated with data structures and does the memory and data handling
efficiently
 memory leaks or memory exhaustion problem can be avoided
Advantages and Disadvantages of Garbage Collector

One major disadvantage of garbage collection is the time involved or CPU cycles involved to find the
unused memory and deleting it, even if the user knows which pointer memory can be released and not
in use. Another disadvantage is, we will not know the time when it is deleted nor when the destructor is
called.

lOMoARcPSD|51362898
UNIT – 3
Inheritance
It is the process by which object of one class acquires the properties of object of another class. The
class from which properties are inherited is called base class and the class to which properties are
inherited is called derived class. Inheritance can be broadly classified into:
 Single Inheritance
 Multiple Inheritance
 Multilevel Inheritance
 Hierarchical Inheritance
 Hybrid Inheritance
Base-Class Access Control

When a class inherits another, the members of the base class become members of the derived class.
Class inheritance uses this general form:
class derived-class-name : access base-class-name
{
// body of class
};
The access status of the base-class members inside the derived class is determined by access. The base
class access specifier must be either public, private, or protected. If no access specifier is present, the
access specifier is private by default if the derived class is a class. If the derived class is a struct, then
public is the default in the absence of an explicit access specifier.
 When the access specifier for a base class is public, all public members of the base become public
members of the derived class, and all protected members of the base become protected members
of the derived class.
 When the base class is inherited by using the private access specifier, all public and protected
members of the base class become private members of the derived class.
 When a base class' access specifier is protected, public and protected members of the base
become protected members of the derived class.
In all cases, the base's private elements remain private to the base and are not accessible by members of
the derived class.
Single Inheritance

lOMoARcPSD|51362898
In a single inheritance the derived class is derived from a single base class.
(Single inheritance)
Example of single inheritance with base class access control as public.

Solution:
class A
{
int i, j;
public:
void set(int a, int b)
{
i=a; j=b;
}
void show()
{
cout << i << " " << j << "\n";
}
};
class B : public A
{
int k;
public:
B(int x)
{
k=x;
}
void showk()
{
cout << k << "\n";
}
};
void main()
{
B b(3);
b.set(1, 2);
b.show();
b.showk();
}
Output:
12
3

lOMoARcPSD|51362898
Note: Here all public and protected members of the base class become private members of the derived
class. So object of derived class cannot directly access the member function and data members of the
base class.
Example of single inheritance with base class access control as private.

Solution:
class A
{
int i, j;
public:
void set(int a, int b)
{
i=a; j=b;
}
void show()
{
cout << i << " " << j << "\n";
}
};
class B : private A
{
int k;
public:
B(int x)
{
k=x;
}
void showk()
{
cout << k << "\n";
}
};
void main()
{
B b(3);
b.set(1, 2);
b.show(); //******Error******
}
How to access the private data member of base class in derived class?
Private data members of base class can be accessed by derived class by using public member
function/methods of the base class.
Multiple Inheritance
In multiple inheritance derived class is derived from more than one base class.

lOMoARcPSD|51362898
(Multiple Inheritance)
Multilevel Inheritance
In multilevel inheritance class B is derived from a class A and a class C is derived from the class B.
Syntax:
class base-class-name1
{
Data members
Member functions
};
class derived-class-name : visibility mode base-class-name
{
Data members
Member functions
};
class derived-class-name1: visibility mode derived-class-name
{
Data members
Member functions
};
Note: visibility mode can be either private, public or protected
(Multilevel inheritance)
Hierarchical Inheritance
In hierarchical inheritance several classes can be derived from a single base class
Syntax:
class base-class-name
{
Data members
Member functions
};
class derived-class-name1 : visibility mode base-class-name
{

lOMoARcPSD|51362898
Data members
Member functions
};
class derived-class-name2: visibility mode base-class-name
{
Data members
Member functions
};
Note: visibility mode can be either private, public or protected
Hybrid inheritance
It is the mixture of one or more above inheritance.
Constructor and Destructor Execution in Inheritance

When an object of a derived class is created, if the base class contains a constructor, it will be called
first, followed by the derived class' constructor. When a derived object is destroyed, its destructor is
called first, followed by the base class' destructor, if it exists (i.e. constructor functions are executed in
their order of derivation. Destructor functions are executed in reverse order of derivation).
Constructor and Destructor execution in single inheritance.

Solution:
class base
{
public:
base()
{
cout << "Constructing base\n";
}
~base()
{
cout << "Destructing base\n";
}
};
class derived: public base

lOMoARcPSD|51362898
{
public:
derived()
{
cout << "Constructing derived\n";
}
~derived()
{
cout << "Destructing derived\n";
}
};
void main()
{
derived ob;
}
Output:
Constructing base
Constructing derived
Destructing derived
Destructing base
Note: In the above program, first base's constructor is executed followed by derived's. Next (because
ob is immediately destroyed in this program), derived's destructor is called, followed by base's.
Passing Parameters to Base-Class Constructors

So far, none of the preceding examples have included constructor functions that require arguments. In
cases where only the derived class' constructor requires one or more parameters, we simply use the
standard parameterized constructor syntax. However, how do you pass arguments to a constructor in a
base class? The answer is to use an expanded form of the derived class's constructor declaration that
passes along arguments to one or more base-class constructors. The general form of this expanded
derived-class constructor declaration is shown here:
derived-constructor (arg-list) : base1(arg-list),base2(arg-list), …...,baseN(arg-list)
{
// body of derived constructor
}
Here, base1 through baseN are the names of the base classes inherited by the derived class. Notice that
a colon separates the derived class' constructor declaration from the base-class specifications, and that
the base-class specifications are separated from each other by commas, in the case of multiple base
classes.
Virtual Base Classes

An element of ambiguity can be introduced into a C++ program when multiple base classes are
inherited.
What is Multipath Inheritance?

Multipath Inheritance is a hybrid inheritance (also called as Virtual Inheritance). It is combination of
hierarchical inheritance and multiple inheritance.

lOMoARcPSD|51362898
In Multipath Inheritance there is a one base class GRANDPARENT. Two derived class PARENT1 and
PARENT2 which are inherited from GRANDPARENT. Third Derived class CHILD which is inherited
from both PARENT1 and PARENT2.
Problem in Multipath Inheritance

There is an ambiguity problem. When we run program with such type inheritance, it gives a compile
time error [Ambiguity]. If we see the structure of Multipath Inheritance then we find that there is shape
like Diamond.
Why Ambiguity Problem in

multipath (Virtual) Inheritance?
Suppose GRANDPARENT has a data member int i. PARENT1 has a data member int j. Another
PARENT2 has a data member int k. CHILD class which is inherited from PARENT1 and PARENT2.
CHILD class have data member:
int j ( one copy of data member PARENT1)
int k ( one copy of data member PARENT2)
int i(two copy of data member GRANDPARENT)
This is ambiguity problem. In CHILD class have two copies of Base class. There are two duplicate
copies of int i of base class. One copy through PARENT1 and another copy from PARENT2. This
problem is also called as DIAMOND Problem.
Demonstration of ambiguities in multipath inheritance.

Solution:
// This program contains an error and will not compile.
class base
{
public:
int i;
};
class derived1 : public base
{
public:
int j;
};
class derived2 : public base
{
public:
int k;
};
class derived3 : public derived1, public derived2
{
public:

lOMoARcPSD|51362898
int sum;
};
void main()
{
derived3 ob;
ob.i = 10; // this is ambiguous, which i???
ob.j = 20;
ob.k = 30;
ob.sum = ob.i + ob.j + ob.k; // i ambiguous here, too
cout << ob.i << " "; // also ambiguous, which i?
cout << ob.j << " " << ob.k << " ";
cout << ob.sum;
}
As the comments in the program indicate, both derived1 and derived2 inherit base. However, derived3
inherits both derived1 and derived2. This means that there are two copies of base present in an object of
type derived3. Therefore, in an expression like ob.i = 10; which i is being referred to, the one in
derived1 or the one in derived2? Because there are two copies of base present in object ob, there are
two ob.is! As we can see, the statement is inherently ambiguous.
There are two ways to remedy the preceding program. The first is to apply the scope resolution
operator to i and manually select one i. The second is to use virtual base class.
Remove Ambiguities using virtual base class:

When two or more objects are derived from a common base class, we can prevent multiple copies of
the base class from being present in an object derived from those objects by declaring the base class as
virtual when it is inherited. We accomplish this by preceding the base class' name with the keyword
virtual when it is inherited. For example, here is another version of the example program in which
derived3 contains only one copy of base:
Remove Ambiguities using virtual base class.

Solution:
class base
{
public:
int i;
};
class derived1 : virtual public base
{
public:
int j;
};
class derived2 : virtual public base
{
public:
int k;
};
class derived3 : public derived1, public derived2
{

lOMoARcPSD|51362898
public:
int sum;
};
void main()
{
derived3 ob;
ob.i = 10; // now unambiguous
ob.j = 20;
ob.k = 30;
ob.sum = ob.i + ob.j + ob.k; // unambiguous
cout << ob.i << " "; // unambiguous
cout << ob.j << " " << ob.k << " ";
cout << ob.sum;
}
As we can see, the keyword virtual precedes the rest of the inherited class specification. Now that both
derived1 and derived2 have inherited base as virtual, any multiple inheritance involving them will
cause only one copy of base to be present. Therefore, in derived3, there is only one copy of base and
ob.i = 10 is perfectly valid and unambiguous.
Polymorphism and Virtual Functions

Polymorphism means one name, multiple forms.
For example, the + (plus) operator in C++ will behave different for different data types:
4 + 5 <-- integer addition
3.14 + 2.0 <-- floating point addition
“Good” + "Boy” <-- string concatenation
Polymorphism is of two types:

(i) Compile time(Static) polymorphism (static binding or static linking or early binding)
 In compile time polymorphism, all information needed to call a function is known during
program compilation.
 Example: Function overloading and operator overloading are used to achieve compile time
polymorphism
(ii) Runtime(Dynamic) polymorphism(late binding or dynamic binding)
 In runtime polymorphism all information needed to call a function is known during program
execution.
 Example: Virtual function is used to achieve runtime polymorphism.
Function Overloading
It is the process by which a single function can perform different task, depending upon no of
parameters and types of parameters.
Write a program to overload function area () to calculate area of circle and

area of a rectangle.
Solution:
float area(int);
int area(int, int);
void main( )
{

lOMoARcPSD|51362898
int r, l, b;
cout << “Enter the Value of r, l & b: ”;
cin>>r>>l>>b;
cout<< “Area of circle is ”<<area(r)<<endl;
cout<< “Area of rectangle is ”<<area(l,b);
}
float area(int a)
{
return (3.14*a*a);
}
int area(int a, int b)
{
return (a*b);
}
Output:
Enter the Value of r, l & b:
786
Area of circle is 153.86
Area of circle is 48
Ambiguity in Function Overloading

Suppose we have two functions:
void area(int,int);
void area(float,int);
void main()
{
area(10,10); // Unambiguous function call, calls area(int, int){ }
area(10.0,10); // Ambiguous function call, error!
}
Note: Here, the second area() function will not compile and will generate error ambiguity between
area(int,int) and area(float, int) . It's because 10.0 is treated as a double, not a float. Either of our
functions could accept a double, but our compiler doesn't know which one you want to use.
Following functions cannot be overloaded:

 void f(int x);
void f(int &x);
Above two functions cannot be overloaded when the only difference is that one takes a
reference parameter and the other takes a normal, call-by-value parameter.
 typedef int integer;

enum days{mon,tue,wed}
void f(int);
void f(mon);
Function Overriding using Virtual Function

lOMoARcPSD|51362898
When a base class and derived class contain same member function, then the base version of the
member function always works when we invoke that function using base pointer.
Demonstration of function overriding.

Solution:
class B
{
public:
void show()
{
cout<<"I am in base show"<<endl;
}
};
class D:public B
{
public:
void show()
{
cout<<"I am in derived show"<<endl;
}
};
void main()
{
B b, *bp;
D d;
bp=&b;
bp->show();
bp=&d;
bp->show();
}
Output:
I am in base show
I am in base show
Note: Here the base version of function show () will work as it overrides the derived version of show ().
A virtual function is a member function that is declared within a base class and redefined by a derived
class. To create a virtual function, precede the function's declaration in the base class with the keyword
virtual. When a class containing a virtual function is inherited, the derived class redefines the virtual
function to fit its own needs. In essence, virtual functions implement the "one interface, multiple
methods" philosophy that underlies polymorphism. The virtual function within the base class defines
the form of the interface to that function. Each redefinition of the virtual function by a derived class
implements its operation as it relates specifically to the derived class. That is, the redefinition creates a
specific method.
Write a program to demonstrate virtual function.

Solution:

lOMoARcPSD|51362898
class B
{
public:
virtual void show()
{
cout<<"I am in base show"<<endl;
}
};
class D:public B
{
public:
void show()
{
cout<<"I am in derived show"<<endl;
}
};
void main()
{
B b, *bp;
D d;
bp=&b;
bp->show();
bp=&d;
bp->show();
}
Output:
I am in base show
I am in derived show
A base pointer can be made to point to any number of derived objects, it cannot access the members
defined by a derived class. It can access only the members which are common to the base class. If a
same function is present in both base and derived class, always base version of the function is called
when we access the function using base pointer (no matters whether it points to base class or derived
class). Derived version of the function can be called by making the function (having same name) as
virtual. This is also called function overriding because function in the base class is overridden by the
function in the derived class.
When a virtual function is inherited, its virtual nature is also inherited. This means that when a derived
class that has inherited a virtual function is itself used as a base class for another derived class, the
virtual function can still be overridden.
Pure virtual function

A pure virtual function is a virtual function that has no definition within the base class. To declare a
pure virtual function, use this general form: virtual return-type function-name (parameter-list) = 0;
When a virtual function is made pure, any derived class must provide its own definition. If the derived
class fails to override the pure virtual function, a compile-time error will result. Hence definition for
pure virtual function must be there in the derived class.

lOMoARcPSD|51362898
Abstract Classes
A class that contains at least one pure virtual function is said to be abstract. Because an abstract class
contains one or more functions for which there is no definition (that is, a pure virtual function), no
objects of an abstract class may be created.
Instead, an abstract class constitutes an incomplete type that is used as a foundation for derived classes.
Although we cannot create objects of an abstract class, we can create pointers and references to an
abstract class. This allows abstract classes to support run-time polymorphism, which relies upon base-
class pointers and references to select the proper virtual function.
Create an abstract class called Shape which contains a pure virtual function called find_vol() and
a protected attribute named as volume. Create two new derived classes from the above class
named as Cube and Sphere having double type attribute named as side and radius respectively.
Implement dynamic polymorphism to find out volume of a cube and a sphere. Also display the
result.
Solution:
class Shape
{
protected:
double volume;
public:
virtual void find_vol()=0;
};
class Cube: public Shape
{
protected:
double side;
public:
Cube();
void find_vol();
};
class Sphere: public Shape
{
protected:
double radius;
public:
Sphere();
void find_vol();
};
Cube::Cube()
{
cout<<”Enter side of the Cube:”<<endl;
cin>>side;
}
Sphere::Sphere ()
{
cout<<”Enter radius of the sphere:”<<endl;
cin>>radius;
}

lOMoARcPSD|51362898
void Cube:: find_vol()

{
volume=side*side*side;
cout<<”Volume of Cube is: ”<<volume<<endl;
}
void Sphere:: find_vol()
{
volume=(4/3)*3.14*radius*radius*radius;
cout<<”Volume of sphere is: ”<<volume;
}
void main()
{
Shape *ptr;
Cube cube;
Sphere sphere;
ptr=&cube;
ptr->find_vol();
ptr=&sphere;
ptr->find_vol();
}
Output:
Enter side of the Cube:
3
Enter radius of the sphere:
4
Volume of Cube is: 27
Volume of sphere is: 200.96
Operator Overloading
 It is most striking feature of C++.
 In operator overloading an operator can be operated on user defined data types. i.e. + operator
perform addition of integers or real numbers. But we can overload this operator to compute sum
of two complex number.
 Only existing operators can be overloaded. New operators cannot be overloaded (i.e. $ cannot
be overloaded as it is not an operator.)
 It should obey the basic meaning of an operator i.e. + operator cannot be used to subtract two
numbers.
The operator overloading can be done by using:

(i) Member function
(ii) Friend function
this Pointer
Every object in C++ has access to its own address through an important pointer called this pointer. The
this pointer is an implicit parameter to all member functions. Therefore, inside a member function, this
may be used to refer to the invoking object.
Friend functions do not have a this pointer, because friends are not members of a class. Only non static
member functions have a this pointer.

lOMoARcPSD|51362898
Write a program to demonstrate this pointer.

Solution:
class Box
{
private:
double length;
double breadth;
double height;
public:
Box(double l=2.0, double b=2.0, double h=2.0)
{
cout <<"Constructor called." << endl;
length = l;
breadth = b;
height = h;
}
double Volume()
{
return (length * breadth * height);
}
int compare(Box box)
{
return (this->Volume() > box.Volume());
}
};
void main(void)
{
Box Box1(3.3, 1.2, 1.5);
Box Box2(8.5, 6.0, 2.0);
if(Box1.compare(Box2))
{
cout << "Box2 is smaller than Box1" <<endl;
}
else
{
cout << "Box2 is equal to or larger than Box1" <<endl;
}
}
Output:
Constructor called.
Constructor called.
Box2 is equal to or larger than Box1
Overloading Operators
A member operator function takes this general form:
return_type operator symbol(arg-list)

lOMoARcPSD|51362898
{
// operations
}
Often, operator functions return an object of the class they operate on, but return_type can be any valid
type(int, char, float, void etc). When you create an operator function, substitute the operator for the
symbol. For example, if you are overloading the / operator, use operator/. When you are overloading a
unary operator, arg-list will be empty. When you are overloading binary operators, arglist will contain
one parameter.
Operator Overloading Restrictions:

There are some restrictions that apply to operator overloading.
 We cannot alter the precedence of an operator.
 We cannot change the number of operands that an operator takes.
 Except for the function call, operator, operator functions cannot have default arguments.
 Finally, these operators cannot be overloaded: scope resolution operator (::), conditional
operator (:?), dot operator (.) and asterisk operator (*).
 Except for the = operator, operator functions are inherited by any derived class.
 However, a derived class is free to overload any operator (including those overloaded by the
base class) it chooses relative to itself.
Templates
 Using templates, it is possible to create generic functions and classes.
 In a generic function or class, the type of data upon which the function or class operates is
specified as a parameter.
 Thus, we can use one function or class with several different types of data without having to
explicitly recode specific versions for each data type.
Generic functions (Function Templates)

A generic function defines a general set of operations that will be applied to various types of data. The
type of data that the function will operate upon is passed to it as a parameter. Through a generic
function, a single general procedure can be applied to a wide range of data.
The general form of a template function definition is shown here:
template <class Ttype>
return-type func-name (Ttype a1, Ttype a2,……., Ttype n)
{
// body of function
}
Here, Ttype is a placeholder name for a data type used by the function.
Write a generic function swap to interchange any two variables (integer,

character, and float).
template <class T>
void swap(T p, T q)
{
T temp;
temp = p;
p = q;
q = temp;

lOMoARcPSD|51362898
cout<<p<<”\t”<<q;
}
void main()
{
int i=10, j=20;
float x=10.1, y=23.3;
char a='x', b='z';
swap (i, j); /*swaps integers*/
swap (x, y); /* swaps floats*/
swap (a, b); /*swaps chars*/
}
Output:
20 10
23.2 10.1
zx
Note: The line:

template <class T> void swap (T p, T q) tells the compiler two things: that a template is being created
and that a generic definition is beginning. Here, T is a generic type that is used as a placeholder. After
the template portion, the function swap () is declared, using T as the data type of the values that will be
swapped. In main () , the swap () function is called using three different types of data: ints, floats, and
chars. Because swap () is a generic function, the compiler automatically creates three versions of
swap(): one that will exchange integer values, one that will exchange floating-point values, and one that
will swap characters.
Generic Function Restrictions

Generic functions are similar to overloaded functions except that they are more restrictive. When
functions are overloaded, you may have different actions performed within the body of each function.
But a generic function must perform the same general action for all versions- only the type of data can
differ.
Overloading a Function Template

In addition to creating explicit, overloaded versions of a generic function, you can also overload the
template specification itself. To do so, simply create another version of the template that differs from
any others in its parameter list. For example:
Demonstration of function template overloading.

Solution:
// First version of f() template.
template <class X> void f(X a)
{
cout << "Inside f(X a)\n";
}
// Second version of f() template.
template <class X, class Y> void f(X a, Y b)
{
cout << "Inside f(X a, Y b)\n";
}

lOMoARcPSD|51362898
int main()
{
f(10); // calls f(X)
f(10, 20); // calls f(X, Y)
return 0;
}
Here, the template for f() is overloaded to accept either one or two parameters
Generic class (class templates)

In addition to generic functions, we can also define a generic class. When we do this, we create a class
that defines all the algorithms used by that class; however, the actual type of the data being manipulated
will be specified as a parameter when objects of that class are created.
Generic classes are useful when a class uses logic that can be generalized. For example, the same
algorithms that maintain a queue of integers will also work for a queue of characters, and the same
mechanism that maintains a linked list of mailing addresses will also maintain a linked list of auto part
information.
The general form of a generic class declaration is:

template <class T>
class class-name
{
--------------------
--------------------
};
General form of a member function definition of template class:
template <class T>
Ret_type class_name <T>:: function()
{
--------------------
--------------------
}
General form of object creation of a template class:

class_name <data_type> object1, object2,…….
Write a program to add two numbers (either two integers or floats) using
class templates.
Solution:
template <class T>
class Add
{
T a, b;
public:
void getdata();
void display();
};
template <class T>
void Add <T>::getdata( )

lOMoARcPSD|51362898
{
cout<<”Eneter 2 nos”;
cin>>a>>b;
}
template <class T>
void Add <T>::display( )
{
cout<<”sum=”<<a+b;
}
void main()
{
Add <int> ob1;
Add <float> ob2;
ob1.getdata( );
ob1.display( );
ob2.getdata( );
ob2.display( );
}
Output:
Eneter 2 nos 4 5
Sum=9
Eneter 2 nos 4.8 5.1
Sum=9.9
The Power of Templates

Templates help you achieve one of the most elusive goals in programming: the creation of reusable
code. Through the use of template classes you can create frameworks that can be applied over and over
again to a variety of programming situations.
Generic functions and classes provide a powerful tool that you can use to amplify your programming
efforts. Once you have written and debugged a template class, you have a solid software component
that you can use with confidence in a variety of different situations. You are saved from the tedium of
creating separate implementations for each data type with which you want the class to work. While it is
true that the template syntax can seem a bit intimidating at first, the rewards are well worth the time it
takes to become comfortable with it. Template functions and classes are already becoming
commonplace in programming, and this trend is expected to continue. For example, the STL (Standard
Template Library) defined by C++ is, as its name implies, built upon templates. One last point:
although templates add a layer of abstraction, they still ultimately compile down to the same, high-
performance object code that you have come to expect from C++.

lOMoARcPSD|51362898
UNIT – 4
C++ Standard Library

The C++ Standard Library can be categorized into two parts −
 The Standard Function Library − This library consists of general-purpose,stand-alone
functions that are not part of any class. The function library is inherited from C.
 The Object Oriented Class Library − This is a collection of classes and associated functions.
Standard C++ Library incorporates all the Standard C libraries also, with small additions and changes
to support type safety.
The Standard Function Library
The standard function library is divided into the following categories −
 I/O,
 String and character handling,
 Mathematical,
 Time, date, and localization,
 Dynamic allocation,
 Miscellaneous,
 Wide-character functions,
The Object Oriented Class Library
Standard C++ Object Oriented Library defines an extensive set of classes that provide support for a
number of common activities, including I/O, strings, and numeric processing. This library includes the
following −
 The Standard C++ I/O Classes
 The String Class
 The Numeric Classes
 The STL Container Classes
 The STL Algorithms
 The STL Function Objects
 The STL Iterators

lOMoARcPSD|51362898
 The STL Allocators

 The Localization library
 Exception Handling Classes
 Miscellaneous Support Library
C++ Files and Streams

So far, we have been using the iostream standard library, which provides cin and cout methods for
reading from standard input and writing to standard output respectively.
This tutorial will teach you how to read and write from a file. This requires another standard C++ library
called fstream, which defines three new data types:
Data Type Description

ofstream This data type represents the output file stream and is used to create
files and to write information to files.
ifstream This data type represents the input file stream and is used to read
information from files.
fstream This data type represents the file stream generally, and has the
capabilities of both ofstream and ifstream which means it can create
files, write information to files, and read information from files.
To perform file processing in C++, header files <iostream> and <fstream> must be included in your C++
source file.
Opening a File:
A file must be opened before you can read from it or write to it. Either the ofstream or fstream object may
be used to open a file for writing and ifstream object is used to open a file for reading purpose only.
Following is the standard syntax for open() function, which is a member of fstream, ifstream, and ofstream
objects.
void open(const char *filename, ios::openmode mode);
Here, the first argument specifies the name and location of the file to be opened and the second argument of
the open() member function defines the mode in which the file should be opened.
Mode Flag Description

ios::app Append mode. All output to that file to be appended to the end.
ios::ate Open a file for output and move the read/write control to the end of
the file.
ios::in Open a file for reading.
ios::out Open a file for writing.
ios::trunc If the file already exists, its contents will be truncated before opening
the file.

lOMoARcPSD|51362898
You can combine two or more of these values by ORing them together. For example if you want to open a
file in write mode and want to truncate it in case it already exists, following will be the syntax:
ofstream outfile;
outfile.open("file.dat", ios::out | ios::trunc );
Similar way, you can open a file for reading and writing purpose as follows:
fstream afile;
afile.open("file.dat", ios::out | ios::in );
Closing a File
When a C++ program terminates it automatically closes flushes all the streams, release all the allocated
memory and close all the opened files. But it is always a good practice that a programmer should close all
the opened files before program termination.
Following is the standard syntax for close() function, which is a member of fstream, ifstream, and ofstream
objects.
void close();
Writing to a File:
While doing C++ programming, you write information to a file from your program using the stream
insertion operator (<<) just as you use that operator to output information to the screen. The only difference
is that you use an ofstream or fstream object instead of the cout object.
Reading from a File:

You read information from a file into your program using the stream extraction operator (>>) just as you
use that operator to input information from the keyboard. The only difference is that you use an ifstream or
fstream object instead of the cin object.
Read & Write Example:

Following is the C++ program which opens a file in reading and writing mode. After writing
information inputted by the user to a file named afile.dat, the program reads information from the
file and outputs it onto the screen:
#include <fstream>
#include <iostream>
using namespace std;
int main ()
char data[100];
// open a file in write mode.
ofstream outfile;
outfile.open("afile.dat");

lOMoARcPSD|51362898
cout << "Writing to the file" << endl;
cout << "Enter your name: ";
cin.getline(data, 100);
// write inputted data into the file.
outfile << data << endl;
cout << "Enter your age: ";
cin >> data;
cin.ignore();
// again write inputted data into the file.
outfile << data << endl;
// close the opened file.
outfile.close();
// open a file in read mode.
ifstream infile;
infile.open("afile.dat");
cout << "Reading from the file" << endl;
infile >> data;
// write the data at the screen.
cout << data << endl;
// again read the data from the file and display it.
infile >> data;
cout << data << endl;
// close the opened file.
infile.close();
return 0;
When the above code is compiled and executed, it produces the following sample input and
output:
$./a.out
Writing to the file
Enter your name: Zara
Enter your age: 9
Reading from the file
Zara
Above examples make use of additional functions from cin object, like getline() function to read
the line from outside and ignore() function to ignore the extra characters left by previous read
statement.

lOMoARcPSD|51362898
File Position Pointers:

Both istream and ostream provide member functions for repositioning the file-position pointer. These
member functions are seekg ("seek get") for istream and seekp ("seek put") for ostream.
The argument to seekg and seekp normally is a long integer. A second argument can be specified to indicate
the seek direction. The seek direction can be ios::beg (the default) for positioning relative to the beginning
of a stream, ios::cur for positioning relative to the current position in a stream or ios::end for positioning
relative to the end of a stream.
The file-position pointer is an integer value that specifies the location in the file as a number of bytes from
the file's starting location. Some examples of positioning the "get" file-position pointer are:
// position to the nth byte of fileObject (assumes ios::beg)

fileObject.seekg( n );
// position n bytes forward in fileObject
fileObject.seekg( n, ios::cur );
// position n bytes back from end of fileObject
fileObject.seekg( n, ios::end );
// position at end of fileObject
fileObject.seekg( 0, ios::end );
Namespace
The namespace keyword allows you to partition the global namespace by creating a declarative region.
In essence, a namespace defines a scope. The general form of namespace is shown here:
namespace name
{
// declarations
}
Anything defined within a namespace statement is within the scope of that namespace.
There is one difference between a class definition and a namespace definition: The namespace is
concluded with a closing brace but no terminating semicolon.
Example:
namespace A
{
int m;
void display(int n)
{
cout<<n;
}
}
using namespace A; using namespace A::m;

m=100; //OK m=100; //OK
display(200); //OK display(200); // NOT OK, display is not visible

lOMoARcPSD|51362898
In general, to access a member of a namespace from outside its namespace, precede the member's name
with the name of the namespace followed by the scope resolution operator.
Here is a program that demonstrates the use of CounterNameSpace.
// Demonstrate a namespace.
namespace CounterNameSpace
{
int upperbound;
int lowerbound;
class counter
{
int count;
public:
counter(int n)
{
if(n <= upperbound) count = n;
else count = upperbound;
}
void reset(int n)
{
if(n <= upperbound) count = n;
}
int run()
{
if(count > lowerbound) return count--;
else return lowerbound;
}
};
}
void main()
{
CounterNameSpace::upperbound = 100;
CounterNameSpace::lowerbound = 0;
CounterNameSpace::counter ob1(10);
int i;
do
{
i = ob1.run();
cout << i << " ";
} while(i > CounterNameSpace::lowerbound);
cout << endl;
CounterNameSpace::counter ob2(20);
do
{
i = ob2.run();
cout << i << " ";
cout << endl;
ob2.reset(100);

lOMoARcPSD|51362898
CounterNameSpace::lowerbound = 90;
Do
{
i = ob2.run();
cout << i << " ";
}
Notice that the declaration of a counter object and the references to upperbound and lowerbound are
qualified by CounterNameSpace. However, once an object of type counter has been declared, it is not
necessary to further qualify it or any of its members. Thus, ob1.run() can be called directly; the
namespace has already been resolved.
using
As you can imagine, if your program includes frequent references to the members of a namespace,
having to specify the namespace and the scope resolution operator each time you need to refer to one
quickly becomes a tedious chore. The using statement was invented to alleviate this problem. The
using statement has these two general forms:
using namespace name;
using name::member;
In the first form, name specifies the name of the namespace you want to access. All of the members
defined within the specified namespace are brought into view (i.e., they become part of the current
namespace) and may be used without qualification. In the second form, only a specific member of the
namespace is made visible. For example, assuming CounterNameSpace as shown above, the
following using statements and assignments are valid.
using CounterNameSpace::lowerbound; // only lowerbound is visible
lowerbound = 10; // OK because lowerbound is visible
using namespace CounterNameSpace; // all members are visible
upperbound = 100; // OK because all members are now visible
Unnamed Namespaces
There is a special type of namespace, called an unnamed namespace that allows you to create identifiers
that are unique within a file. Unnamed namespaces are also called anonymous namespaces.
They have this general form:
namespace
{
// declarations
}
Unnamed namespaces allow you to establish unique identifiers that are known only within the scope of
a single file. That is, within the file that contains the unnamed namespace, the members of that
namespace may be used directly, without qualification. But outside the file, the identifiers are unknown.
Unnamed namespaces eliminate the need for certain uses of the static storage class modifier.
For example, consider the following two files that are part of the same program.
File One
static int k;
void f1() {
k = 99; // OK
}
File Two
extern int k;

lOMoARcPSD|51362898
void f2() {
k = 10; // error
}
Because k is defined in File One, it may be used in File One. In File Two, k is specified as extern,
which means that its name and type are known but that k itself is not actually defined. When these two
files are linked, the attempt to use k within File Two results in an error because there is no definition for
k. By preceding k with static in File One, its scope is restricted to that file and it is not available to File
Two. While the use of static global declarations is still allowed in C++, a better way to accomplish the
same effect is to use an unnamed namespace. For example:
File One
namespace
{
int k;
}
void f1()
{
k = 99; // OK
}
File Two
extern int k;
void f2()
{
k = 10; // error
}
Here, k is also restricted to File One. The use of the unnamed namespace rather than static is
recommended for new code.
The std Namespace

Standard C++ defines its entire library in its own namespace called std. This is the reason that most of
the programs in this book include the following statement:
This causes the std namespace to be brought into the current namespace, which gives you direct access
to the names of the functions and classes defined within the library without having to qualify each one
with std::. Of course, you can explicitly qualify each name with std:: if you like. For example, the
following program does not bring the library into the global namespace.
// Use explicit std:: qualification.

#include <iostream>
void main()
{
int val;
std::cout << "Enter a number: ";
std::cin >> val;
std::cout << "This is your number: ";
std::cout << std::hex << val;
}

lOMoARcPSD|51362898
Here, cout, cin, and the manipulator hex are explicitly qualified by their namespace. That is, to write to
standard output, you must specify std::cout; to read from standard input, you must use std::cin; and
the hex manipulator must be referred to as std::hex.
Exception Handling
Two common types of error in a program are:
1) Syntax error (arises due to missing semicolon, comma, and wrong prog. constructs etc)
2) Logical error (wrong understanding of the problem or wrong procedure to get the solution)
Exceptions
Exceptions are the errors occurred during a program execution. Exceptions are of two types:
 Synchronous (generated by software i.e. division by 0, array bound etc).
 Asynchronous (generated by hardware i.e. out of memory, keyboard etc).
Exception handling mechanism

 C++ exception handling mechanism is basically built upon three keywords namely, try, throw and
catch.
 Try block hold a block of statements which may generate an exception.
 When an exception is detected, it is thrown using a throw statement in the try block.
 A try block can be followed by any number of catch blocks.
The general form of try and catch block is as follows:

try
{
/* try block; throw exception*/
}
catch (type1 arg)
{
/* catch block*/
}
catch (type2 arg)
{
/* catch block*/
}
The exception handling mechanism is made up of the following elements:

• try blocks

lOMoARcPSD|51362898
• catch blocks
• throw expressions
Exception Handling Options
There are several additional features and nuances to C++ exception handling that make it easier and
more convenient to use. These attributes are discussed here.
Catching All Exceptions

In some circumstances you will want an exception handler to catch all exceptions instead of just a
certain type. This is easy to accomplish. Simply use this form of catch.
catch (...) {
// process all exceptions
}
Here, the ellipsis matches any type of data. The following program illustrates catch (...).
void Xhandler(int test)
{
try
{
if(test==0) throw test; // throw int
if(test==1) throw 'a'; // throw char
if(test==2) throw 123.23; // throw double
}
catch(...)
{
cout << "Caught One!\n";
}
}
void main()
{
cout << "Start\n";
Xhandler(0);
Xhandler(1);
Xhandler(2);
cout << "End";
}
Output:
Start
Caught One!
Caught One!
Caught One!
End
Rethrowing an Exception
If you wish to rethrow an expression from within an exception handler, you may do so by calling throw,
by itself, with no exception. This causes the current exception to be passed on to an outer try/catch
sequence. The most likely reason for doing so is to allow multiple handlers access to the exception. For
example, perhaps one exception handler manages one aspect of an exception and a second handler

lOMoARcPSD|51362898
copes with another. An exception can only be rethrown from within a catch block (or from any function
called from within that block). When you rethrow an exception, it will not be recaught by the same
catch statement. It will propagate outward to the next catch statement. The following program
illustrates rethrowing an exception, in this case a char * exception.
void Xhandler()
{
try
{
throw "hello"; // throw a char *
}
catch(const char *)
{
cout << "Caught char * inside Xhandler\n";
throw ; // rethrow char * out of function
}
}
void main()
{
cout << "Start\n";
try
{
Xhandler();
}
catch(const char *)
{
cout << "Caught char * inside main\n";
}
cout << "End";
}
Output:
Start
Caught char * inside Xhandler
Caught char * inside main
end
Understanding terminate( ) and unexpected( )
As mentioned earlier, terminate() and unexpected() are called when something goes wrong during the
exception handling process. These functions are supplied by the Standard C++ library. Their prototypes
are shown here:
void terminate( );
void unexpected( );
These functions require the header <exception>.
The terminate() function is called whenever the exception handling subsystem fails to find a matching
catch statement for an exception. It is also called if your program attempts to rethrow an exception
when no exception was originally thrown. The terminate() function is also called under various other,

lOMoARcPSD|51362898
more obscure circumstances. For example, such a circumstance could occur when, in the process of
unwinding the stack because of an exception, a destructor for an object being destroyed throws an
exception. In general, terminate() is the handler of last resort when no other handlers for an exception
are available. By default, terminate() calls abort() .
Standard Template Library
The Standard Template Library (STL) is a C++ software library that influenced many parts of the
C++ Standard Library It provides four components called algorithms, containers, functional and
iterators. The STL provides a ready-made set of common classes for C++, such as containers and
associative arrays, that can be used with any built-in type and with any user-defined type that supports
some elementary operations (such as copying and assignment). STL algorithms are independent of
containers, which significantly reduces the complexity of the library.
The STL achieves its results through the use of templates. This approach provides compile-time
polymorphism that is often more efficient than traditional run-time polymorphism. Modern C++
compilers are tuned to minimize any abstraction penalty arising from heavy use of the STL.
At the core of the standard template library are three foundational items: containers, algorithms, and
iterators. These items work in conjunction with one another to provide off-the-shelf solutions to a
variety of programming problems.
Containers
Containers are objects that hold other objects, and there are several different types. For example, the
vector class defines a dynamic array, deque creates a double-ended queue, and list provides a linear
list. These containers are called sequence containers because in STL terminology, a sequence is a linear
list. In addition to the basic containers, the STL also defines associative containers, which allow
efficient retrieval of values based on keys. For example, a map provides access to values with unique
keys. Thus, a map stores a key/value pair and allows a value to be retrieved given its key. Each
container class defines a set of functions that may be applied to the container. For example, a list
container includes functions that insert, delete, and merge elements. A stack includes functions that
push and pop values.
Algorithms
Algorithms act on containers. They provide the means by which you will manipulate the contents of
containers. Their capabilities include initialization, sorting, searching, and transforming the contents of
containers. Many algorithms operate on a range of elements within a container.
Iterators
Iterators are objects that are, more or less, pointers. They give you the ability to cycle through the
contents of a container in much the same way that you would use a pointer to cycle through an array.
There are five types of iterators:
Iterator Access Allowed

Random Access Store and retrieve values. Elements may be accessed randomly.
Bidirectional Store and retrieve values. Forward and backward moving.
Forward Store and retrieve values. Forward moving only.
Input Retrieve, but not store values. Forward moving only.
Output Store, but not retrieve values. Forward moving only.

lOMoARcPSD|51362898
In general, an iterator that has greater access capabilities can be used in place of one that has lesser
capabilities. For example, a forward iterator can be used in place of an input iterator. Iterators are
handled just like pointers. You can increment and decrement them.
You can apply the * operator to them. Iterators are declared using the iterator type defined by the
various containers.The STL also supports reverse iterators. Reverse iterators are either bidirectional or
random-access iterators that move through a sequence in the reverse direction. Thus, if a reverse
iterator points to the end of a sequence, incrementing that iterator will cause it to point to one element
before the end.
Other STL Elements

In addition to containers, algorithms, and iterators, the STL relies upon several other standard
components for support. Chief among these are allocators, predicates, comparison functions, and
function objects. Each container has defined for it an allocator. Allocators manage memory allocation
for a container. The default allocator is an object of class allocator, but you can define your own
allocators if needed by specialized applications. For most uses, the default allocator is sufficient.
Several of the algorithms and containers use a special type of function called a predicate. There are two
variations of predicates: unary and binary. A unary predicate takes one argument, while a binary
predicate has two.
Vectors
Perhaps the most general-purpose of the containers is vector. The vector class supports a dynamic
array. This is an array that can grow as needed. As you know, in C++ the size of an array is fixed at
compile time. While this is by far the most efficient way to implement arrays, it is also the most
restrictive because the size of the array cannot be adjusted at run time to accommodate changing
program conditions. A vector solves this problem by allocating memory as needed. Although a vector is
dynamic, you can still use the standard array subscript notation to access its elements.
The template specification for vector is shown here:
template <class T, class Allocator = allocator<T>> class vector

Here, T is the type of data being stored and Allocator specifies the allocator, which defaults to the
standard allocator. vector has the following constructors:
explicit vector(const Allocator &a = Allocator( ) );
explicit vector(size_type num, const T &val = T ( ),
const Allocator &a = Allocator( ));
vector(const vector<T, Allocator> &ob);
template <class InIter> vector(InIter start, InIter end,
const Allocator &a = Allocator( ));
The first form constructs an empty vector. The second form constructs a vector that has num elements
with the value val. The value of val may be allowed to default. The third form constructs a vector that
contains the same elements as ob. The fourth form constructs a vector that contains the elements in the
range specified by the iterators start and end.

lOMoARcPSD|51362898
Any object that will be stored in a vector must define a default constructor. It must also define the <
and == operations. Some compilers may require that other comparison operators be defined. (Since
implementations vary, consult your compiler's documentation for precise information.) All of the builtin
types automatically satisfy these requirements.
Although the template syntax looks rather complex, there is nothing difficult about declaring a vector.
Here are some examples:
vector<int> iv; // create zero-length int vector

vector<char> cv(5); // create 5-element char vector
vector<char> cv(5, 'x'); // initialize a 5-element char vector
vector<int> iv2(iv); // create int vector from an int vector
The following comparison operators are defined for vector:

==, <, <=, !=, >, >=
The subscripting operator [ ] is also defined for vector. This allows you to access the elements of a
vector using standard array subscripting notation.
Basic operation of a vector.

Solution:
#include <iostream>
#include <vector>
#include <cctype>
void main ()
{
vector<char> v(10); // create a vector of length 10
int i;
// display original size of v
cout << "Size = " << v.size() << endl;
// assign the elements of the vector some values
for(i=0; i<10; i++) v[i] = i + 'a';
// display contents of vector
cout << "Current Contents:\n";
for(i=0; i<v.size(); i++) cout << v[i] << " ";
cout << "\n\n";
cout << "Expanding vector\n";
/* put more values onto the end of the vector,
it will grow as needed */
for(i=0; i<10; i++) v.push_back(i + 10 + 'a');
// display current size of v
cout << "Size now = " << v.size() << endl;
// display contents of vector
cout << "Current contents:\n";
cout << "\n\n";
// change contents of vector
for(i=0; i<v.size(); i++) v[i] = toupper(v[i]);
cout << "Modified Contents:\n";

lOMoARcPSD|51362898
cout << endl;

}
Output:
Size = 10
Current Contents:
abcdefghij
Expanding vector
Size now = 20
Current contents:
abcdefghijklmnopqrst
Modified Contents:
ABCDEFGHIJKLMNOPQRST

Oops Complete Notes

Uploaded by

Oops Complete Notes

Uploaded by

lOMoARcPSD|51362898

Oops complete Notes

object oriented programming using C++ (Chaudhary Charan Singh University)

Scan to open on Studocu

Studocu is not sponsored or endorsed by any college or university

Object Oriented Programming

Procedure/ structure oriented Programming

Object Oriented Programming

Basic Concepts of Object-Oriented Programming

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Similarities between C and C++ are:

Differences between C and C++ are:

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Output and Input Statement in C++ : Cin and cout

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

<< (two "less than" signs) is called insertion operator.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Memory Allocation to an integer.

The Placement Forms of new and delete

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Encapsulation and Data Hiding

Data Hiding Definition:

Access Specifiers in C++

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Features and Advantages of Data Encapsulation:

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Class and Object

General form of a class declaration is:

Steps to write a C++ program using class and object:

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

void Add :: calculate()

A member function can be defined:

How to access member of a class?

Application of Scope resolution operator (::)

Object as Function argument

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

void Employee:: getdata(void)

There three types of constructor:

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

The constructor which has no arguments is known as default constructor.

Demonstration of default Constructor.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

A parameterized constructor can be called:

What is Dynamic Initialization of an object?

Write a program to initialize two integer variables using parameterized

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

What is Constructor Overloading?

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Why inline function is used?

Write a program to find area of a circle using inline function.

Demonstration of Friend Function.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

friend int calculate(Add p);

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Static Data Members

Demonstration of static data members.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Static Member function/method

Demonstration of static member function.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

res=ABC :: add(30, 40);

C++ Garbage Collection

 memory leaks or memory exhaustion problem can be avoided

Advantages and Disadvantages of Garbage Collector

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Base-Class Access Control

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Example of single inheritance with base class access control as public.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Example of single inheritance with base class access control as private.

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Note: visibility mode can be either private, public or protected

Downloaded by Amos Shadrack (amos74shadrack@gmail.com)

Constructor and Destructor Execution in Inheritance