C++ Classes and Objects: Complete Guide — Constructors, Destructors, Encapsulation & DSA (2025)

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    string name;
    int    id;

public:
    // Parameterized constructor with initializer list
    Student(string n, int i) : name(n), id(i) {
        cout << "Constructor: " << name << endl;
    }

    // Destructor
    ~Student() {
        cout << "Destructor:  " << name << endl;
    }

    // Const method — cannot modify *this
    void display() const {
        cout << "Name: " << name << ", ID: " << id << endl;
    }

    void   setName(string n) { name = n; }
    string getName() const  { return name; }
};

int main() {
    // Stack object — destroyed when scope ends
    Student s1("Alice", 101);
    s1.display();               // dot operator

    // Heap object — destroyed when we delete
    Student* s2 = new Student("Bob", 102);
    s2->display();              // arrow operator
    s2->setName("Robert");
    s2->display();
    delete s2;                  // destructor called here

    // s1 destructor called here (scope end)
    return 0;
}

#include <iostream>
using namespace std;

class DynamicArray {
    int* data;
    int  size;
public:
    DynamicArray(int n) : size(n), data(new int[n]()) {
        // new int[n]() zero-initializes the array
        cout << "Allocated " << n << " ints\n";
    }

    ~DynamicArray() {
        delete[] data;  // [] required for arrays — not delete data
        cout << "Freed array of size " << size << "\n";
    }

    int& operator[](int i) { return data[i]; }
    int  getSize() const    { return size; }
};

int main() {
    {   // inner scope
        DynamicArray arr(5);
        arr[0] = 10; arr[1] = 20;
        cout << arr[0] << " " << arr[1] << endl;
    }   // ← destructor called here automatically
    cout << "Back in outer scope\n";
    return 0;
}

#include <iostream>
#include <stdexcept>
using namespace std;

class BankAccount {
private:
    double balance;
    string owner;

public:
    BankAccount(string owner, double initial)
        : owner(owner), balance(initial) {}

    // const getter — returns a copy; const objects can call this
    double getBalance() const { return balance; }
    string getOwner()  const { return owner; }

    // Validated setter — encapsulation enforces invariant
    void deposit(double amount) {
        if (amount <= 0) throw invalid_argument("Deposit must be positive");
        balance += amount;
    }

    void withdraw(double amount) {
        if (amount > balance) throw runtime_error("Insufficient funds");
        balance -= amount;
    }

    // 'this' used to disambiguate and for method chaining
    BankAccount& setOwner(string owner) {
        this->owner = owner;  // 'this->owner' = member, 'owner' = param
        return *this;         // enables chaining: acc.setOwner("X").deposit(100)
    }

    void display() const {
        cout << owner << ": $" << balance << endl;
    }
};

int main() {
    BankAccount acc("Alice", 1000.0);
    acc.deposit(500.0);
    acc.withdraw(200.0);
    acc.display();

    // Method chaining using *this
    acc.setOwner("Alice Smith").deposit(100.0);
    acc.display();

    try {
        acc.withdraw(99999.0);  // throws — balance protected
    } catch(const exception& e) {
        cout << "Error: " << e.what() << endl;
    }
    return 0;
}

#include <iostream>
#include <cstring>   // memcpy
using namespace std;

class Buffer {
    int* data;
    int  size;
public:
    Buffer(int n) : size(n), data(new int[n]()) {}

    // 1. Destructor
    ~Buffer() { delete[] data; }

    // 2. Copy constructor — DEEP copy
    Buffer(const Buffer& o) : size(o.size), data(new int[o.size]) {
        memcpy(data, o.data, size * sizeof(int));
    }

    // 3. Copy assignment — deep copy + self-assignment guard
    Buffer& operator=(const Buffer& o) {
        if (this == &o) return *this;  // self-assignment guard
        delete[] data;
        size = o.size;
        data = new int[size];
        memcpy(data, o.data, size * sizeof(int));
        return *this;
    }

    int& operator[](int i) { return data[i]; }
    int  getSize() const   { return size; }
};

int main() {
    Buffer a(3); a[0]=1; a[1]=2; a[2]=3;
    Buffer b = a;    // copy constructor — DEEP copy
    b[0] = 99;       // modifying b should NOT affect a
    cout << a[0] << endl;  // 1 — independent copy ✓
    cout << b[0] << endl;  // 99
    return 0;
}

// struct: plain data record, no invariants to enforce
struct Point {
    double x, y;              // public by default — fine for plain data
};

// struct in competitive programming — custom comparator for Kruskal's
struct Edge {
    int u, v, w;
    bool operator<(const Edge& e) const { return w < e.w; }
};

// class: complex object with invariants — private data, public interface
class BankAccount {
private:
    double balance;  // invariant: balance >= 0 enforced by methods
public:
    void deposit(double a);    // validates before modifying
    void withdraw(double a);   // validates before modifying
};

#include <iostream>
using namespace std;

class LinkedList {
private:
    struct Node {      // nested private struct
        int data;
        Node* next;
        Node(int v) : data(v), next(nullptr) {}
    };
    Node* head;
    int   sz;

public:
    LinkedList() : head(nullptr), sz(0) {}

    ~LinkedList() {           // destructor frees all nodes
        while (head) {
            Node* t = head;
            head = head->next;
            delete t;
        }
    }

    void push_front(int v) {
        Node* n = new Node(v);
        n->next = head;
        head = n; sz++;
    }

    void push_back(int v) {
        Node* n = new Node(v);
        if (!head) { head = n; sz++; return; }
        Node* cur = head;
        while (cur->next) cur = cur->next;
        cur->next = n; sz++;
    }

    void display() const {
        for (Node* c = head; c; c = c->next)
            cout << c->data << " → ";
        cout << "null\n";
    }
    int size() const { return sz; }
};

int main() {
    LinkedList lst;
    lst.push_back(1); lst.push_back(2); lst.push_back(3);
    lst.push_front(0);
    lst.display();
    cout << "Size: " << lst.size() << endl;
    return 0;  // destructor frees all nodes
}

#include <iostream>
#include <stdexcept>
using namespace std;

template<typename T, int MAX = 100>
class Stack {
    T   arr[MAX];
    int top;
public:
    Stack() : top(-1) {}

    void push(const T& v) {
        if (top == MAX-1) throw overflow_error("Stack full");
        arr[++top] = v;
    }
    T pop() {
        if (isEmpty()) throw underflow_error("Stack empty");
        return arr[top--];
    }
    const T& peek() const {
        if (isEmpty()) throw underflow_error("Stack empty");
        return arr[top];
    }
    bool isEmpty() const { return top == -1; }
    int  size()    const { return top + 1; }
};

int main() {
    Stack<int> s;
    s.push(10); s.push(20); s.push(30);
    cout << "Top: " << s.peek() << endl;
    while (!s.isEmpty()) cout << s.pop() << " ";
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;

struct BST {
    int  val;
    BST* left  = nullptr;
    BST* right = nullptr;
    BST(int v) : val(v) {}

    static BST* insert(BST* root, int v) {
        if (!root) return new BST(v);
        if (v < root->val) root->left  = insert(root->left,  v);
        else               root->right = insert(root->right, v);
        return root;
    }

    static void inorder(BST* root) {
        if (!root) return;
        inorder(root->left);
        cout << root->val << " ";
        inorder(root->right);
    }
};

int main() {
    BST* root = nullptr;
    for (int x : {5,3,7,1,4,6,8}) root = BST::insert(root, x);
    cout << "Inorder: ";
    BST::inorder(root);
    cout << endl;
    return 0;
}