C++ Constructors and Destructors Explained — With Real-World Patterns

#include <iostream>
#include <string>

class BankAccount {
private:
    std::string ownerName;
    double balance;
    int accountNumber;

public:
    // DEFAULT CONSTRUCTOR — called when no arguments are provided
    // Use this when a 'blank' account makes sense in your domain
    BankAccount()
        : ownerName("Unknown"), balance(0.0), accountNumber(0) {
        std::cout << "[Default Constructor] Empty account created.\n";
    }

    // PARAMETERISED CONSTRUCTOR — called with specific initial values
    // This is the most common type you'll write in real code
    BankAccount(const std::string& name, double initialDeposit, int accNum)
        : ownerName(name), balance(initialDeposit), accountNumber(accNum) {
        // The initialiser list above sets members BEFORE the constructor body runs
        // This is more efficient than assigning inside the body
        std::cout << "[Parameterised Constructor] Account created for "
                  << ownerName << " with balance $" << balance << "\n";
    }

    void printDetails() const {
        std::cout << "Account #" << accountNumber
                  << " | Owner: " << ownerName
                  << " | Balance: $" << balance << "\n";
    }
};

int main() {
    // Calls the DEFAULT constructor
    BankAccount emptyAccount;

    // Calls the PARAMETERISED constructor
    BankAccount aliceAccount("Alice Johnson", 5000.00, 10042);

    emptyAccount.printDetails();
    aliceAccount.printDetails();

    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>

// RAII in action: this class manages a log file.
// The file opens in the constructor and closes in the destructor —
// no matter how the function using it exits.
class FileLogger {
private:
    std::ofstream logFile;  // the resource we're managing
    std::string   filePath;

public:
    // CONSTRUCTOR: acquire the resource
    explicit FileLogger(const std::string& path) : filePath(path) {
        logFile.open(filePath, std::ios::app);
        if (!logFile.is_open()) {
            // Throwing from a constructor is correct — the object won't exist
            // if construction fails, so the destructor won't run (no double-close)
            throw std::runtime_error("Could not open log file: " + filePath);
        }
        std::cout << "[Constructor] Log file opened: " << filePath << "\n";
    }

    // DESTRUCTOR: release the resource automatically
    ~FileLogger() {
        if (logFile.is_open()) {
            logFile.close();
            // This runs even if an exception was thrown elsewhere in the program
            std::cout << "[Destructor] Log file closed: " << filePath << "\n";
        }
    }

    void log(const std::string& message) {
        logFile << message << "\n";
        std::cout << "[Log] " << message << "\n";
    }

    // Delete copy operations — a file handle shouldn't be shared
    FileLogger(const FileLogger&)            = delete;
    FileLogger& operator=(const FileLogger&) = delete;
};

void runAppSession() {
    // logger is a stack object — its destructor runs when this function returns
    FileLogger logger("app_session.log");
    logger.log("Session started.");
    logger.log("User logged in: alice@example.com");
    // Imagine an early return or exception here — the file STILL closes correctly
}  // <-- destructor fires here automatically

int main() {
    std::cout << "--- Starting session ---\n";
    runAppSession();
    std::cout << "--- Session ended, file safely closed ---\n";
    return 0;
}

#include <iostream>
#include <cstring>   // for memcpy
#include <utility>   // for std::move

// A class that owns a heap-allocated buffer — classic Rule of Five scenario
class ManagedBuffer {
private:
    char* data;    // raw resource we own
    size_t size;

public:
    // --- CONSTRUCTOR ---
    explicit ManagedBuffer(size_t bufferSize)
        : size(bufferSize), data(new char[bufferSize]()) {
        std::cout << "[Constructor] Allocated " << size << " bytes at "
                  << static_cast<void*>(data) << "\n";
    }

    // --- DESTRUCTOR ---
    ~ManagedBuffer() {
        std::cout << "[Destructor] Freeing memory at "
                  << static_cast<void*>(data) << "\n";
        delete[] data;  // always use delete[] for arrays
        data = nullptr; // defensive: prevents dangling pointer use-after-free
    }

    // --- COPY CONSTRUCTOR (deep copy) ---
    // Without this, both objects point to the same memory — double-free waiting to happen
    ManagedBuffer(const ManagedBuffer& other)
        : size(other.size), data(new char[other.size]) {
        std::memcpy(data, other.data, size);  // copy the actual data, not just the pointer
        std::cout << "[Copy Constructor] Copied " << size << " bytes to "
                  << static_cast<void*>(data) << "\n";
    }

    // --- COPY ASSIGNMENT OPERATOR ---
    ManagedBuffer& operator=(const ManagedBuffer& other) {
        if (this == &other) return *this;  // self-assignment guard — always include this
        delete[] data;                     // release old resource before taking new one
        size = other.size;
        data = new char[size];
        std::memcpy(data, other.data, size);
        std::cout << "[Copy Assignment] Assigned " << size << " bytes\n";
        return *this;
    }

    // --- MOVE CONSTRUCTOR (transfer ownership, no allocation needed) ---
    ManagedBuffer(ManagedBuffer&& other) noexcept
        : size(other.size), data(other.data) {
        other.data = nullptr;  // leave the source in a valid but empty state
        other.size = 0;
        std::cout << "[Move Constructor] Ownership transferred\n";
    }

    // --- MOVE ASSIGNMENT OPERATOR ---
    ManagedBuffer& operator=(ManagedBuffer&& other) noexcept {
        if (this == &other) return *this;
        delete[] data;           // release what we currently own
        data = other.data;       // steal the resource
        size = other.size;
        other.data = nullptr;    // neutralise the source
        other.size = 0;
        std::cout << "[Move Assignment] Ownership transferred\n";
        return *this;
    }

    size_t getSize() const { return size; }
};

int main() {
    ManagedBuffer original(256);

    std::cout << "\n-- Deep Copy --\n";
    ManagedBuffer copyOfOriginal(original);  // calls Copy Constructor

    std::cout << "\n-- Move (no allocation) --\n";
    ManagedBuffer movedBuffer(std::move(original));  // calls Move Constructor
    // 'original' is now empty (data == nullptr) — safe but don't use it

    std::cout << "\n-- Cleanup --\n";
    // All three destructors run here — each frees its own memory safely
    return 0;
}