Classes (class)

Classes (`class`)

Explanation

A class is a user-defined type that serves as a blueprint for creating objects.
It encapsulates data members (variables) and member functions (methods) that operate on these data.
A class provides a way to group related behaviors and attributes into a cohesive unit, promoting data abstraction and encapsulation.
A class helps enforce encapsulation by limiting access to internal details and exposing only the necessary functionalities, making code more modular, reusable, and easier to maintain.
An empty object occupy at least one byte memory, since all objects need to have unique memory addresses. Creating an object on the stack is faster than on the heap.
Structures( Stored as the class ) + Functions( Stored outside of the class ) = Classes.

Visibility

The visibility makes code more readable, not affect the performance.
private( default visibility ): The owner class, friend class.
protected: The owner class, friend class, sub-class.
public: All.

Declaration Syntax

class ClassName;

Definition Syntax

class ClassName {
   ...;
};

Member Variables

Explanation

Member variables, also known as instance variables or fields, are attributes of a class that hold data specific to the instances (objects) of that class. They define the state of an object.
Member variables can be assigned default values when they are defined.

Syntax

class ClassName {
   private:
      Type _mem;   // Declaration or definition of a member variable.
};

`this`

Explanation

this is a pointer available within a class's member function that points to the object that invoked the member function. It allows access to the calling object's members.
this is implicitly passed to all non-static member functions.
It can be useful for disambiguation when member variables and parameters have the same name.
It is not available in static member functions as there is no associated object.

Syntax

this->_mem;
// (*this)._mem;

`const` Member Variables

const Member Variables

`constexpr` Member Variables

constexpr Member Variables

`static` Member Variables

static Member Variables

`mutable` Member Variables

Explanation

mutable member variables can be modified even in const member functions.
This allows certain aspects of an object to change while keeping its overall state constant.
Generally, they are used for caching or lazy evaluation purposes.
They break the const-correctness for that particular member variable.
In 90% of cases, the mutable keyword will be used in a class with the const keyword.

Syntax

class ClassName {
   private:
      mutable Type _mem;   // Declaration or definition of a member variable.
};

Pointer Member Variables

Explanation

Pointer member variables hold memory addresses of instances or other data types.
They allow dynamic memory management and manipulation of resources.

Syntax

class ClassName {
   private:
      Type* _mem_ptr;   // Declaration or definition of a member pointer.
};

Reference Member Variables

Explanation

Reference member variables are alternatives to pointers that refer to existing objects.
They cannot be reassigned once established.
Theyt must be initialized when defined and cannot be null.
There are only two ways to initialize a reference member:
- In-Class Initialization: It can be overridden by the constructor.
- Constructor Initialization.
When initializing a reference member in a class, the reference must be bound to either another member variable of the class or an external variable passed as a reference during object construction.

Syntax

class ClassName {
   public:
      // Initialization through constructor
      explicit ClassName( Type& ref ): _memRef( ref ) {};

   private:
      Type _mem;
      // In-Class Initialization
      Type& _memRef = _mem;
};

Methods

Explanation

A method in C++ is a function that belongs to a class or struct.
It is used to perform operations or manipulate the data members (attributes) of that class.
Methods encapsulate behavior specific to an object of the class.
Methods can be overloaded by defining multiple versions with different parameter types.
Methods defined inside the class are automatically considered inline, improving performance by reducing function call overhead.

Syntax

// Declared and defined inside the class.
class ClassName {
   public:
      RetType funcName( para_list ) { ... };
};

// Declared inside the class.
class ClassName {
   public:
      RetType funcName( para_list ) { ... };
};

// Defined outside the class.
RetType ClassName::funcName( para_list ) { ... };

`const` Methods (`const` Member Functions)

const Methods (const Member Functions)

`constexpr` Methods (`constexprt` Member Functions)

constexpr Functions (constexpr Return Values)

`static` Methods (`static` Member Functions)

static Methods (static Member Functions)

`virtual` Methods (`virtual` Functions) (`virtual` Memeber Functions)

virtual Methods (virtual Functions) (virtual Memeber Functions)

Pure `virtual` Functions and Abstract Classes

Pure virtual Functions and Abstract Class

`override` Methods

Explanation

override is a keyword used to explicitly indicate that a method in a derived class is meant to override a virtual method in the base class.
It ensures that the method signature in the derived class matches a virtual method in the base class. If the method signature does not match, the compiler will generate an error, which helps prevent subtle bugs caused by accidental method hiding.

Syntax

class Base {
   public:
      virtual RetType funcName( para_list ){
         // `virtual` method in base class
      };
};

class Derived: public Base {
   public:
      RetType funcName( para_list ) override{
         // Override the base class method
      };
};

Notes

You should always use the override keyword when overriding functions in a derived class, as it helps prevent errors.

Constructors

Explanation

Constructors are special member functions of a class that are automatically called when an object of that class is created.
They are used to initialize the object's properties and set up any necessary resources.
All constructors except for copy and move constructors will cause default initialization of class members if the constructor lacks an initializer list.

Syntax

class ClassName {
   public:
      ClassName( para_list ){
         ...;
      };
   private:
      Type1 _mem1 = val1; // Default initialization.
      Type2 _mem2; // Default initialization.
      ...;
};

