Introduction to C++

C++, as we all know is an extension to C language and was developed by Bjarne stroustrup at
bell labs. C++ is an intermediate level language, as it comprises a confirmation of both high level
and low level language features. C++ is a statically typed, free form, multiparadigm, compiled
general-purpose language.
C++ is an Object Oriented Programming language but is not purely Object Oriented. Its
features like Friend and Virtual, violate some of the very important OOPS features, rendering
this language unworthy of being called completely Object Oriented. Its a middle level language.
Benefits of C++ over C Language
The major difference being OOPS concept, C++ is an object oriented language whereas C
language is a procedural language. Apart form this there are many other features of C++ which
gives this language an upper hand on C laguage.
Following features of C++ makes it a stronger language than C,
1. There is Stronger Type Checking in C++.
2. All the OOPS features in C++ like Abstraction, Encapsulation, Inheritance etc makes it more
worthy and useful for programmers.
3. C++ supports and allows user defined operators (i.e Operator Overloading) and function
overloading is also supported in it.
4. Exception Handling is there in C++.
5. The Concept of Virtual functions and also Constructors and Destructors for Objects.
6. Inline Functions in C++ instead of Macros in C language. Inline functions make complete
function body act like Macro, safely.
7. Variables can be declared anywhere in the program in C++, but must be declared before they
are used.
Object Oriented Programming
Object Oriented programming is a programming style that is associated with the concept of
Class, Objects and various other concepts revolving around these two, like Inheritance,
Polymorphism, Abstraction, Encapsulation etc.
 Class
Here we can take Human Being as a class. A class is a blueprint for any functional entity which
defines its properties and its functions. Like Human Being, having body parts, and performing
various actions.

Inheritance
Considering HumanBeing a class, which has properties like hands, legs, eyes etc, and functions
like walk, talk, eat, see etc. Male and Female are also classes, but most of the properties and
functions are included in HumanBeing, hence they can inherit everything from
class HumanBeing using the concept of Inheritance.

Objects
My name is Abhishek, and I am an instance/object of class Male. When we say, Human Being,
Male or Female, we just mean a kind, you, your friend, me we are the forms of these classes. We
have a physical existence while a class is just a logical definition. We are the objects.

Abstraction
Abstraction means, showcasing only the required things to the outside world while hiding the
details. Continuing our example, Human Being's can talk, walk, hear, eat, but the details are
hidden from the outside world. We can take our skin as the Abstraction factor in our case, hiding
the inside mechanism.

Encapsulation
This concept is a little tricky to explain with our example. Our Legs are binded to help us walk.
Our hands, help us hold things. This binding of the properties to functions is called
Encapsulation.

Polymorphism
Polymorphism is a concept, which allows us to redefine the way something works, by either
changing how it is done or by changing the parts using which it is done. Both the ways have
different terms for them.
If we walk using our hands, and not legs, here we will change the parts used to perform
something. Hence this is called Overloading.
And if there is a defined way of walking, but I wish to walk differently, but using my legs, like
everyone else. Then I can walk like I want, this will be called as Overriding.

OOPS Concept Definitions

Now, let us discuss some of the main features of Object Oriented Programming which you will
be using in C++(technically).
1. Objects
2. Classes
3. Abstraction
4. Encapsulation
5. Inheritance
6. Overloading
7. Exception Handling
Objects
Objects are the basic unit of OOP. They are instances of class, which have data members and
uses various member functions to perform tasks.
Class
It is similar to structures in C language. Class can also be defined as user defined data type but it
also contains functions in it. So, class is basically a blueprint for object. It declare & defines what
data variables the object will have and what operations can be performed on the class's object.
Abstraction
Abstraction refers to showing only the essential features of the application and hiding the details.
In C++, classes can provide methods to the outside world to access & use the data variables,
keeping the variables hidden from direct access, or classes can even declare everything
accessible to everyone, or maybe just to the classes inheriting it. This can be done using access
specifiers.
Encapsulation
It can also be said data binding. Encapsulation is all about binding the data variables and
functions together in class.
Inheritance
Inheritance is a way to reuse once written code again and again. The class which is inherited is
called the Base class & the class which inherits is called the Derived class. They are also called
parent and child class.
So when, a derived class inherits a base class, the derived class can use all the functions which
are defined in base class, hence making code reusable.
Polymorphism
It is a feature, which lets us create functions with same name but different arguments, which will
perform different actions. That means, functions with same name, but functioning in different
ways. Or, it also allows us to redefine a function to provide it with a completely new definition.
You will learn how to do this in details soon in coming lessons.
Exception Handling
Exception handling is a feature of OOP, to handle unresolved exceptions or errors produced at
runtime.
Syntax and Structure of C++ program
Here we will discuss one simple and basic C++ program to print "Hello this is C++" and its
structure in parts with details and uses.
First C++ program
#include <iostream.h>
using namespace std;
int main()
{
cout << "Hello this is C++";
}

Comments in C++ Program

For single line comments, use // before mentioning comment, like
cout<<"single line"; // This is single line comment
For multiple line comment, enclose the comment between /* and */
/*this is
 a multiple line
comment */

Datatypes and Modifiers in C++

Let's start with Datatypes. They are used to define type of variables and contents used. Data
types define the way you use storage in the programs you write. Data types can be of two types:
1. Built-in Datatypes
2. User-defined or Abstract Datatypes

Built-in Data Types

These are the datatypes which are predefined and are wired directly into the compiler. For
eg: int, char etc.

User defined or Abstract data types

These are the type, that user creates as a class or a structure. In C++ these are classes where as in
C language user-defined datatypes were implemented as structures.

Basic Built in Datatypes in C++

char for character storage (1 byte)

int for integral number (2 bytes)

float single precision floating point (4 bytes)

double double precision floating point numbers (8 bytes)

Example:
char a = 'A'; // character type
int a = 1; // integer type
float a = 3.14159; // floating point type
double a = 6e-4; // double type (e is for exponential)

Other Built in Datatypes in C++

bool Boolean (True or False)

void Without any Value

wchar_t Wide Character

Enum as Datatype in C++

Enumerated type declares a new type-name along with a sequence of values containing
identifiers which has values starting from 0 and incrementing by 1 every time.
For Example:
enum day(mon, tues, wed, thurs, fri) d;
Here an enumeration of days is defined which is represented by the variable d. mon will hold
value 0, tue will have 1 and so on. We can also explicitly assign values, like, enum day(mon,
tue=7, wed);. Here, mon will be 0, tue will be assigned 7, so wed will get value 8.

Modifiers in C++
In C++, special words(called modifiers) can be used to modify the meaning of the predefined
built-in data types and expand them to a much larger set. There are four datatype modifiers in
C++, they are:
1. long
2. short
3. signed
4. unsigned
The above mentioned modifiers can be used along with built in datatypes to make them more
precise and even expand their range.
Below mentioned are some important points you must know about the modifiers,
 long and short modify the maximum and minimum values that a data type will hold.
 A plain int must have a minimum size of short.
 Size hierarchy : short int < int < long int
 Size hierarchy for floating point numbers is : float < double < long double
 long float is not a legal type and there are no short floating point numbers.
 Signed types includes both positive and negative numbers and is the default type.
 Unsigned, numbers are always without any sign, that is always positive.
What are Variables
Variable are used in C++, where we need storage for any value, which will change in program.
Variable can be declared in multiple ways each with different memory requirements and
functioning. Variable is the name of memory location allocated by the compiler depending upon
the datatype of the variable.

Basic types of Variables

Each variable while declaration must be given a datatype, on which the memory assigned to the
variable depends. Following are the basic types of variables,
bool For variable to store boolean values( True or False )

char For variables to store character types.

int for variable with integral values

