| Abstract Class | A class containing at least one pure virtual function. Cannot be instantiated directly. |
| Access Specifier | public, protected, or private keyword controlling member visibility within and outside a class. |
| Aggregate | A class or struct with no user-declared constructors, no private/protected non-static data members, no base classes, and no virtual functions; supports brace initialization. |
| Algorithm | A generic function in <algorithm> operating on iterator ranges (e.g., std::sort, std::find). |
| Associative Container | STL containers providing key-based O(log n) or O(1) lookup: map, set, unordered_map, unordered_set. |
| Class | A user-defined type that encapsulates data and functions. Supports inheritance and polymorphism. |
| Composition | A class that contains instances of other classes as members, modeling a "has-a" relationship. |
| Concept | A named constraint (C++20) specifying requirements on template type parameters, checked at compile time. |
| const | Qualifier making a variable, parameter, or member function read-only; enforced at compile time. |
| Constructor | A special class method automatically called when an object is created. Initializes the object. |
| Container Adapter | A class template wrapping a sequential container to provide a restricted interface: stack, queue, priority_queue. |
| Copy Constructor | Creates a new object as a copy of an existing one. Signature: ClassName(const ClassName&). |
| Default Constructor | A constructor taking no arguments; generated by the compiler if no constructors are declared. |
| Deleted Function | A constructor, operator, or function explicitly removed from the class interface using = delete. |
| Destructor | A special method automatically called when an object goes out of scope. Used to release resources. |
| dynamic_cast | Runtime-checked downcast for polymorphic types; returns nullptr on pointer failure or throws std::bad_cast on reference failure. |
| Encapsulation | Combining data and methods into a single unit (class) and restricting access using access specifiers. |
| Fold Expression | C++17 syntax applying a binary operator across all elements of a parameter pack in a single expression. |
| Friend | Allows external functions or classes to access private or protected members of another class. |
| Function Overloading | Defining multiple functions with the same name but different parameter types or counts. |
| Function Pointer | A pointer to a function; declared as RetType (*name)(params), used for callbacks and dispatch tables. |
| Functor | A class with operator(), making its instances callable like functions; stateful alternative to function pointers. |
| Header File | A file (typically .h or .hpp) containing declarations of functions, classes, etc. |
| Heap | Memory region for dynamically allocated objects (via new and delete). |
| if constexpr | Compile-time conditional that discards the untaken branch during template instantiation, preventing compilation of invalid code paths. |
| Inheritance | Mechanism where a class (derived) inherits members from another class (base). |
| Inline Function | A function suggested to be expanded in-place by the compiler to reduce function call overhead. |
| Iterator | An object that points into a container and supports increment (++) and dereference (*) operations. |
| Lambda | An anonymous function defined using [] syntax, often used in STL algorithms. |
| Move Assignment | Transfers ownership of resources from a temporary (rvalue) to an existing object via operator=(T&&). |
| Move Constructor | Constructs a new object by transferring resources from an rvalue, leaving the source in a valid but unspecified state. |
| Namespace | A way to group related code and avoid name collisions. |
| Object | An instance of a class, representing a data structure with behavior. |
| Operator Overloading | Defining custom behavior for operators (e.g., +, <<) for user-defined types. |
| Override | Keyword marking a virtual member function as explicitly overriding a base class virtual; compile error if the signature doesn't match. |
| Parameter Pack | A template parameter representing zero or more types or values, declared and expanded with .... |
| Pointer | A variable that stores the address of another variable or object. |
| Polymorphism | The ability of objects to behave differently based on their dynamic type (usually via virtual functions). |
| Pure Virtual Function | A virtual function declared with = 0; makes the class abstract and requires derived classes to provide an implementation. |
| RAII | Resource Acquisition Is Initialization – a technique where resources are tied to object lifetime. |
| Reference | An alias for another variable, declared using &. |
| Rule of Three | If you explicitly define any of destructor, copy constructor, or copy assignment operator, define all three. |
| Rvalue Reference | T&& syntax that binds to temporaries, enabling move semantics and perfect forwarding. |
| Scope | The region of code in which a name is visible; determined by blocks {}, namespaces, classes, and function boundaries. |
| Sequential Container | STL containers maintaining element insertion order: vector, deque, list, forward_list. |
| Smart Pointer | Classes like std::unique_ptr or std::shared_ptr that manage object lifetime automatically. |
| Stack | Memory region for local variables with automatic lifetime and fast allocation/deallocation. |
| STL (Standard Template Library) | A collection of generic containers, algorithms, and iterators. |
| Stream | Abstraction for sequential character I/O; the base hierarchy is rooted at std::ios_base. |
| Template | A feature allowing generic programming by defining functions or classes with type parameters. |
| Template Metaprogramming | Using template instantiation to perform computation at compile time, producing types or constant values. |
| Template Specialization | A concrete implementation of a function or class template for a specific type, overriding the generic version. |
| Translation Unit | A source file (.cpp) together with all its transitively included headers; the fundamental unit of compilation. |
| Type Coercion | Implicit conversion of a value from one type to another performed automatically by the compiler. |
| Value Semantics | Objects behave like values: copying produces an independent duplicate; distinct from reference semantics. |
| Variadic Template | A template accepting a variable number of type parameters via the ... pack syntax. |
| Virtual Function | A member function that can be overridden in derived classes, enabling dynamic dispatch. |