Defalut Constructors and `default` Constructors

Explanation

A default constructor is a constructor with no parameters or with all parameters having default values.
It is called when an object is instantiated without any arguments.
It initializes data members to their default values (primitive types remain uninitialized).
If no other constructors are defined, the compiler provides a default constructor.
The non-customized default constructor will initialize all non-user-defined type members to their zero values.
The = default syntax explicitly requests the compiler to generate the default constructor.

Syntax

class ClassName {
   public:
      // If no other constructors are defined,
      // this default constructor is provided by the compiler.
      ClassName(){};
};

class ClassName {
   public:
      // Default constructor.
      ClassName(){ ... };
};

class ClassName {
   public:
      // Default constructor.
      ClassName() = default;
      // Default constructor.
      // Parameterized constructor.
      ClassName( parameters with default values ){
      };
};

Parameterized Constructors

Explanation

A parameterized constructor is a type of constructor in a class that allows you to initialize an object with specific values upon creation.
Unlike a default constructor (which takes no arguments), a parameterized constructor accepts one or more arguments that enable you to set the initial state of an object with specific values.
It is called when an object is instantiated with specific arguments.

Syntax

class ClassName {
   public:
      // Parameterized constructor.
      ClassName( para_list ){
      };
};

Constructor Initializer Lists

Explanation

Constructor initializer lists are used to initialize member variables of a class in the constructor's initialization phase before the body of the constructor executes.
Member variables are initialized in the order they are declared in the class, not the order they appear in the initializer list.
Using initializer lists can be more efficient, as it allows direct initialization of the member variables, avoiding unnecessary default construction followed by assignment.
An initializer list is required to initialize const and reference members, as they cannot be assigned after construction.
If members are initialized in the body of the constructor, they are first default-initialized before being assigned.
Initialization in the constructor body can result in additional overhead compared to direct initialization in the initializer list.

Syntax

// Traditional initializer lists.
// Direct-initialization (initial value in parenthesis).
// Slighly faster.
class ClassName {
   public:
      ClassName( Type1 para1, Type2 para2, ... ):
         _mem1( para1 ), _mem2( para2 ), ...{};

   private:
      Type1 _mem1;
      Type2 _mem2;
      ...;
};

// Modern initializer lists.
// Direct-list-initialization (initial value in braces).
// C++11 uniform initialization.
// Type safe, prevents narrowing conversions.
// Recommended.
class ClassName {
   public:
      ClassName( Type1 para1, Type2 para2, ... ):
         _mem1{ para1 }, _mem2{ para2 }, ...{};

   private:
      Type1 _mem1;
      Type2 _mem2;
      ...;
};

Differences between Traditional Initializer Lists and Modern Initializer Lists

Traditional initializer lists:
- They were used before C++11 and primarily involved constructor initialization lists to initialize member variables, with less emphasis on consistency across all types.
- Initialization order:
  - Matched constructor:
    - The constructor that best matches the initializer list is chosen first.
  - Implicit conversion:
    - If no exact match is found for the constructor, implicit conversions can be applied, and the constructor that matches the converted type is chosen.
Modern initializer lists (Introduced in C++11):
- Thye bring a more consistent, type-safe, and uniform syntax for initialization.
- They prevent narrowing conversions and provide a cleaner syntax that can be used across all types (primitives, containers, user-defined types).
- They can work with std::initializer_list< Type > to initialize containers like std::vector, but std::initializer_list< Type > introduces a slight overhead. This overhead arises because std::initializer_list< Type > stores a pointer to the underlying data and the size of the list. However, this overhead is generally minimal and is unlikely to significantly affect performance in most use cases.
- This is only used to initialize the values of elements in an object and cannot specify the size of the object, except when the size itself is a member of the object.
```
std::vector< int > vec{ val }; // Create a vector with one element.
std::vector< int > vec( size ); // Create a vector with `size` elements.
```
- An example:int int_var{ val };.
- Initialization order:
  - Constructor with an initializer list:
    - If the class has a constructor that takes a std::initializer_list, it will be prioritized when initializing with curly braces and matching arguments.
  - Other constructors: contain the implicition conversion.
    - If the initializer list constructor is not available or does not match, the compiler looks for a regular constructor that matches the arguments.
  - Aggregate initialization:
    - If no constructors are defined, aggregate initialization applies to structs or classes.

Limitations of Aggregate Initialization

No user-defined constructors:
- Aggregate initialization is only applicable to aggregate types that lack user-defined constructors.
- If a class has any constructor defined, aggregate initialization cannot be used.
Public members only:
- Only public members can be initialized via aggregate initialization.
- Private or protected members cannot be accessed.
No default member initializers:
- Default member initializers in aggregates are ignored during aggregate initialization, meaning you must explicitly specify values for all members.
Order of initialization:
- Members are initialized in the order they are declared.
- This can lead to issues if one member relies on another being initialized first.
No designated initializers:
- C++ does not support designated initializers (as in C99), preventing the ability to initialize specific members without initializing all preceding members.
Type matching:
- The types in the initializer list must match the types of the aggregate's members exactly.
- A mismatch results in a compilation error.
No implicit conversions:
- Aggregate initialization does not allow implicit type conversions, which can limit flexibility.
No inheritance:
- Aggregate initialization is not applicable for derived classes, limiting its use in inheritance scenarios.

