C++ Constructors and Destructors: All Types, Initializer Lists, Move Semantics & DSA (2025)

#include <iostream>
#include <string>
#include <utility>    // std::move
using namespace std;

class Student {
private:
    string name;
    int    id;
    int*   scores;   // heap resource

public:
    // 1. Default constructor
    Student() : name("Unknown"), id(0), scores(new int[3]()) {
        cout << "Default ctor\n";
    }

    // 2. Parameterized constructor
    Student(string n, int i) : name(move(n)), id(i), scores(new int[3]{90,85,88}) {
        cout << "Param ctor: " << name << "\n";
    }

    // 3. Copy constructor — DEEP copy
    Student(const Student& o)
        : name(o.name), id(o.id), scores(new int[3]) {
        for (int i=0; i<3; i++) scores[i] = o.scores[i];
        cout << "Copy ctor: " << name << "\n";
    }

    // 4. Move constructor — transfer, no copy
    Student(Student&& o) noexcept
        : name(move(o.name)), id(o.id), scores(o.scores) {
        o.scores = nullptr;  // leave moved-from object safe to destruct
        o.id     = 0;
        cout << "Move ctor: " << name << "\n";
    }

    // Destructor
    ~Student() {
        delete[] scores;   // safe: delete[] nullptr is a no-op
        cout << "Dtor: " << name << "\n";
    }

    void display() const {
        cout << name << " (id=" << id << "): ";
        if (scores) cout << scores[0] << " " << scores[1] << " " << scores[2];
        cout << "\n";
    }
};

int main() {
    Student s1;                         // default
    Student s2("Alice", 101);           // parameterized
    Student s3 = s2;                     // copy (deep)
    Student s4 = move(s2);              // move (s2 now empty)

    s3.display();
    s4.display();
    s2.display();
    return 0;
}

class Circle {
    const double PI;
    double&       area;
    double        r;

public:
    Circle(double& areaRef, double radius)
        : PI(3.14159),
          area(areaRef),
          r(radius)
    {
        area = PI * r * r;
    }
    double getR() const { return r; }
};

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

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

    Buffer(const Buffer& o) : n(o.n), data(new int[o.n]) {
        memcpy(data, o.data, n * sizeof(int));
        cout << "Deep copy of " << n << " ints\n";
    }

    Buffer& operator=(const Buffer& o) {
        if (this == &o) return *this;
        delete[] data;
        n = o.n; data = new int[n];
        memcpy(data, o.data, n * sizeof(int));
        return *this;
    }

    ~Buffer() { delete[] data; }
    int& operator[](int i) { return data[i]; }
    int  size() const { return n; }
};

int main() {
    Buffer a(3); a[0]=1; a[1]=2; a[2]=3;
    Buffer b = a;
    b[0] = 99;
    cout << a[0] << " " << b[0] << endl;  // 1 99
    return 0;
}

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

class BigArray {
    int* data;
    int  n;
public:
    BigArray(int size) : n(size), data(new int[size]()) {
        cout << "Allocated " << n << " ints\n";
    }
    BigArray(const BigArray& o) : n(o.n), data(new int[o.n]) {
        for (int i=0; i<n; i++) data[i] = o.data[i];
        cout << "Copied " << n << " ints (slow)\n";
    }
    BigArray(BigArray&& o) noexcept : n(o.n), data(o.data) {
        o.data = nullptr;
        o.n    = 0;
        cout << "Moved (O(1))\n";
    }
    ~BigArray() { delete[] data; }
    int size() const { return n; }
};

int main() {
    BigArray a(1000000);
    BigArray b = a;
    BigArray c = move(a);
    cout << "a.size()=" << a.size() << " c.size()=" << c.size() << endl;
    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() { cout << "Base dtor\n"; }
    virtual void show() { cout << "Base\n"; }
};

class Derived : public Base {
    int* resource;
public:
    Derived() : resource(new int(42)) { cout << "Derived ctor\n"; }
    ~Derived() {
        delete resource;
        cout << "Derived dtor (freed resource)\n";
    }
    void show() override { cout << "Derived\n"; }
};

int main() {
    Base* p = new Derived();
    p->show();
    delete p;
    return 0;
}

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

class ManagedFile {
    ofstream file;
public:
    ManagedFile(const string& path) {
        file.open(path);
        if (!file) throw runtime_error("Cannot open: " + path);
        cout << "File opened\n";
    }
    ~ManagedFile() {
        file.close();
        cout << "File closed (guaranteed by RAII)\n";
    }
    void write(const string& s) { file << s; }
};

void process() {
    ManagedFile f("out.txt");
    f.write("hello\n");
    throw runtime_error("Something went wrong");
}

int main() {
    try { process(); }
    catch (const exception& e) { cout << "Caught: " << e.what() << endl; }
    return 0;
}

class Radius {
public:
    explicit Radius(double r) : val(r) {}
    double val;
};

class Shape {
    double x, y, size;
public:
    Shape(double x, double y, double s) : x(x), y(y), size(s) {}
    Shape() : Shape(0, 0, 1) {}
    Shape(double s) : Shape(0, 0, s) {}
};

class Singleton {
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    Singleton() = default;
};

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

class CircularQueue {
    int* arr;
    int  cap, front, rear, sz;
public:
    explicit CircularQueue(int capacity)
        : cap(capacity), front(0), rear(-1), sz(0),
          arr(new int[capacity]) {
        cout << "Queue(cap=" << cap << ")\n";
    }
    CircularQueue(const CircularQueue& o)
        : cap(o.cap), front(o.front), rear(o.rear), sz(o.sz),
          arr(new int[o.cap]) {
        for (int i=0; i<cap; i++) arr[i] = o.arr[i];
        cout << "Queue copied\n";
    }
    ~CircularQueue() { delete[] arr; cout << "Queue destroyed\n"; }
    void enqueue(int v) {
        if (sz == cap) throw overflow_error("Queue full");
        rear = (rear + 1) % cap; arr[rear] = v; sz++;
    }
    int dequeue() {
        if (sz == 0) throw underflow_error("Queue empty");
        int v = arr[front]; front = (front + 1) % cap; sz--;
        return v;
    }
    int  size()    const { return sz; }
    bool isEmpty() const { return sz == 0; }
};

int main() {
    CircularQueue q(3);
    q.enqueue(1); q.enqueue(2); q.enqueue(3);
    cout << q.dequeue() << endl;
    CircularQueue q2 = q;
    cout << q2.dequeue() << endl;
    return 0;
}

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

struct BSTNode {
    int val;
    unique_ptr<BSTNode> left, right;
    explicit BSTNode(int v) : val(v) {}
};

class BST {
    unique_ptr<BSTNode> root;
    void insert_(BSTNode*& node, int v) {
        if (!node) { node = new BSTNode(v); return; }
        if (v < node->val) insert_((BSTNode*&)node->left, v);
        else               insert_((BSTNode*&)node->right, v);
    }
    void inorder_(const BSTNode* n) const {
        if (!n) return;
        inorder_(n->left.get());
        cout << n->val << " ";
        inorder_(n->right.get());
    }
public:
    void insert(int v) { insert_((BSTNode*&)root, v); }
    void inorder() const { inorder_(root.get()); cout << endl; }
};

int main() {
    BST t;
    for (int x : {5,2,7,1,3}) t.insert(x);
    t.inorder();
    return 0;
}