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