float and double are also types for variables with large and floating point values
Declaration and Initialization
Variable must be declared before they are used. Usually it is preferred to declare them at the
starting of the program, but in C++ they can be declared in the middle of program too, but must
be done before using them.
For example:
int i; // declared but not initialised
char c;
int i, j, k; // Multiple declaration
Initialization means assigning value to an already declared variable,
int i; // declaration
i = 10; // initialization
Initialization and declaration can be done in one single step also,
int i=10; //initialization and declaration in same step
int i=10, j=11;
If a variable is declared and not initialized by default it will hold a garbage value. Also, if a
variable is once declared and if try to declare it again, we will get a compile time error.
int i,j;
i=10;
j=20;
int j=i+j; //compile time error, cannot redeclare a variable in same scope
Scope of Variables
All the variables have their area of functioning, and out of that boundary they don't hold their
value, this boundary is called scope of the variable. For most of the cases its between the curly
braces,in which variable is declared that a variable exists, not outside it. We will study the
storage classes later, but as of now, we can broadly divide variables into two main types,
 Global Variables
 Local variables
Global variables
Global variables are those, which ar once declared and can be used throughout the lifetime of the
program by any class or any function. They must be declared outside the main() function. If only
declared, they can be assigned different values at different time in program lifetime. But even if
they are declared and initialized at the same time outside the main() function, then also they can
be assigned any value at any point in the program.
For example: Only declared, not initialized
include <iostream>
using namespace std;
int x; // Global variable declared
int main()
{
 x=10; // Initialized once
cout <<"first value of x = "<< x;
x=20; // Initialized again
cout <<"Initialized again with value = "<< x;
}
Local Variables
Local variables are the variables which exist only between the curly braces, in which its
declared. Outside that they are unavailable and leads to compile time error.
Example :
include <iostream>
using namespace std;
int main()
{
int i=10;
if(i<20) // if condition scope starts
{
int n=100; // Local variable declared and initialized
} // if condition scope ends
cout << n; // Compile time error, n not available here
}

 Overview of C++
 Introduction to C++
 OOPS concepts basic
 Basic Syntax and Structure
 Data types and Modifiers
 Variables in C++
 Operators in C++
 sizeof and typedef in C++
 Decision Making
 Loop types
 Storage Classes
 Functions
 Core C++ Concepts
 Classes and Objects
 Access Controls in classes
 Defining class and object
 Accessing Data Members
 Member Functions in class
 Types of Member Functions
 Inline Functions
 Function Overloading
 Constructor and Destructor
 Static Keyword
 Const Keyword
 Refrences
 Copy Constructor
 Pointer to Members
 Inheritance
 Introduction to Inheritance
 Types of Inheritance
 Order of Constructor Call
 Upcasting
 Polymorphism
 Function Overriding
 Virtual Functions
 Abstract class and Pure Virtual Functions
 Virtual Destructors
 Operator Overloading
 Operator Overloading
 Operator Overloading Examples
 C++ Miscellaneous
 File Streams
 Exception Handling
 Memory Management
 Multithreading
 Initializer List
 Defining Namespace
 STL in C++ →
 C++ Programs →
Operators in C++
Operators are special type of functions, that takes one or more arguments and produces a new
value. For example : addition (+), substraction (-), multiplication (*) etc, are all operators.
Operators are used to perform various operations on variables and constants.

Types of operators
1. Assignment Operator
2. Mathematical Operators
3. Relational Operators
4. Logical Operators
5. Bitwise Operators
6. Shift Operators
7. Unary Operators
8. Ternary Operator
9. Comma Operator

Some special types of variable

There are also some special keywords, to impart unique characteristics to the variables in the
program. Following two are mostly used, we will discuss them in details later.
1. Final - Once initialized, its value cant be changed.
2. Static - These variables holds their value between function calls.
Example :
#include <iostream.h>
using namespace std;
int main()
{
final int i=10;
static int y=20;
}

sizeOf and typedef Operators in C++

In this tutorial we will cover the usage of sizeOf and typedef operators in C++.
sizeOf is also an operator not a function, it is used to get information about the amount of
memory allocated for data types & Objects. It can be used to get size of user defined data types
too.
sizeOf operator can be used with and without parentheses. If you apply it to a variable you can
use it without parentheses.
cout << sizeOf(double); //Will print size of double
int x = 2;
int i = sizeOf x;

typedef Operator in C++

typedef is a keyword used in C language to assign alternative names to existing types. Its mostly
used with user defined data types, when names of data types get slightly complicated. Following
is the general syntax for using typedef,
typedef existing_name alias_name

Lets take an example and see how typedef actually works.

typedef unsigned long ulong;
The above statement define a term ulong for an unsigned long type. Now this ulong identifier
can be used to define unsigned long type variables.
ulong i, j;

Decision making in C++

Decision making is about deciding the order of execution of statements based on certain
conditions or repeat a group of statements until certain specified conditions are met. C++ handles
decision-making by supporting the following statements,
 if statement
 switch statement
 conditional operator statement
 goto statement

Decision making with if statement

The if statement may be implemented in different forms depending on the complexity of
conditions to be tested. The different forms are,
1. Simple if statement
2. if....else statement
3. Nested if....else statement
4. else if statement
This concept is same as in C-Language.
There are 3 type of loops in C++ language
1. while loop
2. for loop
3. do-while loop

This concept is same as in C-Language.

Storage Classes in C++
Storage classes are used to specify the lifetime and scope of variables. How storage is allocated
for variables and How variable is treated by complier depends on these storage classes.
These are basically divided into 5 different types:
1. Global variables
2. Local variables
3. Register variables
4. Static variables
5. Extern variables
This concept is same as in C-Language.

Functions in C++
Functions are used to provide modularity to a program. Creating an application using function
makes it easier to understand, edit, check errors etc.

Basic Syntax for using Functions in C++

Here is how you define a function in C++,
return-type function-name(parameter1, parameter2, ...)
{
// function-body
}
 return-type: suggests what the function will return. It can be int, char, some pointer or even
a class object. There can be functions which does not return anything, they are mentioned
with void.
 Function Name: is the name of the function, using the function name it is called.
 Parameters: are variables to hold values of arguments passed while function is called. A
function may or may not contain parameter list.
 // function for adding two values
 void sum(int x, int y)
 {
 int z;
 z = x + y;
 cout << z;
 }

 int main()
 {
 int a = 10;
 int b = 20;
 // calling the function with name 'sum'
 sum (a, b);
}
Here, a and b are two variables which are sent as arguments to the function sum,
and x and y are parameters which will hold values of a and b to perform the required
operation inside the function.
 Function body: is the part where the code statements are written.

Declaring, Defining and Calling a Function

Function declaration, is done to tell the compiler about the existence of the function. Function's
return type, its name & parameter list is mentioned. Function body is written in its definition.
Lets understand this with help of an example.
#include < iostream>
using namespace std;

//declaring the function

int sum (int x, int y);

int main()
{
int a = 10;
int b = 20;
int c = sum (a, b); //calling the function
cout << c;
}

//defining the function

int sum (int x, int y)
{
return (x + y);
}
Here, initially the function is declared, without body. Then inside main() function it is called, as
the function returns sumation of two values, and variable c is there to store the result. Then, at
last, function is defined, where the body of function is specified. We can also, declare & define
the function together, but then it should be done before it is called.

Calling a Function
Functions are called by their names. If the function is without argument, it can be called directly
using its name. But for functions with arguments, we have two ways to call them,
1. Call by Value
2. Call by Reference

Call by Value
In this calling technique we pass the values of arguments which are stored or copied into the
formal parameters of functions. Hence, the original values are unchanged only the parameters
inside function changes.
void calc(int x);

int main()
{
int x = 10;
calc(x);
printf("%d", x);
}

void calc(int x)
{
x = x + 10 ;
}

10
In this case the actual variable x is not changed, because we pass argument by value, hence a
copy of x is passed, which is changed, and that copied value is destroyed as the function
ends(goes out of scope). So the variable x inside main() still has a value 10.
But we can change this program to modify the original x, by making the function calc() return a
value, and storing that value in x.
int calc(int x);

int main()
{
int x = 10;
x = calc(x);
printf("%d", x);
}