Notes

In the constructor initializer list, you'd better initialize the members in the order in which they are defined in the class.
If a class has a class or struct member, we should use the constructor initializer to initialize the class or struct member; otherwise, the initialization will call the object's constructors twice: first the default constructor, and then the other constructor.

Copy Constructors

Explanation

A copy constructor is a special constructor that initializes a new object as a copy of an existing object.
This is essential for managing resource ownership and ensuring that objects behave properly when passed, returned, or assigned.
The parameter of a copy constructor and copy assignment operator should not be passed by value, as this can lead to issues.
- When passing the argument by value, the copy constructor will be called to create a temporary object for the parameter.
- This temporary object creation requires another call to the copy constructor, which leads to a recursive cycle.
- The cycle continues until the call stack overflows, causing a stack overflow error.
- In other words, passing by value in the copy constructor or copy assignment operator triggers an infinite loop, as each invocation requires another copy of the argument, which again invokes the copy constructor.

Default Copy (`default`) (Avoid) (Double Destructions)

Explanation

A default copy constructor is automatically generated by the compiler if no user-defined copy constructor is present.
It performs a shallow copy of the object's members.
For primitive types, this is a straightforward copy, but for pointer members, both the original and copied objects will reference the same memory.
This can lead to issues such as:
- Double destructions: When both objects are destroyed, they attempt to free the same memory location, resulting in undefined behavior.
- Dangling pointers: When one object is deleted, the other retains a pointer to the deallocated memory, leading to program crashes if accessed.
The copy is performed quickly since it merely copies the pointer (for pointer types) rather than the pointed-to values.
The default copy constructor is typically marked as noexcept, improving performance by ensuring compatibility with standard containers, such as std::vector.
The = default syntax explicitly requests the compiler to generate the default copy constructor.

Syntax

class ClassName {
   public:
      // Compiler-generated default copy constructor.
};

class ClassName {
   public:
      // Default copy constructor.
      ClassName( const ClassName& ) = default;
};

Shallow Copy (e.g. `memcpy`) (Avoid) (Double Destructions)

Explanation

A shallow copy occurs when the copy constructor simply copies the pointer values instead of the data they point to.
This can lead to multiple instances trying to manage the same resource.
This can lead to issues such as:
- Double destructions: When both objects are destroyed, they attempt to free the same memory location, resulting in undefined behavior.
- Dangling pointers: When one object is deleted, the other retains a pointer to the deallocated memory, leading to program crashes if accessed.
The copy is performed quickly since it merely copies the pointer (for pointer types) rather than the pointed-to values.

Syntax

class ClassName {
   public:
      Type* _mem_ptr;

      // Shallow copy constructor.
      ClassName( const ClassName& other ) {
         _mem_ptr = other._mem_ptr;
         ...;
      };

      // Destructor.
      ~ClassName() {
         // Free allocated memory: Error, double destruction.
         delete _mem_ptr;
         ...;
      };
};

Deep Copy (Recommend)

Explanation

A deep copy ensures that the copy constructor creates a new instance of any dynamically allocated memory, so that two objects do not reference the same location.
This prevents double deletion and dangling pointer issues, as each object manages its own memory independently.
Although slower than shallow copying due to memory allocation, deep copying is generally much safer, particularly for complex data structures.
When implementing a copy constructor, it is also recommended to implement a corresponding copy assignment operator to maintain consistent behavior and proper resource management.

Syntax

class ClassName {
   public:
      Type* _mem_ptr;

      // Deep copy constructor.
      ClassName( const ClassName& other ) {
         _mem_ptr = new Type( *other._mem_ptr );
         ...;
      };

      // Destructor
      ~ClassName() {
         // Free allocated memory.
         delete _mem_ptr;
         ...;
      };

Move Constructors

Explanation

A move constructor is a constructor that transfers resources from one object to another, rather than performing a deep copy.
This enables efficient handling of temporary objects and avoids unnecessary data copying.
It is ideal for rvalue references, which represent temporary objects that do not need to retain their original state.
Move constructors should be marked noexcept to ensure compatibility with standard containers and to optimize performance.
Move constructors behave similarly to shallow copy constructors but use move semantics and rvalue references.
A shallow move resembles a shallow copy but without assigning all pointers in the source object to nullptr, whereas a deep move resembles a shallow copy with all pointers in the source object being assigned to nullptr.

Default Move Constructors

Explanation

The compiler generates a default move constructor only if:
- The class does not explicitly define a copy constructor, copy assignment operator, move constructor, or move assignment operator.
- All data members and base classes are movable (i.e., they also support move semantics).
The default move constructor performs a shallow move, transferring (not copying) each member from the source object to the destination.
However, it treats all members as if they were primitive types, performing a shallow transfer without resetting any pointer members of the original object to nullptr.
This can cause issues such as double deletions and dangling pointers.
While terms like "shallow move" and "deep move" are not part of standard C++ terminology, "unsafe move" and "safe move" better convey the risks and benefits of different copying strategies.
The default move constructor is typically marked as noexcept, improving performance by ensuring compatibility with standard containers, such as std::vector.
The = default syntax explicitly requests the compiler to generate the default move constructor.

Syntax

class ClassName {
   public:
      // Compiler-generated default move constructor.
};

class ClassName {
   public:
      // Default move constructor.
      ClassName( ClassName&& ) = default;
};

Custom Move Constructor

Explanation

A custom move constructor is defined under the following circumstances:
- When a class manages resources that necessitate specialized management, such as dynamic memory allocation or file handles.
- When there is a need to reset the original object to a valid state (e.g., to nullptr) following the transfer of ownership.
Move constructors should be marked noexcept to ensure compatibility with standard containers and to optimize performance. containers like std::vector.

Syntax

class ClassName {
   public:
      Type* _mem_ptr;

