Constructors & Destructors

Rule of Three / Five (overview)

• **Rule of Three:** if you need a custom destructor, copy constructor, or copy assignment — you usually need all three.
• **Rule of Five:** also consider move constructor and move assignment in modern C++.
• **Rule of Zero:** design types so default special members are enough (use RAII members).

=default and =delete

• Class() = default; asks the compiler to generate the default constructor.
• Class(const Class&) = delete; forbids copying (useful for unique ownership).
• Deleting copy is common for resource handles and unique_ptr-like types.

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

Delegating and converting constructors (overview)

• A constructor can call another constructor of the same class (delegating) in C++11.
• A single-argument constructor can act as a conversion — mark explicit to block surprising implicit conversions.

class Degree {
    int value;
public:
    explicit Degree(int v) : value(v) {}
};

Default constructor message

#include <iostream>
using namespace std;

class Hello {
public:
    Hello() { cout << "Hello constructed\n"; }
    ~Hello() { cout << "Hello destroyed\n"; }
};

int main() {
    Hello h;
    return 0;
}

Parameterized Rectangle

#include <iostream>
using namespace std;

class Rectangle {
    int l, w;
public:
    Rectangle(int a, int b) : l(a), w(b) {}
    int area() const { return l * w; }
};

int main() {
    Rectangle r(4, 6);
    cout << r.area() << "\n";
    return 0;
}

Overloaded constructors

#include <iostream>
using namespace std;

class Timer {
    int seconds;
public:
    Timer() : seconds(0) {}
    Timer(int s) : seconds(s) {}
    Timer(int m, int s) : seconds(m * 60 + s) {}
    int get() const { return seconds; }
};

int main() {
    Timer a, b(10), c(1, 5);
    cout << a.get() << " " << b.get() << " " << c.get() << "\n";
    return 0;
}

Copy constructor demo

#include <iostream>
using namespace std;

class Num {
    int v;
public:
    Num(int x) : v(x) {}
    Num(const Num& n) : v(n.v) { cout << "copied\n"; }
    int get() const { return v; }
};

int main() {
    Num a(7);
    Num b(a);
    cout << b.get() << "\n";
    return 0;
}

Destructor reverse order

#include <iostream>
using namespace std;

class A {
    char id;
public:
    A(char c) : id(c) { cout << "Ctor " << id << "\n"; }
    ~A() { cout << "Dtor " << id << "\n"; }
};

int main() {
    A x('X');
    A y('Y');
    return 0;
}

Initializer list with const member

#include <iostream>
using namespace std;

class Badge {
    const int id;
public:
    Badge(int i) : id(i) {}
    int getId() const { return id; }
};

int main() {
    Badge b(42);
    cout << b.getId() << "\n";
    return 0;
}

Simple RAII buffer

#include <iostream>
using namespace std;

class Buffer {
    int* data;
public:
    Buffer(int n) : data(new int[n]{}) {
        cout << "allocated\n";
    }
    ~Buffer() {
        delete[] data;
        cout << "freed\n";
    }
};

int main() {
    Buffer buf(10);
    return 0;
}