OOP & C++ Cheat Sheet

The four OOP pillars — quick reference

Classes & access specifiers

class Student {
private:
    int rollNo;          // accessible only inside the class
protected:
    string name;          // accessible inside class + derived classes
public:
    int marks;            // accessible from anywhere
};

By default, class members are private; struct members are public — this default-access difference is a common trap question.

Constructors & destructors

class Point {
    int x, y;
public:
    Point() : x(0), y(0) {}                  // default constructor, initializer list
    Point(int a, int b) : x(a), y(b) {}       // parameterized constructor
    Point(const Point &p) : x(p.x), y(p.y) {} // copy constructor
    ~Point() {}                               // destructor
};

Construction/destruction order in inheritance

Construction order: Base class constructor  → Derived class constructor
Destruction order:  Derived class destructor → Base class destructor

(Destructor order is always the reverse of constructor order.)

The this pointer

class Box {
    int side;
public:
    Box(int side) {
        this->side = side;  // disambiguates member vs parameter with the same name
    }
    Box& setSide(int s) {
        this->side = s;
        return *this;       // enables method chaining: box.setSide(1).setSide(2);
    }
};

this is a pointer to the calling object, implicitly passed to every non-static member function.

Static members

class Counter {
public:
    static int count;   // declaration
    Counter() { count++; }
};
int Counter::count = 0;  // definition, required outside the class

Inheritance types

Effect of inheritance access specifier

The diamond problem

       A
      / \
     B   C
      \ /
       D

D inherits from both B and C, which both inherit from A.
D ends up with TWO copies of A's members — ambiguous.

Fix: virtual inheritance
   class B : virtual public A {};
   class C : virtual public A {};
   → D now gets only ONE shared copy of A.

Polymorphism — compile-time vs runtime

Function overloading

void print(int x);
void print(double x);
void print(string x);
// Same name, different parameter list — resolved at compile time

Virtual functions & the vtable

class Shape {
public:
    virtual void draw() { cout << "Shape"; }   // virtual — enables runtime polymorphism
};
class Circle : public Shape {
public:
    void draw() override { cout << "Circle"; } // overrides base version
};

Shape* s = new Circle();
s->draw();  // prints "Circle" — decided at RUNTIME via the vtable, not compile time

Without virtual, s->draw() would call Shape::draw() based on the pointer's declared type, not the object's actual type — this is the single most commonly tested OOP concept on CCAT.

Pure virtual functions & abstract classes

class Shape {
public:
    virtual void draw() = 0;  // pure virtual — makes Shape an ABSTRACT class
};
// Shape s;        // ERROR — cannot instantiate an abstract class
// Shape* s = new Circle(); // OK — pointer/reference to abstract class is fine

A class with at least one pure virtual function cannot be instantiated directly; any derived class MUST override it to become concrete (instantiable).

Virtual destructors — a critical exam trap

class Base {
public:
    virtual ~Base() {}   // MUST be virtual if the class will be used polymorphically
};
class Derived : public Base {
public:
    ~Derived() { /* cleanup */ }
};

Base* b = new Derived();
delete b;  // Without a virtual destructor, only ~Base() runs — Derived's cleanup is SKIPPED (memory/resource leak)

Operator overloading

class Complex {
    int real, imag;
public:
    Complex(int r, int i) : real(r), imag(i) {}
    Complex operator+(const Complex &c) {
        return Complex(real + c.real, imag + c.imag);
    }
};
Complex c3 = c1 + c2;  // calls operator+ automatically

Operators that CANNOT be overloaded

::   (scope resolution)
.    (member access)
.*   (pointer-to-member access)
?:   (ternary/conditional)
sizeof
typeid

Friend functions & friend classes

class Box {
    int width;
public:
    Box(int w) : width(w) {}
    friend void printWidth(Box b);  // friend function — NOT a member, but has private access
};

void printWidth(Box b) {
    cout << b.width;  // allowed, because printWidth is declared a friend
}

A friend function is not a member of the class (no this pointer, not inherited, not affected by access specifiers itself) but can access the class's private and protected members.

Templates — generic programming

// Function template
template <typename T>
T maxVal(T a, T b) {
    return (a > b) ? a : b;
}
maxVal(3, 7);       // T deduced as int
maxVal(3.5, 2.1);   // T deduced as double

// Class template
template <typename T>
class Stack {
    T arr[100];
    int top = -1;
public:
    void push(T x) { arr[++top] = x; }
    T pop() { return arr[top--]; }
};
Stack<int> intStack;
Stack<string> strStack;

Templates enable compile-time generic programming — one code definition, many types, with no runtime overhead (unlike, say, Java generics with type erasure).

Exception handling

try {
    int arr[5];
    int idx = 10;
    if (idx >= 5) throw out_of_range("Index out of bounds");
    arr[idx] = 1;
} catch (const out_of_range &e) {
    cout << "Caught: " << e.what();
} catch (...) {
    cout << "Unknown exception";  // catch-all handler
}

Multiple catch blocks are checked top to bottom — order matters. A catch(...) block must come last, or it will swallow every exception before more specific handlers get a chance.

Memory management — new/delete

int* p = new int(5);      // allocate single int on heap
delete p;                 // deallocate

int* arr = new int[10];   // allocate array on heap
delete[] arr;             // MUST use delete[] for arrays, not delete

STL — quick container reference

CDAC C-CAT — top OOP/C++ exam traps

PYQs are indicative of exam style, not guaranteed exact repeats.