      // Custom move constructor.
      ClassName( ClassName&& other ) noexcept: _mem_ptr( std::move( other._mem_ptr ) {
         // Deep move. Safe move.
         other._mem_ptr = nullptr;
         ...;
      };

      // Destructor.
      ~ClassName() {
         // Free allocated memory.
         delete _mem_ptr;   // Leave 'other' in a valid state
         ...;
      };
};

Conversion Constructors

Explanation

A conversion constructor allows implicit (should avoid it with the explicit keyword) or explicit conversion from a given type to the class type.
It takes a single parameter of a different type and initializes an object of the class with it.
These constructors facilitate the integration of custom classes with existing code by allowing automatic type conversion where appropriate.
When the target class holds additional information, conversion constructors ensure that initialization aligns with the class's intended use.

Syntax

class ClassName {
   public:
      // Conversion constructor.
      ClassName( Type para_name );
};

`virtual` Constructors

The concept of a "virtual constructor" does not exist.
The virtual keyword requires a vtable to support runtime polymorphism.
The constructor is responsible for initializing the vtable and constructing the object.
However, when the constructor is called, the vtable does not yet exist.
Therefore, if the constructor were allowed to be declared as a virtual method, a conflict would arise:
- The constructor would need the vtable to be called, but the vtable itself is created as part of the constructor's process.

`explicit` Constructors

explicit

Destructors

Explanation

A destructor is a special member function that is automatically called when an object goes out of scope or is explicitly deleted.
Its primary purpose is to release resources (such as dynamically allocated memory or file handles) associated with the object.
If a class has base classes or member objects, their destructors are called in reverse order of construction.

Syntax

class ClassName {
   public:
      ~ClassName() {
      };   // Destructor.
};

Default Destructors

Explanation

A default destructor is automatically generated by the compiler if the class does not explicitly define one.
It handles destruction according to the rules of the language, ensuring that all member variables and base classes are properly destroyed.
If the class directly manages resources (e.g., raw pointers), a custom destructor is necessary to avoid resource leaks.
The default destructor is typically marked as noexcept, improving performance by ensuring compatibility with standard containers, such as std::vector.
The = default syntax explicitly requests the compiler to generate the default destructor.

Syntax

class ClassName {
   public:
      // Default destructor.
      ~ClassName() = default;
};

`virtual` Destructors

virtual Destructors

Common Objects

Declaration Syntax

ClassName obj_name;

Initialization Syntax

// Default constructor.
ClassName obj_name;

// Parameterized constructor.
ClassName obj_name( para_list );

// Parameterized constructor.
ClassName obj_name1( para_list );
// Copy constructor.
ClassName obj_name2( obj_name1 );

// Not recommend, although the compiler may optimize it so that only one constructor is called.
// First, parameterized constructor.
// Second, copy constructor.
ClassName obj_name = ClassName( para_list );

// Parameterized constructor.
ClassName obj_name1( para_list );
// Move constructor.
ClassName obj_name2( std::move( obj_name1 ) );

// Parameterized constructor.
ClassName obj_name1( para_list );
// Move constructor.
ClassName obj_name2 = std::move( obj_name1 );

// Conversion construcotr, implicit conversion.
ClassName obj_name = initializer;

// Without related parameterized constructors and all members are public, aggregate initialization.
// With related parameterized constructors, parameterized constructor or uniform initialization or brace initialization.
ClassName obj_name{ para_list };

// With default construcotr, default constructor.
// Otherwise, aggregate initialization.
// All members are initialized to 0.
ClassName obj_name{ };

// Without related parameterized constructors and all members are public, aggregate initialization.
// With related parameterized constructors, parameterized constructor or uniform initialization or brace initialization.
ClassName obj_name = { para_list };

// When defining a class, assigning default values to its members.
class ClassName {
   private:
      Type _mem1 = initializer1;
      ...;
};

class ClassName {
   public:
      // Move constructor definition.
      ...;

      // Factory methods for initialization.
      static ClassName createClassName() {
         return std::move( ClassName( para_list ) );   // Parameterized constructor.
      };

      // Only used to return an existing object.
      // static ClassName&& createClassName() {
      //    return std::move( existing_obj );   // Parameterized constructor.
      // };