int calc(int x)
{
x = x + 10 ;
return x;
}

20

Call by Reference
In this we pass the address of the variable as arguments. In this case the formal parameter can be
taken as a reference or a pointer, in both the case they will change the values of the original
variable.
void calc(int *p);

int main()
{
int x = 10;
calc(&x); // passing address of x as argument
printf("%d", x);
}

void calc(int *p)

{
*p = *p + 10;
}

20
Classes and Objects
The classes are the most important feature of C++ that leads to Object Oriented programming.
Class is a user defined data type, which holds its own data members and member functions,
which can be accessed and used by creating instance of that class.
The variables inside class definition are called as data members and the functions are called
member functions.
For example: Class of birds, all birds can fly and they all have wings and beaks. So here flying
is a behavior and wings and beaks are part of their characteristics. And there are many different
birds in this class with different names but they all posses this behavior and characteristics.
Similarly, class is just a blue print, which declares and defines characteristics and behavior,
namely data members and member functions respectively. And all objects of this class will share
these characteristics and behavior.
1. Class name must start with an uppercase letter(Although this is not mandatory). If class name
is made of more than one word, then first letter of each word must be in uppercase. Example,
class Study, class StudyTonight etc
2. Classes contain, data members and member functions, and the access of these data members
and variable depends on the access specifiers (discussed in next section).
3. Class's member functions can be defined inside the class definition or outside the class
definition.
4. Class in C++ are similar to structures in C, the only difference being, class defaults to private
access control, where as structure defaults to public.
5. All the features of OOPS, revolve around classes in C++. Inheritance, Encapsulation,
Abstraction etc.
6. Objects of class holds separate copies of data members. We can create as many objects of a
class as we need.
7. Classes do posses more characteristics, like we can create abstract classes, immutable classes,
all this we will study later.

class Abc
{
int x;
void display()
{
// some statement
}
};

void main()
{
Abc obj; // Object of class Abc created
}

Access Control in C++

Now before studying how to define class and its objects, lets first quickly learn what are access
modifiers.
Access modifiers in C++ class defines the access control rules. C++ has 3 new keywords
introduced, namely,
1. public
2. private
3. protected
These access modifiers are used to set boundaries for availability of members of class be it data
members or member functions
Access modifiers in the program, are followed by a colon. You can use either one, two or all 3
modifiers in the same class to set different boundaries for different class members. They change
the boundary for all the declarations that follow them.
Public Access Modifier in C++
Public, means all the class members declared under public will be available to everyone. The
data members and member functions declared public can be accessed by other classes too. Hence
there are chances that they might change them. So the key members must not be declared public.
class PublicAccess
{
// public access modifier
public:
int x; // Data Member Declaration
void display(); // Member Function decaration
}
Private Access Modifier in C++
Private keyword, means that no one can access the class members declared private, outside that
class. If someone tries to access the private members of a class, they will get a compile time
error. By default class variables and member functions are private.
class PrivateAccess
{
// private access modifier
private:
int x; // Data Member Declaration
void display(); // Member Function decaration
}
Protected Access Modifier in C++
Protected, is the last access specifier, and it is similar to private, it makes class member
inaccessible outside the class. But they can be accessed by any subclass of that class. (If class A
is inherited by class B, then class B is subclass of class A. We will learn about inheritance later.)
class ProtectedAccess
{
// protected access modifier
protected:
int x; // Data Member Declaration
void display(); // Member Function decaration
}

Defining Class and Creating Objects

When we define any class, we are not defining any data, we just define a structure or a blueprint,
as to what the object of that class type will contain and what operations can be performed on that
object.
Below is the syntax of class definition,
class ClassName
{
Access specifier:
Data members;
Member Functions()
{
// member function defintion
}
};

Here is an example, we have made a simple class named Student with appropriate members,
class Student
{
public:
int rollno;
string name;
};
So its clear from the syntax and example, class definition starts with the keyword "class"
followed by the class name. Then inside the curly braces comes the class body, that is data
members and member functions, whose access is bounded by access specifier. A class definition
ends with a semicolon, or with a list of object declarations.
For example:
class Student
{
public:
int rollno;
string name;
}A,B;

Here A and B are the objects of class Student, declared with the class definition. We can also
declare objects separately, like we declare variable of primitive data types. In this case the data
type is the class name, and variable is the object.
int main()
{
// creating object of class Student
Student A;
Student B;
}
Both A and B will have their own copies of data members i.e. rollno and name and we can store
different values for them in these objects.
Member Functions of Classes in C++
Member functions are the functions, which have their declaration inside the class definition and
works on the data members of the class. The definition of member functions can be inside or
outside the definition of class.
If the member function is defined inside the class definition it can be defined directly, but if its
defined outside the class, then we have to use the scope resolution :: operator along with class
name alng with function name.
For example:
class Cube
{
public:
int side;
/*
Declaring function getVolume
with no argument and return type int.
*/
int getVolume();
};
If we define the function inside class then we don't not need to declare it first, we can directly
define the function.
class Cube
{
public:
int side;
int getVolume()
{
return side*side*side; //returns volume of cube
}
};
But if we plan to define the member function outside the class definition then we must declare
the function inside class definition and then define it outside.
class Cube
{
public:
int side;
int getVolume();
}

// member function defined outside class definition

int Cube :: getVolume()
{
return side*side*side;
}
The main function for both the function definition will be same. Inside main() we will create
object of class, and will call the member function using dot . operator.
Calling Class Member Function in C++
Similar to accessing a data member in the class, we can also access the public member functions
through the class object using the dot operator (.).
Below we have a simple code example, where we are creating an object of the class Cube and
calling the member function getVolume():
int main()
{
Cube C1;
C1.side = 4; // setting side value
cout<< "Volume of cube C1 = "<< C1.getVolume();
}

Volume of cube C1 = 16
Types of Class Member Functions in C++
We already know what member functions are, what they do, how to define member function and
how to call them using class objects. Now lets learn about some special member functions which
can be defined in C++ classes. Following are the different types of Member functions:
1. Simple functions
2. Static functions
3. Const functions
4. Inline functions
5. Friend functions
Inline Functions in C++
Inline functions are actual functions, which are copied everywhere during compilation, like
preprocessor macro, so the overhead of function calling is reduced. All the functions defined
inside class definition are by default inline, but you can also make any non-class function inline
by using keyword inline with them.
For an inline function, declaration and definition must be done together. For example,
inline void fun(int a)
{
return a++;
}

Some Important points about Inline Functions

1. We must keep inline functions small, small inline functions have better efficiency.
2. Inline functions do increase efficiency, but we should not make all the functions inline.
Because if we make large functions inline, it may lead to code bloat, and might affect the
speed too.
3. Hence, it is adviced to define large functions outside the class definition using scope
resolution ::operator, because if we define such functions inside class definition, then they
become inline automatically.
4. Inline functions are kept in the Symbol Table by the compiler, and all the call for such
functions is taken care at compile time.
Getter and Setter Functions in C++
We have already studied this in the topic accessing private data variables inside a class. We use
access functions, which are inline to do so.
class Auto
{
// by default private
int price;

public:
// getter function for variable price
int getPrice()
{
return price;
}
// setter function for variable price
void setPrice(int x)
{
i=x;
}
};
Here getPrice() and setPrice() are inline functions, and are made to access the private data
members of the class Auto. The function getPrice(), in this case is called Getter or
Accessorfunction and the function setPrice() is a Setter or Mutator function.
There can be overlaoded Accessor and Mutator functions too. We will study overloading
functions in next topic.
Limitations of Inline Functions
1. Large Inline functions cause Cache misses and affect performance negatively.
2. Compilation overhead of copying the function body everywhere in the code on compilation,
which is negligible for small programs, but it makes a difference in large code bases.
3. Also, if we require address of the function in program, compiler cannot perform inlining on
such functions. Because for providing address to a function, compiler will have to allocate
storage to it. But inline functions doesn't get storage, they are kept in Symbol table.
Function Overloading in C++
If any class have multiple functions with same names but different parameters then they are said
to be overloaded. Function overloading allows you to use the same name for different functions,
to perform, either same or different functions in the same class.
Function overloading is usually used to enhance the readability of the program. If you have to
perform one single operation but with different number or types of arguments, then you can
simply overload the function.
Different ways to Overload a Function
1. By changing number of Arguments.
2. By having different types of argument.
Function Overloading: Different Number of Arguments
In this type of function overloading we define two functions with same names but different
number of parameters of the same type. For example, in the below mentioned program we have
made two sum() functions to return sum of two and three integers.
// first definition
int sum (int x, int y)
{
cout << x+y;
}

