OOP CheatSheet

A collection of the main concepts behind OOP in brief

Definition

OOP refers to a programming methodology/paradigm based on classes and their instances,

called objects. Classes contain data members (variables) and member functions, which can be
accessed through objects.

Access Specifiers
Public Members are accessible from outside the class
Private Members cannot be accessed from outside the class
Protected Like private, except members can be accessed in friend/inherited classes

Four Pillars of OOP

Encapsulation
Encapsulation is defined as wrapping up related data and functions that operate on them under
a single unit, thereby providing: (a) security in the form of data hiding and (b) making the code
more readable and reusable in the long run.

Example: Departments within a company can have their own implementation of a generic parent
Department() class, making each department’s data hidden from the others, unless accessed
by an object of that class. Now there may arise a situation when for some reason an official from
one dept. X needs all the data about some other dept. Y in a particular month. In this case, X is
not allowed to directly access the data of the Y section. Thus, X will first have to contact some
other officer in the Y dept. and then request him to give the particular data.

Abstraction
Abstraction means displaying only essential information and hiding the details. Data abstraction
refers to providing only essential information about the data to the outside world, hiding the
background details or implementation. Abstraction is achieved in C++ in two ways:

● Abstraction using Classes: We can implement Abstraction in C++ using classes. The
class helps us to group data members and member functions using available access
 specifiers. A Class can decide which data member will be visible to the outside
world(public) and which is not(private).
● Abstraction in Header files: Not essentially a feature of OOP, because this has been
there since before OOP was introduced, but still very useful in achieving encapsulation.

Polymorphism
Ability to take more than one form is called polymorphism. In an OOP environment, an
operation may exhibit different behaviours in different instances. The behaviour depends upon
the types of data used in the operation/passed as argument. C++ supports Operator
Overloading and Function Overloading.

Operator Overloading
In C++, can be done by using operator keyword followed by operator_name.

Example
Consider the Complex Class, shown below:
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i =0) { //Constructor
real = r; imag = i;
}
void print() {
cout << real << " + i" << imag << endl;
}
};