      ...;
};

// First, create a temporary object with the parameterized constructor in the createClassName.
// Second, create `obj_name` with the move constructor.
ClassName obj_name = ClassName::createClassName();

Class Pointers

Declaration Syntax

ClassName* obj_ptr;

Definition or Initialization Syntax

// Default constructor.
ClassName* obj_ptr = new ClassName;

// Parameterized constructor.
ClassName* obj_ptr = new ClassName( para_list );

// Default constructor.
ClassName obj_name;
ClassName* obj_ptr = &obj_name;

Class References

// Default constructor.
ClassName obj_name;
ClassName& obj_ref = &obj_name;

`const` Instance of Classes

const Instance of Classes

`constexpr` Instances of Classes

constexpr Instances of Classes

`static` Instances of Classes

static Instances of Classes

Anonymous Classes

Explanation

An anonymous class (also known as an unnamed class) is a class that is defined inline without a name.
These classes are typically used for creating objects on the fly or as part of data structures without the need to define a separate named class

Syntax

class {
  ...;
} obj_name;

union {
      class {
            ...;
      };
      ...;
};

// In this case, members should all be public.
class {
  ...;
} obj_name{ para_list };

Operator Overloading

Operator Overloading

Copy-assignment Operator

Copy-assignment Operator

Move-assignment Operator

Move-assignment Operator

Conversion Operator

Conversion Operator

`explicit` Conversion Operator

explicit Conversion Operator

How to Determine Which Constructor or Assignment Operator Is Invoked

If an object is being defined, the appropriate constructor will be called:
- No argument: default constructor.
- Single argument of a different type: conversion constructor.
- Single argument of the same type (lvalue reference): copy constructor.
- Single argument of the same type (rvalue reference): move constructor.
- Multiple arguments: parameterized constructor.
- If there is no explicit keyword before the called constructor, implicit conversion occurs, and the five rules mentioned above are followed to determine which constructor will be called.
If an object already exists and is assigned a new object, the assignment operator will be called:
- A different-type object: conversion operator.
- Same type (lvalue reference): copy-assignment operator.
- Same type (rvalue reference): move-assignment operator.
- If there is no explicit keyword before the called assignment operator, implicit conversion occurs, and the four rules mentioned above are followed to determine which assignment operator will be called.
When a temporary object is passed to a function by value, its copy constructor is not called due to move semantics or copy elision(especially since C++17). Instead, the move constructor (if available) or a parameterized constructor (if the move constructor is not available) is called.

Inheritance

Explanation

Inheritance allows a class to acquire the properties and behaviors of another class.
It promotes code reuse and establishes a hierarchical relationship between a base class and one or more derived classes.
C++ supports multiple inheritance and virtual inheritance to address complexities arising from overlapping base classes.
Inheritance also facilitates polymorphism, enabling derived classes to override virtual functions.

Definition Syntax

Code

class Base {
      // Members of base class.
};

class Derived: public Base {
      // Members of derived class.
};

template< class T, ... >
class Base {
      // Members of base class.
};

template< class T, ... >
class Derived: public Base< class T, ... > {
      // Members of derived class.
};

Initialization Syntax

Code

class Derived: public Base {
   public:
      Derived( para_list1 ): Base( para_list2 ), ... {};

   private:
      ...;
};

Explanation

When creating a derived class object, constructor delegation allows initializing the base class part of the object.
The initialization of the base class members must be done via an initializer list in the derived class constructor.

Construction Order

Base class constructor: Called first, initializing the base portion of the object.
Derived class constructor: Called after the base class constructor.
Member initializations: Member variables of the derived class are initialized after the base class part.

Destruction Order

Derived class destructor: Called first to release resources specific to the derived class.
Base class destructor: Called last to release resources inherited from the base class.

Calling Functions Defined in Base Classes from Derived Classes

// Calling hidden functions.
class Base {
   public:
      virtual RetType funcName( ... ) { ...; };
      ...;

   private:
      ...;
};

class Derived: public Base {
   public:
      RetType funcName( ... ) override {
         RetType var_name = Base::funcName( ... );
         ...;
      };
      ...;

   private:
      ...;
};

// Calling private functions.
class Base {
   public:
      RetType1 funcName1( ... ) {
         RetType2 var_name2 = funcName2( ... );
         ...;
      };

      ...;

   private:
      virtual RetType2 funcName2( ... ) { ...; };

      ...;
};

class Derived: public Base {
   public:
      RetType3 funcName3( ... ) override {
         RetType1 var_name1 = funcName1( ... );
         ...;
      };

      ...;

