Object-Oriented Programming (C++)

Contents

• Phase 1.1 — Topic Frequency & Weightage Table
• Phase 1.2 — Repeated & Predicted Questions
• Phase 1.3 — High-Yield Notes (All Topics)
• Phase 1.4 — Common Pitfalls Table
• Phase 2 — Master MCQ Bank with Explanations

Phase 1.1 — Topic Frequency & Weightage Breakdown

Based on question-count analysis across Sections A, B and C of the August 2018, December 2018, August 2019, May/June 2022, April/May 2023, June/July 2024, September 2024 and January 2025 COMP 116 papers.

#	Topic	Approx. Weightage	Priority	Where it shows up
1	Inheritance (types, access specifiers, virtual base class, diamond problem, ctor/dtor order)	~20%	TIER 1	Sec A (every paper, 2–4 Qs), Sec B, Sec C long programs
2	Constructors & Destructors (types, copy ctor, initialization, order of calls)	~15%	TIER 1	Sec A every paper, Sec B theory Q, Sec C programs
3	Virtual Functions / Pure Virtual / Abstract Classes / Runtime Polymorphism	~13%	TIER 1	Sec A, Sec C — the "big program" question almost every year
4	Operator Overloading (rules, friend-based, unary ++/--)	~13%	TIER 1	Sec A, Sec B/C program question (very frequent)
5	Templates (function template, class template, generic programming)	~10%	TIER 2	Sec A, Sec B (near-guaranteed 4-mark question)
6	Exception Handling (try/catch/throw, rethrow)	~8%	TIER 2	Sec A, Sec B short note
7	Friend Functions	~7%	TIER 2	Sec A, used inside operator overloading answers
8	Static Data Members / Static Functions	~6%	TIER 2	Sec A, occasional Sec B program
9	Core OOP Pillars (Encapsulation, Abstraction, Data Hiding, Composition)	~5%	TIER 2	Sec A conceptual MCQs, Sec B intro question
10	Function Overloading vs Function Overriding	~3%	TIER 3	Sec A, occasional Sec C "differentiate" sub-part
11	Inline Functions	~3%	TIER 3	Sec A, Sec B short question
12	References vs Pointers, pass-by-reference	~2%	TIER 3	Sec A
13	new/delete operator, dynamic memory	~2%	TIER 3	Sec A, Sec B short note

Phase 1.2 — Most Repeated Questions & High-Probability Predictions

A. Verbatim / Rephrased Recurring Questions (appeared in 3+ papers)

Recurring Question Pattern	Seen In	Marks
"Create a class hierarchy: base class + 2 derived classes + 1 further-derived class. Implement runtime polymorphism using virtual functions, with data stored in an array of objects." (Province / Publication–Book–Tape / Food–TableInfo–BillAmount / ReferenceBook–IssuableBook / Digital Wallet / Employee–HOD)	2019, 2022, 2023, 2024(Sept)	8
"Explain the rules of constructor calls in inheritance. How is a base class data member initialized from a derived class constructor?"	2018, 2019, 2022, 2023, 2025	2–4
"Write a program to overload the (unary ++/-- or binary +) operator using a friend function."	2018, 2019, 2022, 2023, 2025	4–8
"Write a class/function template that returns the largest and/or average value of elements in an array."	2018, 2019, 2022, 2023, 2024	4
"What is a pure virtual function? What are the implications of making a function pure virtual? / What is an abstract class?"	2018, 2022, 2023, 2024(Sept)	2–4
"Differentiate between virtual base class and virtual function." / "What sort of ambiguity is solved by virtual base class? Explain with diagram." (Diamond problem)	2018, 2022, 2023	4–8
"Write short notes on (choose 2): Re-throwing an exception / new-delete operator / reference variable / friend function / abstract class"	2018, 2019, 2022, 2025	4
"Write in brief about static data member and static member function of a class." / "Implement a static counter that assigns a serial number to each object created."	2018, 2022, 2024	4
"Differentiate Object-Oriented Programming with Structured/Procedural Programming."	2019, 2022, 2024, 2025	2–4
"Explain the two levels of access control/specifiers over class members in inheritance."	2018, 2019, 2023, 2024	4

B. High-Probability Predicted Questions for the Next Exam

Phase 1.3 — In-Depth High-Yield Notes

1. Core OOP Pillars