Now, if we want to add two complex numbers, we cannot use the + operator as-is, because the
compiler does not know how complex numbers work. Hence, we must overload the ‘+’ Operator
as shown:
Complex operator + (Complex const &obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
//if we have c1 and c2, and we do c1 + c2, c1 is res and c2 is obj
Operators which cannot be overloaded:
. : Dot Operator
:: : Scope resolution
?: : Conditional operator
sizeof : Get size

Function Overloading
Function overloading is when two or more functions can have the same name but accept
different parameters. The function can perform different operations and hence it eliminates the
use of different function names for the same kind of operations.

Note
Function overloading (achieved in compile time) is different from Function Overriding (achieved
at run time). Function Overriding is the redefinition of a base class function in its derived class
with the same signature i.e return type and parameters.

Inheritance
Inheritance is a mechanism in which one object acquires all the properties and behaviors of a
parent class, in addition to the already existing members of that class. The idea behind
inheritance is that we can create new classes that are built upon existing classes.

Modes of Inheritance
● Public mode: If we derive a subclass from a public base class.
○ Public(BaseClass) := Public(Subclass)
○ Protected (BaseClass) := Protected (Subclass)

● Protected mode: If we derive a subclass from a Protected base class.

○ Public(BaseClass) := Protected (Subclass)
○ Protected (BaseClass) := Protected (Subclass)

● Private mode: If we derive a subclass from a Private base class.

○ Public(BaseClass) := Private(Subclass)
○ Protected (BaseClass) := Private(Subclass)
Types of Inheritance
Single, Multiple(single subclass inherits from multiple base classes), Multi-level, Hierarchical
(Multiple subclass are derived from single base class), and Hybrid.

Friend Classes and Functions

Friend Class
A friend class can access private and protected members of another class in which it is declared
as friend. For example, a LinkedList class may be allowed to access private members of Node.

class Node {
private:
int key;
Node* next;
// Now class LinkedList can access private members of Node
friend class LinkedList;
};

Friend Function
Like friend class, a friend function can be given a special grant to access private and protected
members. A friend function can be:
● A member of another class or
● A global function

class Node {
private:
int key;
Node* next;
/* makes search() of LinkedList class a friend function */
friend int LinkedList::search();
};

Note
● Friendship is not mutual. If class A is a friend of B, then B doesn’t become a friend of A.
● Friendship is not inherited.
● If too many functions or external classes are declared as friends of a class with protected
or private data, it lessens the value of encapsulation.
Virtual Functions
A virtual function is a member function which is declared within a base class using the virtual
keyword. It may be re-defined(overridden) by a derived class as well.

Example: Class Car may have some method openDoor which can be overridden in some
sub-class SuperCar. In that case, we have to make openDoor a virtual function in Car

● Thus, upon referring to a derived class object using a pointer or a reference to the base
class, you can call a virtual function for that object and execute the derived class’s
version of the function.
● Thus, virtual functions ensure that the correct function is called for an object, regardless
of the type of reference (or pointer) used for function call. Since the resolving of function
calls is done at run-time, virtual functions are mainly used to achieve runtime
polymorphism.

To achieve run-time polymorphism using virtual functions, there are some caveats:

I. Virtual functions should be accessed using pointer or reference of base class type to
achieve runtime polymorphism.
II. Virtual functions cannot be static.
III. The prototype of virtual functions should be the same in the base as well as derived
class.
IV. A class may have a virtual destructor but it cannot have a virtual constructor.

How do virtual functions achieve late binding?

Consider a Parent class and a Child class, which is derived from Parent. The compiler
maintains two things to serve this purpose:
● vtable: A table of virtual function pointers, maintained per class.
● vptr: A pointer to vtable, maintained per object instance.
Compiler adds additional code at two places to maintain and use vptr.
1. Code in every constructor This code sets the vptr of the object being created. This
code sets vptr to point to the vtable of the class.
2. Code with polymorphic function call Wherever a polymorphic call is made, the
compiler inserts code to first look for vptr using base class pointer or reference (Since
pointed or referred object is of derived type, vptr of derived class is accessed). Once
vptr is fetched, vtable of the derived class can be accessed. Using vtable, the
address of the derived class function is accessed and called.

Pure Virtual Functions virtual pureVirtualFunction_name()=0

A pure virtual function is implemented by classes which are derived from an Abstract class.
Abstract Classes
A class is abstract if it has at least one pure virtual function. Sometimes implementation of a
function cannot be provided in a base class because there may not exist a generic
implementation, in that case, we have to declare that function as pure virtual in the base
class. Such a class is called an abstract class.

Constructors and Destructors

Constructors are special class functions which perform 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, when it goes out of scope.

Constructors
Syntax: ClassName()

The name of the constructor is the same as the name of the class, and constructors don’t have
a return type. Constructors can be defined either inside the class definition or outside class
definition using class name and scope resolution :: operator. Constructors can be
overloaded as well, as long each definition takes in different arguments.

Constructors are of three types:

1. Default : If not specified explicitly, added by the compiler.
2. Parameterized : When some arguments are passed to the constructor.
3. Copy : Takes reference to an object of the same class as an argument.

Important:
Why should the copy constructor accept its parameter by reference in C++?
Because if it's not by reference, it's by value. To do that we again have to make a copy, and to
do that we call the copy constructor. But to do that, we need to make a new value, so we call the
copy constructor again, thus leading to an infinite chain of recursive calls.

Can a constructor be virtual?

The virtual mechanism works only when we have a base class pointer to a derived class object.
In C++, the constructor cannot be virtual, because when a constructor of a class is executed
there is no virtual table in the memory, meaning no virtual pointer has been defined yet. So, the
constructor should always be non-virtual. But virtual destructors are possible.
Destructors
Syntax: ~ClassName()

Destructor is a member function which destructs or deletes an object. Destructor function is

automatically invoked when the objects are destroyed(the function ends or the program ends or
a block containing local variables ends or a delete operator is called). It cannot be declared
static or const. The destructor does not have arguments. It has no return type, not even void.
An object of a class with a Destructor cannot become a member of any union. A destructor
should be declared in the public section of the class.

What is the order in which constructors and destructors are invoked?

The constructors of inherited classes are called in the same order in which they are inherited
i.e., from base to derived. Destructors, on the other hand, are invoked in the reverse order, i.e.,
from derived to base.

Diamond Problem
The diamond problem occurs when two superclasses of a class have a common base class.
Consider the following case, where both B and C are derived from A, and D inherits from both B
and C:

A common example illustrating this is shown below:

class Person {
public:
Person(int x) { cout << "Person::Person(int ) called" << endl; }
};

class Faculty : public Person {

public:
Faculty(int x):Person(x) {
 cout<<"Faculty::Faculty(int ) called"<< endl;
}
};

class Student : public Person {

public:
Student(int x):Person(x) {
cout<<"Student::Student(int ) called"<< endl;
}
};

class TA : public Faculty, public Student {

public:
TA(int x):Student(x), Faculty(x) {
cout<<"TA::TA(int ) called"<< endl;
}
};

A A
| |
B C
\ /
D

In the above program, when some object of class TA will be instantiated, constructor of Person
is called two times. Similarly, Destructor of Person will also be called two times. So all objects
of class TA have two copies of all members of Person, thus causing ambiguities.

The solution to this problem is the ‘virtual’ keyword. We make the classes ‘Faculty’ and ‘Student’
as virtual base classes to avoid two copies of ‘Person’ in ‘TA’ class.

class Student : virtual public Person

/.../
class Faculty : virtual public Person
A
/ \
B C
\ /
D

Virtual inheritance means that there will be a single instance of the base A, regardless of how
many paths there are. This excellent S/O answer explains the reason behind this really well.
Deep Copy & Shallow Copy
In general, creating a copy of an object means to create an exact replica of the object having
the same literal value, data type, and resources. Depending upon the resources like dynamic
memory (allocated in heap) held by the object, either we need to perform Shallow Copy or Deep
Copy in order to create a replica of the object. In general, if the variables of an object have been
dynamically allocated then it is required to do a Deep Copy in order to create a copy of the
object.

Shallow Copy
In shallow copy, an object is created by simply copying the data of all variables of the original
object. C++ compiler implicitly creates a copy constructor and overloads the assignment
operator in order to perform shallow copy at compile time, as shown:

className O1 {
int a, b;
int *p;
};
//Copy Constructor
ClassName O2 = O1;
//Assignment Operator Overloading
ClassName O3;
O3 = O1;

This works well if none of the variables of the object are defined in the heap section of memory.
If some variables are dynamically allocated memory from the heap section, then the copied
object variable will also reference the same memory location which will create ambiguity and
run-time errors, since change made by one will be reflected in all other objects that copied the
data item from it as well. These problems can be avoided if we explicitly implement Deep Copy.

Deep Copy
In Deep copy, an object is created by copying data of all variables and it also allocates similar
memory resources with the same value to the object. In order to perform Deep copy, we need to
explicitly define the copy constructor and assign dynamic memory as well if required. Also, it is
required to dynamically allocate memory to the variables in the other constructors, as well.
className(className &obj) {
a = obj.a; b = obj.b;
p = new int;
*p = *(obj.p); //Deep Copy
}
Exception Handling
Exceptions are run-time anomalies or abnormal conditions that a program encounters during its
execution. There are two types of exceptions: a) Synchronous, b) Asynchronous (which are
beyond the program’s control, e.g, disc failure etc). C++ provides the following specialized
keywords for this purpose.
● try: represents a block of code that can throw an exception.
● throw: Used to throw an exception.
● catch: represents a block of code that is executed when a particular exception is thrown.
try and catch blocks work together: we use the try block to test some code, and if the exception
condition is satisfied, we throw the value that caused that error. The catch block then catches
that error(by taking it as an argument) and executes the catch block pertaining to that argument.
As a consequence, If no error occurs, the catch block is skipped.
try {
if (x < 0) {
throw x;
}
}
catch (int x) {
cout << "Exception Caught \n";
}
Important points about Exception Handling
There is a special catch block called catch all catch(...) that can be used to catch all types of
exceptions. An example is shown below, where since there is no catch block pertaining to int
specifically, the catch all block is executed.

int main()
{
try {
throw 10;
}
catch (char *excp) {
cout << "Caught " << excp;
}
catch (...) {
cout << "Default Exception\n";
}
return 0;
}

One more thing to note is that Implicit type conversion doesn’t happen for primitive types.
Also, If an exception is thrown and not caught anywhere, the program terminates abnormally.