   private:
      ...;
};

`virtual` Inheritance

virtual Inheritance

`virtual`

Explanation

The virtual keyword in C++ is integral to enabling dynamic polymorphism and ensuring the correct behavior of objects in inheritance hierarchies.
The virtual keyword propagates down the class hierarchy.

`virtual` Methods (`virtual` Functions) (`virtual` Memeber Functions)

Explanation

A virtual method is a member function declared with the virtual keyword in a base class, allowing derived classes to provide their own implementation.
When invoked through a base class pointer or reference, the function from the most derived class is called, enabling runtime polymorphism.
virtual methods ensure dynamic dispatch by resolving function calls at runtime based on the object's actual type.
They can be overridden in derived classes using the same function signature.
The override keyword is optional but recommended, as it ensures that the derived class correctly overrides a virtual function.
If a derived class does not override the virtual function, the base class's implementation will be invoked.
Once a function is declared as virtual in a base class, it remains virtual in all derived classes until the final keyword is encountered.
The virtual keyword propagates down the class hierarchy.

Syntax

class Base {
   public:
      virtual RetType funcName() const {
         // Base class implementation.
      };
};

class Derived: public Base {
   public:
      // Override keyword for clarity.
      RetType funcName() const override{
         // Derived class implementation.
      };
};

Static Binding and Dynamic Binding

Polymorphism and Problems

Polymorphism:
- virtual functions enable polymorphic behavior, allowing a program to treat objects of different derived classes through a base class pointer or reference.
- This allows different objects to be operated on using the same interface, meaning the same operation can be applied to different objects, exhibiting different behaviors.
- This makes it easier to write flexible and reusable code.
Performance overhead:
- virtual functions introduce a performance penalty due to the dynamic dispatch mechanism.
- The program must go through the V table to look up the correct function to call at runtime, which can be slower than static binding.
Memory overhead:
- Each class that uses virtual functions typically includes a virtual table (vtable), which adds some memory overhead.
- Each object of such classes contains a pointer to the vtable, increasing the size of the object.
Debugging Challenges:
- Debugging issues related to virtual functions can be more challenging, especially when it comes to understanding the flow of execution and object lifetimes in the presence of polymorphism.
Potential for Resource Leaks:
- If a base class has virtual functions, its destructor should also be virtual to ensure proper cleanup of derived class resources.
- Failing to declare a virtual destructor can lead to resource leaks.
Bindings

Notes

In cases where performance is very important, you should avoid using virtual functions as much as possible.

Pure `virtual` Functions and Abstract Classes

Explanation

A pure virtual function is declared by assigning = 0 to a virtual function, indicating that it does not provide any implementation in the base class.
Pure virtual functions enforce a contract that derived classes must fulfill, promoting design consistency.
A class containing at least one pure virtual function is termed an abstract class and cannot be instantiated.
The abstract class is not restricted to only contain virtual functions.
If a class only contains pure virtual functions, it serves as an interface or a base type for deriving more specific implementations.
All derived classes must override the pure virtual functions; otherwise, they also become abstract.
Abstract classes may contain non-virtual member functions in addition to pure virtual ones.

Syntax

class ClassName {
   public:
      // Pure `virtual` function.
      virtual RetType funcName( para_list ) const = 0;
};

`virtual` Destructors

Explanation

A virtual destructor ensures that when an object is deleted via a base class pointer, the destructor of the derived class is invoked, followed by the base class’s destructor.
This guarantees that all resources allocated by the derived class are correctly released, thereby preventing memory leaks and ensuring complete destruction of the object.
Destructors should be declared virtual in any base class intended for inheritance to avoid undefined behavior during object destruction.
Without a virtual destructor, only the base class destructor would execute, leaving resources specific to the derived class unreleased.
Although virtual destructors add a slight performance overhead, they are critical for safe and correct resource management.

Syntax

class Base {
   public:
      virtual ~Base() {
         // Cleanup logic for the base class.
      };
};

class Derived: public Base {
   public:
      ~Derived() {
         // Cleanup logic for the derived class.
      };
};

Notes

It's used to delete a subclass object pointed to by a parent class pointer in a polymorphic context. A virtual destructor differs from other virtual functions.
The subclass's virtual destructor does not override its parent class's virtual destructor; both will be called.
If we allow our class to be derived into a subclass, we should declare its destructor as virtual to avoid issues like memory leaks.

`virtual` Inheritance

Explanation

virtual inheritance prevents ambiguity when a class indirectly inherits from the same base class multiple times.
It ensures that only one instance of the base class exists in the final derived class.
It resolves the diamond inheritance problem, where two base classes share a common ancestor.
The base class constructor must be invoked from the most-derived class.
Virtual inheritance occurs only when a class is inherited using the virtual keyword, and it propagates down the class hierarchy.
For example, Base is virtually inherited by B using the virtual keyword. Although Derived inherits from B without using the virtual keyword, Base is still virtually inherited by Derived through B, as B has virtually inherited Base.
The virtual keyword propagates down the class hierarchy.

Definition Syntax

class Base {
      ...;
};
class A: virtual public Base {};
class B: virtual public Base {};
class Derived: public A,
               public B {};

Initialization Syntax

class Derived: public A,
               public B {
   public:
      Derived( para_list1 ):
         Base( para_list2 ), A( para_list3 ), B( para_list4 ){};
};

Construction Order

virtual base class constructor: Called first, even if it's inherited indirectly.
Other base class constructors: Called next.
Derived class constructor: Called last.

Destruction Order

Derived class destructor: Invoked first.
Non-virtual base class destructors: Called next.
virtual base class destructor: Called last.

`friend`

Explanation

The friend keyword grants non-member functions or other classes access to the private and protected members of a class.
The friend keyword is commonly used when specific functions or classes require access to a class's internal details but are not part of its public interface
Friendship in C++ is not inherited—a derived class does not inherit the friendship relationships of its base class.
Additionally, friendship is unidirectional: the class or function granted access does not automatically reciprocate that privilege.

`friend` Functions

Explanation

A friend function is a non-member function that is allowed access to the private and protected members of a class.
If the friend function needs access to non-static non-public members, the class instance should be passed to the friend function.
If the friend function only accesses static members or performs operations unrelated to a specific object, the class instance does not need to be passed.

Syntax

class ClassName {
   public:
      // Friend function declaration.
      friend RetType funcName( const ClassName& obj );
};

class ClassName {
   public:
      // Friend function declaration.
      friend RetType funcName();
};

`friend` Classes

Explanation

A friend class is a non-member class that is granted access to the private and protected members of another class.
If the member functions of the friend class need to access non-static non-static members, the class instance should be passed to those functions.
If the member functions of the friend class access static members or perform operations unrelated to a specific object, the class instance does not need to be passed.

Syntax

class ClassA {
   public:
      friend class ClassB;   // Declaring ClassB as a friend
};

class ClassB {
   public:
      RetType funcName( const ClassA& obj ) { ... };
};

class ClassA {
   public:
      friend class ClassB;   // Declaring ClassB as a friend
};

class ClassB {
   public:
      RetType funcName() { ... };
};

`final`

Explanation

The final keyword in C++ is used to prevent further inheritance or overriding of classes and virtual functions.
It plays a crucial role in controlling the behavior of classes in the inheritance hierarchy.

`final` Functions

Explanation

A final function is a virtual function that cannot be overridden by any derived class.
The final specifier ensures that the function's implementation remains fixed in the class that declares it as final.
This feature can improve performance by devirtualizing calls to the final function, as the compiler can safely inline such calls, knowing that no further overrides exist and not add this function to vtable.

Syntax

class Base {
   public:
      virtual RetType funcName() final;   // Declaration of a final function.
};

`final` Classes

Explanation

A final class is a class that cannot be inherited from.
Declaring a class as final ensures that no further subclassing is allowed, which can prevent misuse of inheritance and unintended extensions of the class’s functionality.
This can improve runtime performance, as the compiler can optimize calls and remove virtual dispatch overhead.
final classes are often used for singleton patterns, utility classes, or performance-critical components to prevent inheritance overhead.

Syntax

class FinalClass final {};

// class Derived: public FinalClass {};   // Error: Cannot inherit from a final class

Notes

final functions should not be combined with the override keyword, but virtual methods in final classes should still be declared with the override keyword.
final classes do not need to contain functions with the final keyword.
Functions marked with override must be virtual functions.

`explicit`

explicit

`using`

using

Hiding, Overloading, Overriding, and Overwriting

Hiding, Overloading, Overriding, and Overwriting

Bitfields

Explanation

A bitfield in C++ is a data structure that allows you to allocate a specific number of bits for individual members within a struct or class.
This is particularly useful for saving memory when you need to store multiple small values that can fit into fewer bits than the size of the default data types (e.g., int, char).
Bitfields are commonly used for:
- Flags.
- Control registers.
- Packed data structures.
Type is an integral type (e.g., int, unsigned int, short).
mem_name is the name of the bitfield member.
num_of_bits is the number of bits allocated to this member.
The size of ClassName is equal to (memory alignment) ceil( (double)( num_of_bits1 + num_of_bits2 + ... ) / sizeof( maximum-size type ) ) * sizeof( maximum-size type );.
It's different from std::bitset.

Syntax

class ClassName {
   public:
      Type1 mem_name1: num_of_bits1;
      Type2 mem_name2: num_of_bits2;
      ...;
};

A Demonstration

// The complete example can be found in cpp_project_example.
#include <algorithm>
#include <future>
#include <iostream>
#include <mutex>
#include <random>
#include <vector>
#ifdef PRINT_MES
   #define OUTMES( inf ) std::cout << inf << std::endl;
#else
   #define OUTMES( inf ) ;
#endif
class Sort {
   public:
      virtual void operate() { return; };

