Constructors and destructors

Why constructors?

An object should be valid from the very first moment: a Student without a roll number, or a Ticket with a negative fare, should never exist. A constructor is a member function with the same name as the class and no return type. C++ calls it automatically every time an object is created.

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

class Ticket {
public:
    Ticket(std::string passenger, int farePaise)
        : passenger_(std::move(passenger)), farePaise_(farePaise) {   // member initialiser list
        if (farePaise_ < 0) throw std::invalid_argument("negative fare");
    }
    void print() const { std::cout << passenger_ << ": " << farePaise_ / 100 << '\n'; }
private:
    std::string passenger_;
    int farePaise_;
};

int main() {
    Ticket t("Asha", 145050);
    t.print();                     // Asha: 1450
    // Ticket bad;                 // error: no default constructor
}

The member initialiser list

Members are always initialised BEFORE the constructor body runs. If you assign them inside the body, each member is first default-constructed and then overwritten, which is wasteful. Some members can only be set in the initialiser list: const members, reference members, and members whose type has no default constructor.

Default constructor and default member values

class Counter {
public:
    Counter() = default;          // use the default member values below
    explicit Counter(int start) : count_(start) {}
    int value() const { return count_; }
private:
    int count_ = 0;               // default member initialiser (C++11)
};

Counter a;        // 0
Counter b(10);    // 10
Counter c{5};     // 5, brace initialisation

explicit

A constructor that takes one argument can be used by the compiler to convert silently: void show(Counter c); show(42); would build a Counter from 42 behind your back. Marking the constructor explicit forbids those silent conversions. Make single-argument constructors explicit unless you really want the conversion.

Destructors

#include <iostream>

class Lamp {
public:
    explicit Lamp(int id) : id_(id) { std::cout << "Lamp " << id_ << " on\n"; }
    ~Lamp() { std::cout << "Lamp " << id_ << " off\n"; }
private:
    int id_;
};

int main() {
    Lamp a(1);
    {
        Lamp b(2);
    }                       // b is destroyed here
    std::cout << "end of main\n";
}                           // a is destroyed here
// Output:
// Lamp 1 on
// Lamp 2 on
// Lamp 2 off
// end of main
// Lamp 1 off

A destructor has no parameters and no return type, and a class has exactly one. You almost never call it yourself; C++ calls it at the end of the object's lifetime (end of scope for local objects, delete for heap objects, or when the containing object or container is destroyed).

Common mistakes

• Writing Ticket t(); to create an object with no arguments. That declares a FUNCTION named t (the "most vexing parse"). Write Ticket t; or Ticket t{};.
• Forgetting to initialise a member such as an int, leaving garbage. Give every member a default value.
• Doing heavy work that can fail silently in a constructor. If construction cannot produce a valid object, throw an exception.
• Throwing exceptions out of a destructor. Destructors are noexcept by default; a throw from one usually ends the program.