C++ Core Concepts and Object-Oriented Programming

Vocabulary flashcards covering key C++ concepts from the lecture notes including object lifecycle management, inheritance, operator overloading, templates, and polymorphism.

Rule of Three

A C++ design guideline stating that if a class requires a custom copy constructor, copy assignment operator (operator=), or destructor, it almost certainly needs to explicitly define all three to manage dynamic memory and resources properly.

Default Constructor

A constructor that can be called with no arguments, either taking no parameters or having default values for all parameters, which is automatically supplied by the compiler if no custom constructor is defined.

Destructor

A special member function denoted as ~ClassName() that is automatically called when an object goes out of scope, taking no parameters, returning no value, and incapable of being overloaded.

Copy Constructor

A constructor with the signature ClassName(const ClassName& other) used to initialize a new object using an existing object of the same class, such as when an object is passed or returned by value.

Protected Access Specifier

A member access level in C++ that prevents direct access from outside functions while allowing member functions of derived classes to access those members.

Multiple Inheritance

A feature supported in C++ that allows a derived class to inherit directly from more than one base class.

Non-Overloadable Operators

A specific set of C++ operators that cannot be overloaded, consisting of the conditional operator (?:), member access operator (.), pointer-to-member operator (.*), scope resolution operator (::), and sizeof operator.

Templates

A C++ feature for generic programming that allows functions or classes to work with abstract types, instantiated by the compiler at compile-time rather than runtime.

Runtime Polymorphism

A form of polymorphism in C++ resolved at runtime using virtual functions called through base class pointers or references.

Compile-Time Polymorphism

A form of polymorphism in C++ resolved during compilation through function overloading, operator overloading, and templates.