      Sort() { OUTMES( "Default constructor." ); };

      Sort( const Sort& other ) {
         OUTMES( "Copy constructor." );
         if( this != &other ) {
            _vec = other.getVec();
         };
      };   // Not require move semenetatic.

      Sort( Sort&& other ) {
         OUTMES( "Move constructor." );
         if( this != &other ) {
            _vec = std::move( other.getVec() );
         };
      };   // Require move semenetatic.

      explicit Sort( const std::vector< int >& vec ): _vec{ vec } {
         OUTMES( "Parameterized constructor with copy." );
      };

      explicit Sort( std::vector< int >&& vec ): _vec{ std::move( vec ) } {
         OUTMES( "Parameterized constructor with move semenetatic." );
      };

      virtual ~Sort() = default;

      const std::vector< int >& getVec() const {
         OUTMES( "lvalue" );
         return _vec;
      };   // Not allow move sementatic.

      std::vector< int >&& getVec() {
         OUTMES( "rvalue" );
         return std::move( _vec );
      };   // Allow move sementatic.

      Sort& operator=( const Sort& other ) {
         OUTMES( "Copy assignment." );
         if( this != &other ) {
            _vec = other.getVec();
         };
         return *this;   // Allow chain assignment.
      };   // Not require move semenetatic.