// second overloaded defintion

int sum(int x, int y, int z)
{
cout << x+y+z;
}
Here sum() function is said to overloaded, as it has two defintion, one which accepts two
arguments and another which accepts three arguments. Which sum() function will be called,
depends on the number of arguments.
int main()
{
// sum() with 2 parameter will be called
sum (10, 20);

//sum() with 3 parameter will be called

sum(10, 20, 30);
}
30
60
Function Overloading: Different Datatype of Arguments
In this type of overloading we define two or more functions with same name and same number
of parameters, but the type of parameter is different. For example in this program, we have two
sum() function, first one gets two integer arguments and second one gets two double arguments.
// first definition
int sum(int x, int y)
{
cout<< x+y;
}

// second overloaded defintion

double sum(double x, double y)
{
cout << x+y;
}

int main()
{
sum (10,20);
sum(10.5,20.5);
}

30
31.0
Functions with Default Arguments
When we mention a default value for a parameter while declaring the function, it is said to be as
default argument. In this case, even if we make a call to the function without passing any value
for that parameter, the function will take the default value specified.
sum(int x, int y=0)
{
cout << x+y;
}
Here we have provided a default value for y, during function definition.

int main()
{
sum(10);
sum(10,0);
sum(10,10);
}
10 10 20
First two function calls will produce the exact same value.
for the third function call, y will take 10 as value and output will become 20.
By setting default argument, we are also overloading the function. Default arguments also allow
you to use the same function in different situations just like function overloading.
Rules for using Default Arguments
1. Only the last argument must be given default value. You cannot have a default argument
followed by non-default argument.
2. sum (int x,int y);
3. sum (int x,int y=0);
4. sum (int x=0,int y); // This is Incorrect
5. If you default an argument, then you will have to default all the subsequent arguments after
that.
6.
7. sum (int x,int y=0);
8. sum (int x,int y=0,int z); // This is incorrect
9. sum (int x,int y=10,int z=10); // Correct
10. You can give any value a default value to argument, compatible with its datatype.
Function with Placeholder Arguments
When arguments in a function are declared without any identifier they are called placeholder
arguments.
void sum (int, int);
Such arguments can also be used with default arguments.
void sum (int, int=0);

Constructors and Destructors in C++

Constructors are special class functions which performs initialization of every object. The
Compiler calls the Constructor whenever an object is created. Constructors initialize values to
object members after storage is allocated to the object.
Whereas, Destructor on the other hand is used to destroy the class object.
Let's start with Constructors first, following is the syntax of defining a constructor function in a
class:
class A
{
int x;
public:
// constructor
A()
{
// object initialization
}
};
While defining a contructor you must remeber that the name of constructor will be same as
the name of the class, and contructors will never have a return type.
Constructors can be defined either inside the class definition or outside class definition using
class name and scope resolution :: operator.
class A
{
int i;
 public:
A(); // constructor declared
};

// constructor definition
A::A()
{
i=1;
}

Types of Constructors in C++

Constructors are of three types:
1. Default Constructor
2. Parametrized Constructor
3. Copy COnstructor

Default Constructors
Default constructor is the constructor which doesn't take any argument. It has no parameter.
Syntax:
class_name(parameter1, parameter2, ...)
{
// constructor Definition
}
For example:
class Cube
{
int side;
public:
Cube()
{
side=10;
}
};

int main()
{
Cube c;
cout << c.side;
}

10
In this case, as soon as the object is created the constructor is called which initializes its data
members.
A default constructor is so important for initialization of object members, that even if we do not
define a constructor explicitly, the compiler will provide a default constructor implicitly.
class Cube
{
public:
int side;
};

int main()
{
Cube c;
cout << c.side;
}

0 or any random value

In this case, default constructor provided by the compiler will be called which will initialize the
object data members to default value, that will be 0 or any random integer value in this case.

Parameterized Constructors
These are the constructors with parameter. Using this Constructor you can provide different
values to data members of different objects, by passing the appropriate values as argument.
For example:
class Cube
{
public:
int side;
Cube(int x)
{
side=x;
}
};

int main()
{
Cube c1(10);
Cube c2(20);
Cube c3(30);
cout << c1.side;
cout << c2.side;
cout << c3.side;
}

10
20
30
By using parameterized construcor in above case, we have initialized 3 objects with user defined
values. We can have any number of parameters in a constructor.
Copy Constructors
These are special type of Constructors which takes an object as argument, and is used to copy
values of data members of one object into other object. We will study copy constructors in detail
later.

Constructor Overloading in C++

Just like other member functions, constructors can also be overloaded. Infact when you have
both default and parameterized constructors defined in your class you are having Overloaded
Constructors, one with no parameter and other with parameter.
You can have any number of Constructors in a class that differ in parameter list.
class Student
{
int rollno;
string name;
public:
// first constructo
Student(int x)
{
rollno=x;
name="None";
}
// second constructor
Student(int x, string str)
{
rollno=x ;
name=str ;
}
};

int main()
{
// student A initialized with roll no 10 and name None
Student A(10);

// student B initialized with roll no 11 and name John

Student B(11, "John");
}
In above case we have defined two constructors with different parameters, hence overloading the
constructors.
One more important thing, if you define any constructor explicitly, then the compiler will not
provide default constructor and you will have to define it yourself.
In the above case if we write Student S; in main(), it will lead to a compile time error, because
we haven't defined default constructor, and compiler will not provide its default constructor
because we have defined other parameterized constructors.

Destructors in C++
Destructor is a special class function which destroys the object as soon as the scope of object
ends. The destructor is called automatically by the compiler when the object goes out of scope.
The syntax for destructor is same as that for the constructor, the class name is used for the name
of destructor, with a tilde ~ sign as prefix to it.
class A
{
public:
// defining destructor for class
~A()
{
// statement
}
};
Destructors will never have any arguments.

Example to see how Constructor and Destructor are called

Below we have a simple class A with a constructor and destructor. We will create object of the
class and see when a constructor is called and when a destructor gets called.
class A
{
// constructor
A()
{
cout << "Constructor called";
}

// destructor
~A()
{
cout << "Destructor called";
}
};

int main()
{
A obj1; // Constructor Called
int x=1
if(x)
{
A obj2; // Constructor Called
} // Destructor Called for obj2
} // Destructor called for obj1

Constructor called
Constructor called
Destructor called
Destructor called
When an object is created the constructor of that class is called. The object reference is destroyed
when its scope ends, which is generally after the closing curly bracket } for the code block in
which it is created.
The object obj2 is destroyed when the if block ends because it was created inside the if block.
And the object obj1 is destroyed when the main() function ends.

Static Keyword in C++

Static is a keyword in C++ used to give special characteristics to an element. Static elements are
allocated storage only once in a program lifetime in static storage area. And they have a scope till
the program lifetime. Static Keyword can be used with following,
1. Static variable in functions
2. Static Class Objects
3. Static member Variable in class
4. Static Methods in class

Static Variables inside Functions

Static variables when used inside function are initialized only once, and then they hold there
value even through function calls.
These static variables are stored on static storage area , not in stack.
void counter()
{
static int count=0;
cout << count++;
}

