OOP

An abstract class has at least one pure virtual function (= 0); it cannot be instantiated directly and serves as a contract for derived classes. In C++ a pure virtual function may still have a body — useful for the destructor.

public — accessible everywhere; protected — accessible inside the class and its derived classes; private — only inside the class and friends. Default in class is private, in struct is public.

A const member is declared with const after the parameter list; inside it, this is a pointer to const and the function cannot modify non-mutable members. Only const methods may be called on a const object.

A constructor initialises a new object. Kinds: default, copy (const T&), move (T&&), converting (one non-explicit arg), delegating, inherited (using Base::Base).

Encapsulation bundles data and operations into one unit and hides implementation details; in C++ this uses access specifiers — private data is exposed only via public/protected methods.

Inheritance models 'is-a' and reuses base-class behaviour: public (is-a), protected (restricted is-a), private (implemented-in-terms-of). Multiple inheritance combines several bases; virtual inheritance avoids duplicating shared ancestors.

Polymorphism uses a single interface for different underlying types. C++ has three kinds: subtype (runtime, virtual functions), parametric (compile-time, templates), and ad-hoc (overloading).

Rule of Three: if you write any of (destructor, copy ctor, copy assign) you almost certainly need all three. C++11 added move ctor/assign → Rule of Five. Rule of Zero: use RAII members so no special members are needed.

Deleting a derived object through a base pointer with a non-virtual destructor calls only the base destructor — UB. A virtual destructor ensures the derived destructor runs first, then each base. Polymorphic bases must have one.

virtual enables dynamic dispatch: the correct override is selected at runtime by the object's actual type, not the static type of the pointer/reference. Only the base declaration needs virtual; derived overrides inherit virtuality.

Copy constructor creates a new object from an existing one (T b = a;); copy-assignment replaces the state of an already-constructed object (b = a;) and must handle self-assignment, typically via copy-and-swap.

Overloading: multiple same-named functions with different parameter types, resolved at compile time; overriding: a derived class replaces a virtual function with the same signature, resolved at runtime via the vtable.

Construction: virtual bases, then non-virtual bases (left to right), then data members (in declaration order), then the constructor body. Destruction is the exact reverse. Members are initialised in declaration order, not initialiser-list order.

Shallow copy duplicates pointer values — both objects share one allocation, leading to double-free; deep copy allocates new memory and duplicates the pointed-to data, required whenever a class owns heap resources.

Three ways: member initialiser list in the constructor (only way for const/reference members and bases); default member initialisers (C++11) in the class body; and assignment in the constructor body (default-construct then assign).

Declare the copy constructor and copy-assignment operator as = delete; any copy attempt becomes a compile error. For movable-but-not-copyable types only the copy operations are deleted while move operations are defaulted.

Yes, a pure virtual function can have an out-of-line body, callable explicitly via Base::method(). Calling it through virtual dispatch from a constructor/destructor is UB — at that point the vtable points to the base.

A static data member belongs to the class itself and is shared by all instances; a static member function has no this and can only access other static members. Static members exist for the whole program lifetime.

The diamond problem: two bases share a common ancestor and the derived class inherits two copies. Virtual inheritance ensures one shared sub-object; the most-derived class constructs the virtual base directly, adding a vbptr per object.

On self-assignment (w = w;) it deletes data_, then dereferences the now-freed other.data_ (the same pointer) — use-after-free, UB. Fix: guard with if (this != &other), or use the copy-and-swap idiom, which is self-assignment-safe and exception-safe.

= default asks the compiler to generate the default implementation of a special member; = delete removes a function from the overload set so calling it is a compile-time error.

A delegating constructor (C++11) calls another constructor of the same class in its initialiser list, avoiding code duplication. Only the delegated-to constructor may have member initialisers; the delegating body runs after delegation completes.

A single-argument constructor is a converting constructor and allows implicit conversions; marking it explicit forbids the compiler from using it implicitly, requiring direct initialisation.

friend grants another class or function full access to private and protected members; friendship is not inherited, not transitive, and not mutual, and is typically used for non-member operator overloads.

The initialiser list constructs members directly; body assignment first default-constructs then assigns — two operations. It is mandatory for const, reference, and non-default-constructible members.

C++ has no interface keyword — an interface is a convention: a class with only pure virtual functions and no data; an abstract class has at least one pure virtual but may also have data and concrete methods.

Multiple inheritance combines bases but causes the diamond problem (ambiguity, duplicate sub-objects); virtual inheritance shares one sub-object, and the most-derived class must call the virtual base constructor.

override tells the compiler the function must override a base virtual; if none matches, compilation fails — catching silent signature-mismatch bugs. final forbids further overriding or derivation.

Three main kinds: subtype (runtime) via virtual functions and vtable; parametric (compile-time) via templates; ad-hoc via function/operator overloading. CRTP provides static subtype-like dispatch.

If a class needs a custom destructor, copy ctor, or copy assignment, it almost certainly needs all five: destructor, copy ctor, copy assignment, move ctor, move assignment. Use RAII members (unique_ptr, vector) to avoid writing them.

Slicing occurs when a derived object is assigned or copied into a base by value, discarding all derived members. Prevent it via references, pointers, or smart pointers — or by deleting the base copy constructor.