      Sort& operator=( Sort&& other ) {
         OUTMES( "Move assignment." );
         if( this != &other ) {
            _vec = std::move( other.getVec() );
         };
         return *this;
      };   // Require move sementatic.

      // Friend function to overload `<<`
      // Why require `friend`:
      // The << operator is typically implemented as a non-member function
      // because the left-hand operand (std::ostream) is not part of the class.
      friend std::ostream& operator<<( std::ostream& os, const Sort& sort );

      Sort operator+( const Sort& other ) {
         OUTMES( "*This + other." );
         std::vector< int > res = _vec;
         if( _vec.size() == other.getVec().size() ) {
            for( size_t i = 0; i < _vec.size(); i++ ) {
               res[i] = res[i] + other.getVec()[i];
            }
         }
         return Sort( std::move( res ) );
      };

      Sort& operator+=( const Sort& other ) {
         OUTMES( "*This += other." );
         if( _vec.size() == other.getVec().size() ) {
            for( size_t i = 0; i < _vec.size(); i++ ) {
               _vec[i] += other.getVec()[i];
            }
         }
         return *this;   // Allow chain rules.
      };

      bool operator<( const Sort& other ) const {
         OUTMES( "*This < other?" );
         if( _vec.size() == other.getVec().size() ) {
            for( size_t i = 0; i < _vec.size(); i++ ) {
               return _vec[i] < other.getVec()[i];
            }
         }
         return _vec[0];
      };

      // Overload prefix increment (++x)
      Sort& operator++() {
         OUTMES( "++( *This )." );
         for( auto& val: _vec ) {
            ++val;
         };
         return *this;   // Return the updated object
      }

      // Overload postfix increment (x++)
      // The dummy `int` parameter differentiates the postfix increment from
      // prefix increment. The parameter is not used but is necessary for the
      // signature.
      Sort operator++( int ) {
         OUTMES( "( *This )++." );
         Sort temp = *this;   // Save the current state
         for( auto& val: _vec ) {
            ++val;
         };
         return temp;   // Return the original state
      }

   protected:
      std::vector< int > _vec;
};

// Implementation of `<<` operator
std::ostream& operator<<( std::ostream& os, const Sort& sort ) {
   os << "[ ";
   for( auto& ele: sort.getVec() ) {
      os << ele;
      os << " ";
   }
   os << "]";
   return os;
};

Notes

All destructors of base classes (parent classes) should be declared as virtual functions.
All functions of base classes (parent classes) that you intend to override in derived classes need to be declared as virtual.
The parameter of a copy constructor and copy assignment operator should not be passed by value, as this can lead to a issue, an infinite loop.

Files

Classes.md

Latest commit

History

Classes.md

File metadata and controls

Classes (class)

Explanation

Visibility

Declaration Syntax

Definition Syntax

Member Variables

Explanation

Syntax

this

Explanation

Syntax

const Member Variables

constexpr Member Variables

static Member Variables

mutable Member Variables

Explanation

Syntax

Pointer Member Variables

Explanation

Syntax

Reference Member Variables

Explanation

Syntax

Methods

Explanation

Syntax

const Methods (const Member Functions)

constexpr Methods (constexprt Member Functions)

static Methods (static Member Functions)

virtual Methods (virtual Functions) (virtual Memeber Functions)

Pure virtual Functions and Abstract Classes

override Methods

Explanation

Syntax

Notes

Constructors

Explanation

Syntax

Defalut Constructors and default Constructors

Explanation

Syntax

Parameterized Constructors

Explanation

Syntax

Constructor Initializer Lists

Explanation

Syntax

Differences between Traditional Initializer Lists and Modern Initializer Lists

Limitations of Aggregate Initialization

Notes

Copy Constructors

Explanation

Default Copy (default) (Avoid) (Double Destructions)

Explanation

Syntax

Shallow Copy (e.g. memcpy) (Avoid) (Double Destructions)

Explanation

Syntax

Deep Copy (Recommend)

Explanation

Syntax

Move Constructors

Explanation

Default Move Constructors

Explanation

Syntax

Custom Move Constructor

Explanation

Syntax

Conversion Constructors

Explanation

Syntax

virtual Constructors

explicit Constructors

Classes (`class`)

`this`

`const` Member Variables

`constexpr` Member Variables

`static` Member Variables

`mutable` Member Variables

`const` Methods (`const` Member Functions)

`constexpr` Methods (`constexprt` Member Functions)

`static` Methods (`static` Member Functions)

`virtual` Methods (`virtual` Functions) (`virtual` Memeber Functions)

Pure `virtual` Functions and Abstract Classes

`override` Methods

Defalut Constructors and `default` Constructors

Default Copy (`default`) (Avoid) (Double Destructions)

Shallow Copy (e.g. `memcpy`) (Avoid) (Double Destructions)

`virtual` Constructors

`explicit` Constructors

`virtual` Destructors

`const` Instance of Classes

`constexpr` Instances of Classes

`static` Instances of Classes

`explicit` Conversion Operator

`virtual` Inheritance

`virtual`

`virtual` Methods (`virtual` Functions) (`virtual` Memeber Functions)

Pure `virtual` Functions and Abstract Classes

`virtual` Destructors

`virtual` Inheritance

`friend`

`friend` Functions