int main(0
{
for(int i=0;i<5;i++)
{
counter();
}
}

01234
Let's se the same program's output without using static variable.
void counter()
{
int count=0;
cout << count++;
}

int main(0
{
for(int i=0;i<5;i++)
{
 counter();
}
}

00000
If we do not use static keyword, the variable count, is reinitialized everytime
when counter()function is called, and gets destroyed each time when counter() functions ends.
But, if we make it static, once initialized count will have a scope till the end of main() function
and it will carry its value through function calls too.
If you don't initialize a static variable, they are by default initialized to zero.

Static Class Objects

Static keyword works in the same way for class objects too. Objects declared static are allocated
storage in static storage area, and have scope till the end of program.
Static objects are also initialized using constructors like other normal objects. Assignment to
zero, on using static keyword is only for primitive datatypes, not for user defined datatypes.
class Abc
{
int i;
public:
Abc()
{
i=0;
cout << "constructor";
}
~Abc()
{
cout << "destructor";
}
};

void f()
{
static Abc obj;
}

int main()
{
int x=0;
if(x==0)
{
f();
}
cout << "END";
}
constructor END destructor
You must be thinking, why was the destructor not called upon the end of the scope
of if condition, where the reference of object obj should get destroyed. This is because object
was static, which has scope till the program's lifetime, hence destructor for this object was called
when main() function exits.

Static Data Member in Class

Static data members of class are those members which are shared by all the objects. Static data
member has a single piece of storage, and is not available as separate copy with each object, like
other non-static data members.
Static member variables (data members) are not initialied using constructor, because these are
not dependent on object initialization.
Also, it must be initialized explicitly, always outside the class. If not initialized, Linker will give
error.
class X
{
static int i;
public:
X()
{
// construtor
};
};

int X::i=1;

int main()
{
X obj;
cout << obj.i; // prints value of i
}

1
Once the definition for static data member is made, user cannot redefine it. Though, arithmetic
operations can be performed on it.

Static Member Functions

These functions work for the class as whole rather than for a particular object of a class.
It can be called using an object and the direct member access . operator. But, its more typical to
call a static member function by itself, using class name and scope resolution :: operator.
For example:
class X
{
public:
static void f()
{
 // statement
}
};

int main()
{
X::f(); // calling member function directly with class name
}
These functions cannot access ordinary data members and member functions, but only static data
members and static member functions.
Pointers to Class Members in C++
Defining a Pointer of Class type
We can define pointer of class type, which can be used to point to class objects.
class Simple
{
public:
int a;
};

int main()
{
Simple obj;
Simple* ptr; // Pointer of class type
ptr = &obj;

cout << obj.a;

cout << ptr->a; // Accessing member with pointer
}
Here you can see that we have declared a pointer of class type which points to class's object. We
can access data members and member functions using pointer name with arrow -> symbol.

Pointer to Data Members of Class

We can use pointer to point to class's data members (Member variables).
Syntax for Declaration :
datatype class_name :: *pointer_name;

Syntax for Assignment :

pointer_name = &class_name :: datamember_name;

Both declaration and assignment can be done in a single statement too.

datatype class_name::*pointer_name = &class_name::datamember_name ;
Using Pointers with Objects
For accessing normal data members we use the dot . operator with object and -> qith pointer to
object. But when we have a pointer to data member, we have to dereference that pointer to get
what its pointing to, hence it becomes,
Object.*pointerToMember
and with pointer to object, it can be accessed by writing,
ObjectPointer->*pointerToMember
Lets take an example, to understand the complete concept.
class Data
{
public:
int a;
void print()
{
cout << "a is "<< a;
}
};

int main()
{
Data d, *dp;
dp = &d; // pointer to object

int Data::*ptr=&Data::a; // pointer to data member 'a'

d.*ptr=10;
d.print();

dp->*ptr=20;
dp->print();
}

a is 10
a is 20
The syntax is very tough, hence they are only used under special circumstances.

Pointer to Member Functions of Class

Pointers can be used to point to class's Member functions.
Syntax:
return_type (class_name::*ptr_name) (argument_type) = &class_name::function_name;
Below is an example to show how we use ppointer to member functions.
class Data
{
public:
int f(float)
{
 return 1;
}
};

int (Data::*fp1) (float) = &Data::f; // Declaration and assignment

int (Data::*fp2) (float); // Only Declaration

int main(0
{
fp2 = &Data::f; // Assignment inside main()
}

Inheritance in C++
Inheritance is the capability of one class to acquire properties and characteristics from another
class. The class whose properties are inherited by other class is called
the Parent or Base or Super class. And, the class which inherits properties of other class is
called Child or Derived or Sub class.
Inheritance makes the code reusable. When we inherit an existing class, all its methods and fields
become available in the new class, hence code is reused.
NOTE: All members of a class except Private, are inherited

Purpose of Inheritance in C++

1. Code Reusability
2. Method Overriding (Hence, Runtime Polymorphism.)
3. Use of Virtual Keyword

Basic Syntax of Inheritance

class Subclass_name : access_mode Superclass_name

While defining a subclass like this, the super class must be already defined or atleast declared
before the subclass declaration.
Access Mode is used to specify, the mode in which the properties of superclass will be inherited
into subclass, public, privtate or protected.

Example of Inheritance
Whenever we want to use something from an existing class in a new class, we can use the
concept on Inheritace. Here is a simple example,
class Animal
{
public:
int legs = 4;
};

// Dog class inheriting Animal class

class Dog : public Animal
{
public:
int tail = 1;
};

int main()
{
Dog d;
cout << d.legs;
cout << d.tail;
}

41

Access Modifiers and Inheritance: Visibility of Class Members

Depending on Access modifier used while inheritance, the availability of class members of Super
class in the sub class changes. It can either be private, protected or public.

1) Public Inheritance
This is the most used inheritance mode. In this the protected member of super class becomes
protected members of sub class and public becomes public.
class Subclass : public Superclass
2) Private Inheritance
In private mode, the protected and public members of super class become private members of
derived class.
class Subclass : Superclass // By default its private inheritance

3) Protected Inheritance
In protected mode, the public and protected members of Super class becomes protected members
of Sub class.
class subclass : protected Superclass

Table showing all the Visibility Modes

Derived Class Derived Class Derived Class

Base class Public Mode Private Mode Protected Mode

Private Not Inherited Not Inherited Not Inherited

Protected Protected Private Protected

Public Public Private Protected

Types of Inheritance in C++

In C++, we have 5 different types of Inheritance. Namely,
1. Single Inheritance
2. Multiple Inheritance
3. Hierarchical Inheritance
4. Multilevel Inheritance
5. Hybrid Inheritance (also known as Virtual Inheritance)

Single Inheritance in C++

In this type of inheritance one derived class inherits from only one base class. It is the most
simplest form of Inheritance.
Multiple Inheritance in C++
In this type of inheritance a single derived class may inherit from two or more than two base
classes.

Hierarchical Inheritance in C++

In this type of inheritance, multiple derived classes inherits from a single base class.
Multilevel Inheritance in C++
In this type of inheritance the derived class inherits from a class, which in turn inherits from
some other class. The Super class for one, is sub class for the other.

Hybrid (Virtual) Inheritance in C++

Hybrid Inheritance is combination of Hierarchical and Mutilevel Inheritance.
Polymorphism in C++
Polymorphism means having multiple forms of one thing. In inheritance, polymorphism is done,
by method overriding, when both super and sub class have member function with same
declaration bu different definition.

Function Overriding in C++

If we inherit a class into the derived class and provide a definition for one of the base class's
function again inside the derived class, then that function is said to be overridden, and this
mechanism is called Function Overriding

Requirements for Overriding a Function

1. Inheritance should be there. Function overriding cannot be done within a class. For this we
require a derived class and a base class.
2. Function that is redefined must have exactly the same declaration in both base and derived
class, that means same name, same return type and same parameter list.

Example of Function Overriding in C++

class Base
{
public:
void show()
{
cout << "Base class";
}
};

class Derived:public Base

