C++ Class

class ClassName {
    // By default, members are private in a C++ class
    int defaultPrivateMember; 

private:
    // Accessible only from within the class itself or by friend entities
    int privateData;

protected:
    // Accessible within the class and by derived (child) classes
    double protectedData;

public:
    // Accessible from anywhere the object is in scope
    
    // Default Constructor
    ClassName();

    // Parameterized Constructor
    explicit ClassName(int initialValue); 
    
    // Destructor
    ~ClassName(); 

    // Copy Constructor
    ClassName(const ClassName& other);

    // Copy Assignment Operator
    ClassName& operator=(const ClassName& other);

    // Move Constructor
    ClassName(ClassName&& other) noexcept;

    // Move Assignment Operator
    ClassName& operator=(ClassName&& other) noexcept;

    // Member function declaration
    void modifyState(int newValue); 
    
    // Const member function: Guarantees no modification to the object's state
    int getState() const; 
}; // A class definition must terminate with a semicolon

#include <utility>

// Out-of-line constructor implementation using a member initializer list
ClassName::ClassName(int initialValue) 
    : defaultPrivateMember(0), privateData(initialValue), protectedData(0.0) {
}

// Out-of-line move constructor implementation
ClassName::ClassName(ClassName&& other) noexcept
    : defaultPrivateMember(std::exchange(other.defaultPrivateMember, 0)),
      privateData(std::exchange(other.privateData, 0)),
      protectedData(std::exchange(other.protectedData, 0.0)) {
    // Resources are "stolen" from 'other', leaving 'other' in a valid but unspecified state
}

// Out-of-line destructor implementation
ClassName::~ClassName() {
    // Cleanup code
}

// Out-of-line member function implementation
void ClassName::modifyState(int newValue) {
    this->privateData = newValue; // 'this->' is optional but explicit
}

#include <memory>

int main() {
    // 1. Stack Allocation (Automatic Storage Duration)
    // Destroyed automatically when execution leaves the current scope.
    ClassName stackObject(10); 

    // 2. Heap Allocation (Dynamic Storage Duration)
    // Returns a pointer. Requires manual deallocation using 'delete'.
    ClassName* heapObject = new ClassName(20);
    delete heapObject; 

    // 3. Smart Pointers (Modern C++ Heap Allocation)
    // Automatically manages heap memory lifecycle via RAII.
    std::unique_ptr<ClassName> smartObject = std::make_unique<ClassName>(30);

    return 0;
}