C++ OOPS for Interviews

Build a strong OOPs foundation by mastering how classes are defined, objects are created, and members are accessed in C++.

• Class definition — syntax for declaring member variables and member functions together

• Object creation on stack vs heap — local instantiation vs dynamic allocation with new

• Dot operator — accessing members through a directly declared object variable

• Arrow operator (->) — accessing members through a pointer to an object

• Default access modifier — class members are private by default, struct members are public

• Stack vs heap lifetime — stack objects destroyed when scope ends, heap requires explicit delete

Master the full lifecycle of C++ objects — from initialization strategies to destruction order and the critical difference between shallow and deep copy.

• Default constructor — compiler-generated when no constructor is defined, initializes no members

• Parameterized constructor — accepts arguments to initialize members with specific values

• Copy constructor — creates a new object as a copy of an existing one

• Shallow copy — copies pointer addresses, both objects share the same memory location

• Deep copy — allocates new memory and duplicates the data, prevents double-free crashes

• Destructor syntax — ~ClassName() called automatically when object goes out of scope

• Constructor and destructor order — base constructor runs first, base destructor runs last

• Rule of Three — if a class needs a custom destructor, it likely needs copy constructor and copy assignment too

Design secure, well-structured classes by controlling data access and separating interface from implementation.

• private — restricts member access to within the class only, default for class members

• public — makes members accessible from anywhere outside the class

• protected — accessible within the class and by derived classes but not outside

• Getters and setters — accessor methods that safely read and write private attributes

• Implementation hiding — exposing only what the caller needs, concealing internal logic

• Preventing invalid state — setters can validate input before modifying private data

Understand how C++ models real-world relationships through inheritance — including access control, constructor order, and the diamond problem.

• Single inheritance — derived class inherits from one base class

• Multiple inheritance — derived class inherits from two or more base classes

• Multilevel inheritance — chain of inheritance across three or more levels

• Hierarchical inheritance — multiple derived classes inherit from a single base class

• Public inheritance — public and protected members of base remain accessible in derived

• Constructor execution order — base class constructor runs before derived class constructor

• Diamond problem — ambiguity when two base classes share a common ancestor

• Virtual base classes — solving the diamond problem by ensuring only one copy of the shared ancestor

Master both forms of C++ polymorphism — compile-time through overloading and runtime through virtual functions and dynamic dispatch.

• Function overloading — same function name with different parameter types or counts, resolved at compile time

• Function overriding — derived class redefines a base class virtual function, resolved at runtime

• Early binding (static) — function call resolved at compile time based on declared type

• Late binding (dynamic) — function call resolved at runtime based on actual object type

• Base class pointer to derived object — polymorphic behavior requires virtual functions

• Object slicing — assigning a derived object to a base object by value strips derived members

• Overloading vs overriding — different scope (same class) vs different class hierarchy level

Design flexible, extensible systems using abstract classes and pure virtual functions to define contracts without implementation.

• Abstract class — contains at least one pure virtual function, cannot be instantiated directly

• Pure virtual function — virtual void func() = 0; forces derived classes to provide an implementation

• Interface in C++ — abstract base class with only pure virtual functions and no data members

• Concrete class — a derived class that implements all pure virtual functions of its base

• Instantiation restriction — attempting to create an abstract class object causes a compile error

• Abstraction benefit — hides complex implementation details, exposes only essential behavior

Understand class-level constructs — when to grant external access using friend and how static members behave across all instances.

• Friend function — declared with the friend keyword, can access private and protected members from outside the class

• Friend class — grants all member functions of one class access to private members of another

• Static data member — shared across all instances, exists independently of any object

• Static member function — called on the class itself, not an instance, has no this pointer

• Static function limitation — can only access static data members and other static functions

• Encapsulation trade-off — friend functions break strict encapsulation, use only when necessary

Extend built-in operators to work with user-defined types — enabling intuitive syntax for custom classes.

• Operator overloading syntax — operator keyword followed by the symbol being overloaded

• Overloadable operators — most operators can be overloaded except ::, .*, ., and ?:

• Prefix increment overload — returns reference to the incremented object for chaining

• Postfix increment overload — takes dummy int parameter, returns copy of original value

• Binary operator as member function — left operand is the implicit this object

• Binary operator as friend function — both operands passed explicitly, used for symmetry

• Return by value vs reference — return by reference enables chaining, return by value for temporaries

• Self-assignment check — always verify this != &other in copy assignment operator

Deeply understand the internal mechanism behind runtime polymorphism — V-Tables, virtual pointers, virtual destructors, and object slicing.

• virtual keyword — declares a function eligible for runtime dispatch based on actual object type

• V-Table (vtable) — compiler-generated table of function pointers, one per class with virtual functions

• V-Pointer (vptr) — hidden pointer in each object that points to the class's vtable

• Runtime dispatch — vptr looked up at call time to find and invoke the correct overridden function

• Virtual destructor — required in base classes to ensure derived destructor runs on delete through base pointer

• Memory leak without virtual destructor — derived destructor never called, heap resources not freed

• Object slicing — assigning derived to base by value copies only the base portion, losing derived data

• override keyword — explicitly marks a derived function as overriding a base virtual, catches signature mismatches