{
public:
void show()
{
cout << "Derived Class";
}
}
In this example, function show() is overridden in the derived class. Now let us study how these
overridden functions are called in main() function.

Function Call Binding with class Objects

Connecting the function call to the function body is called Binding. When it is done before the
program is run, its called Early Binding or Static Binding or Compile-time Binding.
class Base
{
public:
void shaow()
{
cout << "Base class\n";
}
};

class Derived:public Base

{
public:
void show()
{
cout << "Derived Class\n";
}
}

int main()
{
Base b; //Base class object
Derived d; //Derived class object
b.show(); //Early Binding Ocuurs
d.show();
}

Base class
Derived class
In the above example, we are calling the overrided function using Base class and Derived class
object. Base class object will call base version of the function and derived class's object will call
the derived version of the function.

Function Call Binding using Base class Pointer

But when we use a Base class's pointer or reference to hold Derived class's object, then Function
call Binding gives some unexpected results.
class Base
{
public:
void show()
 {
cout << "Base class\n";
}
};

class Derived:public Base

{
public:
void show()
{
cout << "Derived Class\n";
}
}

int main()
{
Base* b; //Base class pointer
Derived d; //Derived class object
b = &d;
b->show(); //Early Binding Occurs
}

Base class
In the above example, although, the object is of Derived class, still Base class's method is called.
This happens due to Early Binding.
Compiler on seeing Base class's pointer, set call to Base class's show() function, without
knowing the actual object type.

Virtual Functions in C++

Virtual Function is a function in base class, which is overrided in the derived class, and which
tells the compiler to perform Late Binding on this function.
Virtual Keyword is used to make a member function of the base class Virtual.

Late Binding in C++

In Late Binding function call is resolved at runtime. Hence, now compiler determines the type of
object at runtime, and then binds the function call. Late Binding is also called Dynamic Binding
or RuntimeBinding.

Problem without Virtual Keyword

Let's try to understand what is the issue that virtual keyword fixes,
class Base
{
public:
void show()
{
cout << "Base class";
 }
};

class Derived:public Base

{
public:
void show()
{
cout << "Derived Class";
}
}

int main()
{
Base* b; //Base class pointer
Derived d; //Derived class object
b = &d;
b->show(); //Early Binding Ocuurs
}

Base class
When we use Base class's pointer to hold Derived class's object, base class pointer or reference
will always call the base version of the function

Using Virtual Keyword in C++

We can make base class's methods virtual by using virtual keyword while declaring them.
Virtual keyword will lead to Late Binding of that method.
class Base
{
public:
virtual void show()
{
cout << "Base class\n";
}
};

class Derived:public Base

{
public:
void show()
{
cout << "Derived Class";
}
}

int main()
{
Base* b; //Base class pointer
Derived d; //Derived class object
b = &d;
b->show(); //Late Binding Ocuurs
}

Derived class
On using Virtual keyword with Base class's function, Late Binding takes place and the derived
version of function will be called, because base class pointer pointes to Derived class object.

Using Virtual Keyword and Accessing Private Method of Derived class

We can call private function of derived class from the base class pointer with the help of virtual
keyword. Compiler checks for access specifier only at compile time. So at run time when late
binding occurs it does not check whether we are calling the private function or public function.
#include <iostream>
using namespace std;

class A
{
public:
virtual void show()
{
cout << "Base class\n";
}
};

class B: public A
{
private:
virtual void show()
{
cout << "Derived class\n";
}
};

int main()
{
A *a;
B b;
a = &b;
a->show();
}

Derived class
Mechanism of Late Binding in C++

To accomplich late binding, Compiler creates VTABLEs, for each class with virtual function.
The address of virtual functions is inserted into these tables. Whenever an object of such class is
created the compiler secretly inserts a pointer called vpointer, pointing to VTABLE for that
object. Hence when function is called, compiler is able to resovle the call by binding the correct
function using the vpointer.

Abstract Class and Pure Virtual Function in C++

Abstract Class is a class which contains atleast one Pure Virtual function in it. Abstract classes
are used to provide an Interface for its sub classes. Classes inheriting an Abstract Class must
provide definition to the pure virtual function, otherwise they will also become abstract class.

Characteristics of Abstract Class

1. Abstract class cannot be instantiated, but pointers and refrences of Abstract class type can be
created.
2. Abstract class can have normal functions and variables along with a pure virtual function.
3. Abstract classes are mainly used for Upcasting, so that its derived classes can use its
interface.
4. Classes inheriting an Abstract Class must implement all pure virtual functions, or else they
will become Abstract too.

Pure Virtual Functions in C++

Pure virtual Functions are virtual functions with no definition. They start with virtual keyword
and ends with = 0. Here is the syntax for a pure virtual function,
virtual void f() = 0;

Example of Abstract Class in C++

Below we have a simple example where we have defined an abstract class,
//Abstract base class
class Base
{
public:
virtual void show() = 0; // Pure Virtual Function
};

class Derived:public Base

{
public:
void show()
{
cout << "Implementation of Virtual Function in Derived class\n";
}
};

int main()
{
Base obj; //Compile Time Error
Base *b;
Derived d;
b = &d;
b->show();
}

Implementation of Virtual Function in Derived class

In the above example Base class is abstract, with pure virtual show() function, hence we cannot
create object of base class.

Why can't we create Object of an Abstract Class?

When we create a pure virtual function in Abstract class, we reserve a slot for a function in
the VTABLE(studied in last topic), but doesn't put any address in that slot. Hence the VTABLE
will be incomplete.
As the VTABLE for Abstract class is incomplete, hence the compiler will not let the creation of
object for such class and will display an errror message whenever you try to do so.

Pure Virtual definitions

 Pure Virtual functions can be given a small definition in the Abstract class, which you want
all the derived classes to have. Still you cannot create object of Abstract class.
 Also, the Pure Virtual function must be defined outside the class definition. If you will define
it inside the class definition, complier will give an error. Inline pure virtual definition is
Illegal.
// Abstract base class
class Base
{
public:
virtual void show() = 0; //Pure Virtual Function
};

void Base :: show() //Pure Virtual definition

{
cout << "Pure Virtual definition\n";
}

class Derived:public Base

{
public:
void show()
{
cout << "Implementation of Virtual Function in Derived class\n";
}
};

int main()
{
Base *b;
Derived d;
b = &d;
b->show();
}

Implementation of Virtual Function in Derived class

Operator Overloading in C++

Operator overloading is an important concept in C++. It is a type of polymorphism in which an
operator is overloaded to give user defined meaning to it. Overloaded operator is used to perform
operation on user-defined data type. For example '+' operator can be overloaded to perform
addition on various data types, like for Integer, String(concatenation) etc.
Almost any operator can be overloaded in C++. However there are few operator which can not
be overloaded. Operator that are not overloaded are follows
 scope operator - ::
 sizeof
 member selector - .
 member pointer selector - *
 ternary operator - ?:

Operator Overloading Syntax

Implementing Operator Overloading in C++

Operator overloading can be done by implementing a function which can be :
1. Member Function
2. Non-Member Function
3. Friend Function
Operator overloading function can be a member function if the Left operand is an Object of that
class, but if the Left operand is different, then Operator overloading function must be a non-
member function.
Operator overloading function can be made friend function if it needs access to the private and
protected members of class.

Restrictions on Operator Overloading in C++

Following are some restrictions to be kept in mind while implementing operator overloading.
1. Precedence and Associativity of an operator cannot be changed.
2. Arity (numbers of Operands) cannot be changed. Unary operator remains unary, binary
remains binary etc.
3. No new operators can be created, only existing operators can be overloaded.
4. Cannot redefine the meaning of a procedure. You cannot change how integers are added.

Operator Overloading Examples in C++

Almost all the operators can be overloaded in infinite different ways. Following are some
examples to learn more about operator overloading. All the examples are closely connected.

Overloading Arithmetic Operator in C++

Arithmetic operator are most commonly used operator in C++. Almost all arithmetic operator
can be overloaded to perform arithmetic operation on user-defined data type. In the below
example we have overridden the + operator, to add to Time(hh:mm:ss) objects.