Concept	Definition
Encapsulation	Binding data + functions that operate on that data into a single unit (class), restricting direct access to internal state.
Abstraction	Showing only essential features while hiding implementation/background details (e.g., pure virtual functions, abstract classes).
Inheritance	Mechanism where a new class (derived) acquires properties/behavior of an existing class (base) — enables code reusability.
Polymorphism	"Many forms" — same interface, different implementations. Compile-time (function/operator overloading) vs Run-time (virtual functions).
Composition	"Has-a" relationship — one class contains an object of another class as a member (object inside object).

2. Constructors & Destructors

class A {
  int x;
public:
  A() { x = 0; }              // default constructor
  A(int v) { x = v; }         // parameterized
  A(const A &obj) { x = obj.x; } // copy constructor
  ~A() { }                    // destructor
};

Constructor call order in inheritance: Base class constructor is called first (in the order of declaration/inheritance), then the derived class constructor. Virtual base class constructors are called before any non-virtual base classes, regardless of inheritance order.

Initializing base class data via derived constructor — use the member-initializer list:

class Derived : public Base {
public:
  Derived(int a, int b) : Base(a) { // Base(a) initializes base part
     y = b;
  }
};

Destructor call order: exactly reverse of constructor order — derived class destructor runs first, then base class destructor(s).

Copy constructor pitfall: the compiler-generated (default) copy constructor does a shallow copy. If a class has a pointer data member (e.g., dynamically allocated array), shallow copy makes two objects point to the same memory — a deep copy (user-defined copy constructor) is required.

3. Inheritance

Access Specifier of Inheritance	Public members of Base become	Protected members of Base become	Private members of Base
class D : public B	Public in D	Protected in D	Inherited but inaccessible directly
class D : protected B	Protected in D	Protected in D	Inherited but inaccessible directly
class D : private B (default for class)	Private in D	Private in D	Inherited but inaccessible directly

Types of inheritance: Single, Multilevel, Multiple, Hierarchical, Hybrid.

Diamond Problem: occurs in multiple/hybrid inheritance when two base classes inherit from the same grandparent, and a class inherits from both — the grandparent's members get duplicated ("ambiguity"). Solved using a virtual base class:

class Person { };
class Account : virtual public Person { };
class Admin   : virtual public Person { };
class Master  : public Account, public Admin { }; // only ONE copy of Person

With a virtual base class, its constructor is invoked only once, and it is called by the most-derived class — not by the intermediate classes.

4. Virtual Functions, Pure Virtual Functions & Abstract Classes

class Shape {              // abstract class
public:
  virtual float area() = 0; // pure virtual function
};
class Circle : public Shape {
  float r;
public:
  Circle(float rad): r(rad) {}
  float area() override { return 3.14*r*r; }
};
int main(){
  Shape *s = new Circle(5);  // base ptr -> derived obj
  cout << s->area();         // runtime polymorphism
}

Static (early) binding = function call resolved at compile time (normal function calls, overloading). Dynamic (late) binding = resolved at run time via virtual functions and base class pointers.

5. Operator Overloading

Giving additional/special meaning to existing C++ operators for user-defined types. Can be done as a member function or a friend function.

Aspect	Member Function	Friend Function
Argument count for binary op	1 explicit argument (left operand is this)	2 explicit arguments (one more than member function)
Access	Direct access to private members	Needs friend declaration to access private members
When required	Left operand must be an object of the class	Useful when left operand is NOT of the class type (e.g., 5 + obj)

class Point {
  int x, y;
public:
  Point(int a=0,int b=0):x(a),y(b){}
  friend Point operator+(const Point &p1, const Point &p2){
     return Point(p1.x+p2.x, p1.y+p2.y);
  }
  // Prefix ++ (member): Point operator++();
  // Postfix ++ (member): Point operator++(int); // dummy int marks postfix
};

Operators that CANNOT be overloaded: :: (scope resolution), . (member access), .* (pointer-to-member), ?: (conditional/ternary), sizeof.

6. Templates (Generic Programming)

Templates let you write a single function/class that works with any data type — achieving generic programming.

template<class T>
T maxVal(T a, T b){
  return (a > b) ? a : b;
}
// Multiple template parameters:
template<class T1, class T2>
void show(T1 a, T2 b){ cout<<a<<" "<<b; }

template<class T>
class Box {
  T value;
public:
  void set(T v){ value = v; }
  T get(){ return value; }
};
// defining member function OUTSIDE the class:
template<class T>
void Box<T>::set(T v){ value = v; }

7. Exception Handling

