Class Access Control

C++ classes utilize three levels of access control: public, private, and protected.

• Internal Access: Members within a class can access any class member, regardless of its access specifier.
• External Access: Code outside the class can only interact with public members.
• Structural Defaults: Structures (struct) default to public access, whereas classes default to private.

Constructor and Destructor Lifecycle

Constructors and destructors are special member functions that manage object initialization and cleanup, respectively.

• Constructors: Executed automatically upon object creation. They share the class name, lack a return type, and can be overloaded. It is best practice to avoid complex logic inside constructors; focus strictly on initialization.
• Destructors: Executed automatically before object destruction. They are prefixed with a tilde (~), accept no parameters, and cannot be overloaded. While manual invocation is possible, it is rarely necessary in standard RAII patterns.

Copy Constructors

When a new object is initialized from an existing one, the copy constructor is invoked. If not explicitly defined, the compiler generates a shallow-copy constructor. For classes managing dynamic resources (pointers), a custom deep-copy constructor is mandatory to avoid double-free errors or memory corruption.

class DataContainer {
public:
    int* m_buffer;
    DataContainer(const DataContainer& other) {
        m_buffer = new int(*other.m_buffer);
    }
    ~DataContainer() {
        delete m_buffer;
    }
};

Initialization Lists

Initialization lists are the preferred method for member initialization. They occur before the constructor body executes, providing performance benefits by avoiding redundant assignments and enabling the initialization of const members and references.

class User {
    const int m_id;
public:
    User(int id) : m_id(id) {}
};

Const Member Functions

Marking a member function as const indicates that it does not modify the object's state. The mutable keyword can be used to allow specific members to be modified even with in const functions, which is useful for internal caching or logging mechanisms.

Static Members

Static members belong to the class rather than individual instances. They are shared across all objects of the class and must be defined outside the class scope. Static member functions can only access static members and do not possess a this pointer.

Operator Overloading

Operators can be overloaded to provide intuitive syntax for custom types. Key rules include:

• Certain operators (e.g., =, [], (), ->) must be overloaded as member functions.
• The original precedence and associativity of operators remain unchanged.
• New operators cannot be created.

Inheritance and Polymorphism

Inheritance facilitates code reuse and hierarchical design.

• Polymorphism: By declaring functions as virtual in the base class, derived classes can override them to exhibit specific behaviors.
• Abstract Classes: A class containing at least one pure virtual function (virtual void func() = 0;) is considered abstract and cannot be instantiated.

Smart Pointers

Modern C++ manages memory via smart poitners, which implement RAII to automate resource cleanup:

• std::unique_ptr: Represents exclusive ownership.
• std::shared_ptr: Implements reference counting for shared ownership.
• std::weak_ptr: Provides non-owning access to an object managed by shared_ptr, preventing circular dependencies.

Template Programming

Templates allow for generic programming, enabling functions and classes to operate on any data type. Specific implementations can be provided through template specialization, while auto and decltype facilitate type deduction in complex scenarios.