Example: overloading + Operator to add two Time class object

#include <iostream.h>
#include <conio.h>
class Time
{
int h,m,s;
public:
Time()
{
h=0, m=0; s=0;
}
void setTime();
void show()
{
cout<< h<< ":"<< m<< ":"<< s;
}

//overloading '+' operator

Time operator+(time);
};

Time Time::operator+(Time t1) //operator function

{
Time t;
int a,b;
a = s+t1.s;
t.s = a%60;
b = (a/60)+m+t1.m;
t.m = b%60;
t.h = (b/60)+h+t1.h;
t.h = t.h%12;
return t;
}
void time::setTime()
{
cout << "\n Enter the hour(0-11) ";
cin >> h;
cout << "\n Enter the minute(0-59) ";
cin >> m;
cout << "\n Enter the second(0-59) ";
cin >> s;
}

void main()
{
Time t1,t2,t3;

cout << "\n Enter the first time ";

t1.setTime();
cout << "\n Enter the second time ";
t2.setTime();
t3 = t1 + t2; //adding of two time object using '+' operator
cout << "\n First time ";
t1.show();
cout << "\n Second time ";
t2.show();
cout << "\n Sum of times ";
t3.show();
getch();
}
While normal addition of two numbers return the sumation result. In the case above we have
overloaded the + operator, to perform addition of two Time class objects. We add
the seconds, minutes and hour values separately to return the new value of time.
In the setTime() funtion we are separately asking the user to enter the values for hour, minute
and second, and then we are setting those values to the Time class object.
For inputs, t1 as 01:20:30(1 hour, 20 minute, 30 seconds) and t2 as 02:15:25(2 hour, 15 minute,
25 seconds), the output for the above program will be:

1:20:30
2:15:25
3:35:55
First two are values of t1 and t2 and the third is the result of their addition.

Overloading I/O operator in C++

The first question before learning how to override the I/O operator should be, why we need to
override the I/O operators. Following are a few cases, where overloading the I/O operator proves
useful:
 We can overload output operator << to print values for user defined datatypes.
 We can overload output operator >> to input values for user defined datatypes.
In case of input/output operator overloading, left operand will be of
types ostream& and istream&
Also, when overloading these operators, we must make sure that the functions must be a Non-
Member function because left operand is not an object of the class.
And it must be a friend function to access private data members.
You have seen above that << operator is overloaded with ostream class object cout to print
primitive datatype values to the screen, which is the default behavious of << operator, when used
with cout. In other words, it is already overloaded by default.
Similarly we can overload << operator in our class to print user-defined datatypes to screen. For
example we can overload << in our Time class to display the value of Time object
using cout rather than writing a custom member function like show() to print the value
of Time class objects.
Time t1(3,15,48);
// like this, directly
cout << t1;
In the next section we will learn how to do that.
NOTE: When the operator does not modify its operands, the best way to overload the operator is
via friend function.

Example: overloading << Operator to print Class Object

We will now overload the << operator in the Time class,
#include<iostream.h>
#include<conio.h>
class Time
{
int hr, min, sec;
public:
// default constructor
Time()
{
hr=0, min=0; sec=0;
}

// overloaded constructor
Time(int h, int m, int s)
{
hr=h, min=m; sec=s;
}

// overloading '<<' operator

friend ostream& operator << (ostream &out, Time &tm);
};

// define the overloaded function

ostream& operator << (ostream &out, Time &tm)
{
 out << "Time is: " << tm.hr << " hour : " << tm.min << " min : " << tm.sec << " sec";
return out;
}

void main()
{
Time tm(3,15,45);
cout << tm;
}

Time is: 3 hour : 15 min : 45 sec

This is simplied in languages like Core Java, where all you need to do in a class is override
the toString() method of the String class, and you can define how to print the object of that class.

Overloading Relational Operator in C++

You can also overload relational operators like == , != , >= , <= etc. to compare two object of
any class.
Let's take a quick example by overloading the == operator in the Time class to directly compare
two objects of Time class.
class Time
{
int hr, min, sec;
public:
// default constructor
Time()
{
hr=0, min=0; sec=0;
}

// overloaded constructor
Time(int h, int m, int s)
{
hr=h, min=m; sec=s;
}

//overloading '==' operator

friend bool operator==(Time &t1, Time &t2);
};

/*
Defining the overloading operator function
Here we are simply comparing the hour, minute and
second values of two different Time objects to compare
their values
*/
bool operator== (Time &t1, Time &t2)
{
return ( t1.hr == t2.hr && t1.min == t2.min && t1.sec == t2.sec );
}

void main()
{
Time t1(3,15,45);
Time t2(4,15,45);
if(t1 == t2)
{
cout << "Both the time values are equal";
}
else
{
cout << "Both the time values are not equal";
}
}

Both the time values are not equal

As the hour value of object t1 is 3 and for object t2 it is 4, hence they are not equal.

Copy Constructor vs. Assignment Operator (=)

Assignment operator is used to copy the values from one object to another already existing
object. For example:
Time tm(3,15,45); // tm object created and initialized
Time t1; // t1 object created
t1 = tm; // initializing t1 using tm
Whereas, Copy constructor is a special constructor that initializes a new object from an
existing object.
Time tm(3,15,45); // tm object created and initialized
Time t1(tm); //t1 object created and initialized using tm object
In case of Copy constructor, we provide the object to be copied as an argument to the
constructor.

File Handling using File Streams

File represents storage medium for storing data or information. Streams refer to sequence of
bytes. In Files we store data i.e. text or binary data permanently and use these data to read or
write in the form of input output operations by transferring bytes of data. So we use the term File
Streams/File handling. We use the header file <fstream>
 ofstream: It represents output Stream and this is used for writing in files.
 ifstream: It represents input Stream and this is used for reading from files.
 fstream: It represents both output Stream and input Stream. So it can read from files and
write to files.
Operations in File Handling:
 Creating a file: open()
 Reading data: read()
 Writing new data: write()
 Closing a file: close()

Creating/Opening a File
We create/open a file by specifying new path of the file and mode of operation. Operations can
be reading, writing, appending and truncating. Syntax for file
creation: FilePointer.open("Path",ios::mode);
 Example of file opened for writing: st.open("E:\studytonight.txt",ios::out);
 Example of file opened for reading: st.open("E:\studytonight.txt",ios::in);
 Example of file opened for appending: st.open("E:\studytonight.txt",ios::app);
 Example of file opened for truncating: st.open("E:\studytonight.txt",ios::trunc);
#include<iostream>
#include<conio>
#include <fstream>

using namespace std;

int main()
{
fstream st; // Step 1: Creating object of fstream class
st.open("E:\studytonight.txt",ios::out); // Step 2: Creating new file
if(!st) // Step 3: Checking whether file exist
{
cout<<"File creation failed";
}
else
{
cout<<"New file created";
st.close(); // Step 4: Closing file
}
getch();
return 0;
}

Writing to a File
#include <iostream>
#include<conio>
#include <fstream>

using namespace std;

int main()
{
fstream st; // Step 1: Creating object of fstream class
st.open("E:\studytonight.txt",ios::out); // Step 2: Creating new file
if(!st) // Step 3: Checking whether file exist
 {
cout<<"File creation failed";
}
else
{
cout<<"New file created";
st<<"Hello"; // Step 4: Writing to file
st.close(); // Step 5: Closing file
}
getch();
return 0;
}
Here we are sending output to a file. So, we use ios::out. As given in the program, information
typed inside the quotes after "FilePointer <<" will be passed to output file.

Reading from a File

#include <iostream>
#include<conio>
#include <fstream>

using namespace std;