try {
   if(x==0) throw runtime_error("divide by zero");
}
catch(runtime_error &e){
   cout<<e.what();
   throw; // re-throw: passes the SAME exception up to an outer handler
}

Rethrowing: done using the bare keyword throw; (no operand) inside a catch block — it forwards the currently-caught exception to an outer/enclosing try-catch block instead of handling it locally.

To catch a thrown C-string literal, the catch clause must match its exact type: catch(const char *s).

8. Friend Functions

A friend function is not a member of the class but is granted access to its private and protected members. Declared inside the class with the friend keyword but defined outside (no scope-resolution operator needed since it isn't a member).

9. Static Data Members & Static Functions

class Counter {
  static int count;      // declaration inside class
public:
  Counter(){ count++; }
  static int getCount(){ return count; } // static member fn
};
int Counter::count = 0;  // definition OUTSIDE class — mandatory
// Access: Counter::getCount();  (no object needed)

A static member function can only directly access other static members of the class (it has no this pointer).

10. Function Overloading vs Overriding

Function Overloading	Function Overriding
Same function name, different parameter list, same class	Same function signature, redefined in derived class
Compile-time (static) polymorphism	Run-time (dynamic) polymorphism — needs virtual

11. Inline Functions

Requested with the inline keyword; the compiler replaces the function call with the function body directly (like a macro), avoiding call-overhead. Faster execution, but larger compiled program size (more memory). Best for small, frequently-used functions — not recommended for large/complex functions with loops or recursion (compiler will usually ignore the request).

Phase 1.4 — Common Pitfalls Table

Mistake	Why Marks Are Lost	Exact Fix
Forgetting the member-initializer list when a base class needs arguments in its constructor	Program won't compile if base class has no default constructor	Always write Derived(args): Base(args) { ... }
Declaring destructor as ~ClassName(int) or giving it a return type	Destructors can never take arguments or return a value — this is a syntax error	Use exactly ~ClassName(){ }
Overloading operator as a member function when the left operand isn't an object of the class	Compiler cannot resolve 5 + obj using a member function	Use a friend function with 2 explicit parameters
Missing virtual keyword on base class function meant to be overridden	Causes static binding → wrong function called via base pointer (loses all runtime-polymorphism marks)	Always mark the base function virtual; use = 0 for pure virtual
Trying to instantiate an abstract class directly	Compile error — abstract classes cannot be instantiated	Only create objects of the fully-derived (non-abstract) class
Diamond inheritance without virtual on the shared base	Grandparent class gets duplicated → ambiguous member access error	Inherit the common base as virtual public Base in both intermediate classes
Defining the static member variable only inside the class	Linker error: "undefined reference" — declaration inside class isn't a definition	Add int ClassName::staticVar = 0; outside the class, once
Forgetting to define the copy constructor for a class with pointer members	Shallow copy → double-free / dangling pointer crash, loses "deep copy" marks	Write a custom copy constructor that allocates new memory and copies values
Postfix vs prefix operator overload signature confusion	Examiner explicitly checks the int dummy parameter for postfix	Prefix: operator++(). Postfix: operator++(int)
Writing template function definitions inside .cpp without template<class T> repeated before each out-of-class definition	Linker/compiler error — every template member definition needs its own template header	Repeat template<class T> ReturnType ClassName<T>::func(){} for every method
Catching exceptions by value for large/user objects instead of by reference	Unnecessary copy overhead; slicing problem for polymorphic exception hierarchies	Prefer catch(const ExceptionType &e)
Confusing "rethrow" with throwing a brand-new exception	Loses marks for not understanding that bare throw; preserves the original exception	Use plain throw; (no operand) inside the catch block to rethrow
Not answering the "differentiate" sub-parts with a two-column comparison	Markers award partial credit per point of distinction — a paragraph answer loses these discrete points	Always answer differentiate/compare questions in a two-column table format

Phase 2 — Master MCQ Practice Bank

All questions are drawn from or adapted from the 8 analyzed past papers, grouped by topic, with the correct option highlighted and a full explanation beneath each card.

Topic: Core OOP Concepts

Topic: Constructors & Destructors

Topic: Inheritance

Topic: Virtual Functions, Polymorphism & Abstract Classes

Topic: Operator Overloading

Topic: Templates / Generic Programming

Topic: Exception Handling

Topic: Friend Functions & Static Members

Topic: References, Overloading vs Overriding, Inline & Misc.