Non-static methods receive a hidden this pointer; static members have no this, so ptr->staticMethod() may compile with null ptr (use Type::method() instead). Calling a non-static method on null is UB.

Each polymorphic class has a static vtable (array of function pointers); each instance carries a hidden vptr. A virtual call dereferences the vptr, indexes the vtable, and jumps — the most-derived override wins.

sizeof(A) is 1, not 0 — the standard requires every distinct object to have a unique address. As a base, the Empty Base Optimisation (EBO) allows an empty base sub-object to take zero size.

Use final on the class (class C final {};) to forbid further inheritance and let the compiler devirtualise calls. You can also apply final to individual virtual functions to forbid overriding them in subclasses.

mutable allows a member to be modified through a const object or inside a const method; typical uses are lazy caches and mutexes that need locking in read-only operations.

Fields are initialised in declaration order, not initialiser-list order. If the list references a field declared later, it is read uninitialised — undefined behaviour. Compilers warn with -Wreorder.

Lookup searches scopes from innermost to outermost, so locals shadow members; use this->name or ClassName::name to disambiguate, and conventions like m_name/name_ avoid the issue entirely.

Deleting a Derived through a Base* whose destructor is not virtual is undefined behavior — in practice ~Derived never runs, leaking the resources it owns. Fix: give a polymorphic base a virtual destructor (or own it via unique_ptr).

Private inheritance expresses 'implemented-in-terms-of', not 'is-a': base public/protected members become private in the derived class. Use it for overriding virtuals, EBO, or accessing protected base members; otherwise prefer composition.

protected exposes a member only to derived classes — broader than private, narrower than public. Use sparingly: it loosens encapsulation toward subclasses you don't control.

Static polymorphism resolves at compile time (templates, overloading, CRTP) with no runtime cost; dynamic polymorphism (virtual functions) resolves at runtime via vtable, supporting heterogeneous containers and runtime types.

The Empty Base Optimization (EBO) lets a base class with no non-static data members occupy zero bytes inside a derived object, instead of the minimum 1 byte a standalone empty class needs. It applies only when the empty base is inherited, not held as a member.

Non-static data members are initialized in declaration order, never in the order they appear in the member initializer list. If one member's initializer reads another member declared later, that member is still uninitialized garbage. Enable -Wreorder to catch this.

Each polymorphic base contributes its own vptr; sub-objects sit consecutively, casting to a secondary base adjusts the pointer by an offset, and virtual inheritance adds a vbptr for the shared sub-object.

The Non-Virtual Interface idiom makes the public interface non-virtual and the customization points private virtual. The public method runs shared pre/post logic and delegates the variable part to a private hook, so subclasses cannot skip the wrapper code.

Yes — = 0 only marks the class abstract and forces derived classes to override; it does not forbid a definition, which must be out of line. It is useful as a shared default invoked via Base::method(), and is mandatory for a pure virtual destructor.

Declaring a destructor, copy constructor, or copy assignment suppresses implicit generation of the move constructor and move assignment, so the class silently copies instead of moving. Declaring either copy operation also deprecates the other one.

A standard-layout class has no virtual functions or virtual bases, all non-static data members with the same access control, and members declared in at most one class. It has a predictable, compiler-independent layout and is fully C-struct compatible.

During each constructor stage the object's vptr points to that class's own vtable, because more-derived parts do not exist yet. A virtual call from the base constructor resolves to the base version. Calling a pure virtual this way is undefined behavior.

Each polymorphic class has a static vtable; each instance carries a hidden vptr. Each constructor stage resets the vptr to its class's vtable — so virtual calls in constructors don't reach derived overrides.

class and struct differ only by defaults: class is private by default, struct is public. union overlays all members in one memory location — only one member is active at a time.

Logger wraps a std::ostream& and writes timestamped, level-prefixed lines. Accepting the stream by reference lets callers pass std::cout, an std::ofstream, or any ostream. The class must be non-copyable since streams are not copyable.

The four OOP principles: encapsulation (data + methods, controlled access), abstraction (expose only needed), inheritance (IS-A reuse), and polymorphism (uniform interface, different behaviour).

C++ has no interface keyword — interface is a convention: only pure-virtual functions plus a virtual destructor. Abstract class: at least one pure-virtual but may have data and bodies.

Define IProductRepository (pure virtual fetchByFilter), SqlProductRepository for real queries, FakeProductRepository for tests. ProductService depends only on the interface — Dependency Injection enables tests without a database.

Split into Grid (owns cells, computes next generation) and a Printer/Renderer (displays). Grid::step() counts live neighbours and applies the four rules using a double buffer — writing to a new grid and swapping — to avoid in-place mutation bugs.

s.b is 5, but s.a is garbage. Members initialize in declaration order (a then b), not the order written in the initializer list, so a(b) runs first and reads b before it is set. Compile with -Wreorder to catch this.

String owns a heap char[] and must follow the Rule of Five: destructor, copy ctor, copy-assignment via copy-and-swap, move ctor, move-assignment. Move operations null the source pointer so the source destructor doesn't double-free.

Destruction runs in reverse of construction: most-derived destructor body first, then members in reverse declaration order, then bases. The base destructor must be virtual when deleting through a base pointer — otherwise the derived part leaks (UB).