int main()
{
fstream st; // step 1: Creating object of fstream class
st.open("E:\studytonight.txt",ios::in); // Step 2: Creating new file
if(!st) // Step 3: Checking whether file exist
{
cout<<"No such file";
}
else
{
char ch;
while (!st.eof())
{
st >>ch; // Step 4: Reading from file
cout << ch; // Message Read from file
}
st.close(); // Step 5: Closing file
}
getch();
return 0;
}
Here we are reading input from a file. So, we use ios::in. As given in the program, information
from the output file is obtained with the help of following syntax "FilePointer >>variable".
Close a File
It is done by FilePointer.close().
#include <iostream>
#include<conio>
#include <fstream>

using namespace std;

int main()
{
fstream st; // Step 1: Creating object of fstream class
st.open("E:\studytonight.txt",ios::out); // Step 2: Creating new file
st.close(); // Step 4: Closing file
getch();
return 0;
}

Special operations in a File

There are few important functions to be used with file streams like:
 tellp() - It tells the current position of the put pointer.
Syntax: filepointer.tellp()
 tellg() - It tells the current position of the get pointer.
Syntax: filepointer.tellg()
 seekp() - It moves the put pointer to mentioned location.
Syntax: filepointer.seekp(no of bytes,reference mode)
 seekg() - It moves get pointer(input) to a specified location.
Syntax: filepointer.seekg((no of bytes,reference point)
 put() - It writes a single character to file.
 get() - It reads a single character from file.
Note: For seekp and seekg three reference points are passed:
ios::beg - beginning of the file
ios::cur - current position in the file
ios::end - end of the file
Below is a program to show importance of tellp, tellg, seekp and seekg:
#include <iostream>
#include<conio>
#include <fstream>

using namespace std;

int main()
{
fstream st; // Creating object of fstream class
st.open("E:\studytonight.txt",ios::out); // Creating new file
if(!st) // Checking whether file exist
{
 cout<<"File creation failed";
}
else
{
cout<<"New file created"<<endl;
st<<"Hello Friends"; //Writing to file

// Checking the file pointer position

cout<<"File Pointer Position is "<<st.tellp()<<endl;

st.seekp(-1, ios::cur); // Go one position back from current position

//Checking the file pointer position

cout<<"As per tellp File Pointer Position is "<<st.tellp()<<endl;

st.close(); // closing file

}
st.open("E:\studytonight.txt",ios::in); // Opening file in read mode
if(!st) //Checking whether file exist
{
cout<<"No such file";
}
else
{
char ch;
st.seekg(5, ios::beg); // Go to position 5 from begning.
cout<<"As per tellg File Pointer Position is "<<st.tellg()<<endl; //Checking file pointer
position
cout<<endl;
st.seekg(1, ios::cur); //Go to position 1 from beginning.
cout<<"As per tellg File Pointer Position is "<<st.tellg()<<endl; //Checking file pointer
position
st.close(); //Closing file
}
getch();
return 0;
}

New file created

File Pointer Position is 13
As per tellp File Pointer Position is 12
As per tellg File Pointer Position is 5
As per tellg File Pointer Position is 6

Exception Handling in C++

Errors can be broadly categorized into two types. We will discuss them one by one.
1. Compile Time Errors
2. Run Time Errors
Compile Time Errors – Errors caught during compiled time is called Compile time errors.
Compile time errors include library reference, syntax error or incorrect class import.
Run Time Errors - They are also known as exceptions. An exception caught during run time
creates serious issues.
Errors hinder normal execution of program. Exception handling is the process of handling errors
and exceptions in such a way that they do not hinder normal execution of the system. For
example, User divides a number by zero, this will compile successfully but an exception or run
time error will occur due to which our applications will be crashed. In order to avoid this we'll
introduce exception handling technics in our code.
In C++, Error handling is done using three keywords:
 try
 catch
 throw
Syntax:
try
{
//code
throw parameter;
}
catch(exceptionname ex)
{
//code to handle exception
}

try block
The code which can throw any exception is kept inside(or enclosed in) atry block. Then, when
the code will lead to any error, that error/exception will get caught inside the catch block.

catch block
catch block is intended to catch the error and handle the exception condition. We can have
multiple catch blocks to handle different types of exception and perform different actions when
the exceptions occur. For example, we can display descriptive messages to explain why any
particular excpetion occured.

throw statement
It is used to throw exceptions to exception handler i.e. it is used to communicate information
about error. A throw expression accepts one parameter and that parameter is passed to handler.
throw statement is used when we explicitly want an exception to occur, then we can
use throwstatement to throw or generate that exception.

Understanding Need of Exception Handling

Let's take a simple example to understand the usage of try, catch and throw.
Below program compiles successfully but the program fails at runtime, leading to an exception.
#include <iostream>#include<conio.h>
using namespace std;
int main()
{
int a=10,b=0,c;
c=a/b;
return 0;
}
The above program will not run, and will show runtime error on screen, because we are trying
to divide a number with 0, which is not possible.
How to handle this situation? We can handle such situations using exception handling and can
inform the user that you cannot divide a number by zero, by displaying a message.

Using try, catch and throw Statement

Now we will update the above program and include exception handling in it.
#include <iostream>
#include<conio.h>
using namespace std;
int main()
{
int a=10, b=0, c;
// try block activates exception handling
try
{
if(b == 0)
{
// throw custom exception
throw "Division by zero not possible";
c = a/b;
}
}
catch(char* ex) // catches exception
{
cout<<ex;
}
return 0;
}

Division by zero not possible

In the code above, we are checking the divisor, if it is zero, we are throwing an exception
message, then the catch block catches that exception and prints the message.
Doing so, the user will never know that our program failed at runtime, he/she will only see the
message "Division by zero not possible".
This is gracefully handling the exception condition which is why exception handling is used.
Using Multiple catch blocks
Below program contains multiple catch blocks to handle different types of exception in different
way.
#include <iostream>
#include<conio.h>
using namespace std;

int main()
{
int x[3] = {-1,2};
for(int i=0; i<2; i++)
{
int ex = x[i];
try
{
if (ex > 0)
// throwing numeric value as exception
throw ex;
else
// throwing a character as exception
throw 'ex';
}
catch (int ex) // to catch numeric exceptions
{
cout << "Integer exception\n";
}
catch (char ex) // to catch character/string exceptions
{
cout << "Character exception\n";
}
}
}

Integer exception
Character exception
The above program is self-explanatory, if the value of integer in the array x is less than 0, we are
throwing a numeric value as exception and if the value is greater than 0, then we are throwing a
character value as exception. And we have two different catch blocks to catch those exceptions.

Generalized catch block in C++

Below program contains a generalized catch block to catch any uncaught
errors/exceptions. catch(...) block takes care of all type of exceptions.
#include <iostream>
#include<conio.h>
using namespace std;
int main()
{
int x[3] = {-1,2};
for(int i=0; i<2; i++)
{
int ex=x[i];
try
{
if (ex > 0)
throw ex;
else
throw 'ex';
}
// generalised catch block
catch (...)
{
cout << "Special exception\n";
}
}
return 0;
}

Special exception
Special exception
In the case above, both the exceptions are being catched by a single catch block. We can even
have separate catch blocks to handle integer and character exception along with th
generalised catchblock.

Standard Exceptions in C++

There are some standard exceptions in C++ under <exception> which we can use in our
programs. They are arranged in a parent-child class hierarchy which is depicted below:
 std::exception - Parent class of all the standard C++ exceptions.
 logic_error - Exception happens in the internal logical of a program.
o domain_error - Exception due to use of invalid domain.
o invalid argument - Exception due to invalid argument.
o out_of_range - Exception due to out of range i.e. size requirement exceeds allocation.
o length_error - Exception due to length error.
 runtime_error - Exception happens during runtime.
o range_error - Exception due to range errors in internal computations.
o overflow_error - Exception due to arithmetic overflow errors.
o underflow_error - Exception due to arithmetic underflow errors
 bad_alloc - Exception happens when memory allocation with new() fails.
 bad_cast - Exception happens when dynamic cast fails.
 bad_exception - Exception is specially designed to be listed in the dynamic-exception-
specifier.
 bad_typeid - Exception thrown by typeid.