C++ Constructors: Initialize Objects the Right Way

What a Constructor Is

On the previous page you defined classes and gave them member variables. But a freshly created object's members hold whatever garbage was in that memory unless you set them. A constructor fixes that: it's a special member function that runs automatically the moment an object is created, and its one job is to leave the object in a valid, fully-initialized state.

A constructor has the same name as the class and no return type - not even void. You never call it directly; the compiler calls it for you whenever an object comes into existence.

#include <iostream>
using namespace std;

class Counter {
public:
    int value;

    Counter() {          // constructor: same name as the class, no return type
        value = 0;
        cout << "Counter created\n";
    }
};

int main() {
    Counter c;           // the constructor runs right here
    cout << c.value << "\n";   // 0, not garbage
    return 0;
}

The Counter() with no parameters is called the default constructor - it's the one used when you create an object without passing any arguments.

Parameterized Constructors

A constructor that takes no arguments is fine, but usually you want to create an object with specific values. A parameterized constructor accepts arguments and uses them to initialize the members.

#include <iostream>
using namespace std;

class Point {
public:
    int x;
    int y;

    Point(int startX, int startY) {
        x = startX;
        y = startY;
    }
};

int main() {
    Point p(3, 4);                // pass the values at creation
    cout << p.x << ", " << p.y << "\n";   // 3, 4
    return 0;
}

A class can have more than one constructor, as long as their parameter lists differ - this is ordinary function overloading applied to constructors. Here Point can be created with or without coordinates:

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point() {            // default constructor
        x = 0;
        y = 0;
    }

    Point(int startX, int startY) {   // parameterized constructor
        x = startX;
        y = startY;
    }
};

int main() {
    Point origin;        // calls Point()
    Point p(3, 4);       // calls Point(int, int)

    cout << origin.x << ", " << origin.y << "\n";  // 0, 0
    cout << p.x << ", " << p.y << "\n";            // 3, 4
    return 0;
}

A common gotcha: Point p(); does not create an object - the compiler reads it as the declaration of a function named p that returns a Point. To call the default constructor, write Point p; (no parentheses) or Point p{}; with braces.

Member Initializer Lists

So far the examples assigned to members inside the constructor body. That works for simple types, but it's the wrong tool. By the time the body runs, every member has already been default-constructed; the body then throws that away and assigns over it. A member initializer list initializes each member directly, before the body, in one step.

The syntax is a colon after the parameter list, then member(value) pairs:

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

class User {
public:
    string name;
    int age;

    User(string n, int a) : name(n), age(a) {   // initializer list
        // body can stay empty
    }
};

int main() {
    User u("Ada", 36);
    cout << u.name << " is " << u.age << "\n";   // Ada is 36
    return 0;
}

For a string member this also avoids constructing an empty string and then assigning - the initializer list builds it correctly on the first try.

The initializer list isn't just an optimization; it's mandatory in three cases, because the body can only assign, not initialize:

• const members - you can't assign to a const after it exists.
• Reference members - a reference must be bound when it's born.
• Members whose type has no default constructor.

class Sensor {
    const int id;        // const member
    int& slot;           // reference member

public:
    Sensor(int sensorId, int& s) : id(sensorId), slot(s) {}
    // Trying to set id or slot in the body would not compile.
};

One subtlety to know: members are initialized in the order they are declared in the class, not the order you list them in the initializer list. If one member's initializer reads another, declaration order is what matters - mismatching the two is a classic source of using a not-yet-initialized value.

Default Arguments and Delegating Constructors

You don't always need separate overloads. Default arguments let a single constructor cover several cases - omit an argument and the default fills in:

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point(int startX = 0, int startY = 0) : x(startX), y(startY) {}
};

int main() {
    Point a;          // 0, 0
    Point b(5);       // 5, 0
    Point c(5, 9);    // 5, 9

    cout << a.x << "," << a.y << "  "
         << b.x << "," << b.y << "  "
         << c.x << "," << c.y << "\n";
    return 0;
}

Be careful combining a defaulted parameterized constructor with a separate Point() default constructor - the compiler can't tell which to call for Point p; and will report an ambiguity. Pick one approach.

When you do have multiple constructors that share setup, a delegating constructor (C++11) lets one constructor call another instead of repeating the logic. You "delegate" by putting the other constructor in the initializer list:

#include <iostream>
using namespace std;

class Rectangle {
public:
    int width, height;

    Rectangle(int w, int h) : width(w), height(h) {
        cout << "full constructor\n";
    }

    Rectangle() : Rectangle(1, 1) {   // delegates to the constructor above
        cout << "default delegated\n";
    }
};

int main() {
    Rectangle r;                      // runs full constructor, then default body
    cout << r.width << "x" << r.height << "\n";   // 1x1
    return 0;
}

The Copy Constructor

When you create an object as a copy of another - by passing it by value, returning it, or writing Foo b = a; - the copy constructor runs. Its signature takes a const reference to the same type:

ClassName(const ClassName& other);

If you don't write one, the compiler generates a default copy constructor that copies each member. For classes holding only values (ints, strings, vectors), that's exactly right and you should not write your own.

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

class Box {
public:
    string label;
    int size;

    Box(string l, int s) : label(l), size(s) {}

    // Custom copy constructor, here just to see it fire:
    Box(const Box& other) : label(other.label + " (copy)"), size(other.size) {
        cout << "copy made\n";
    }
};

int main() {
    Box original("widget", 10);
    Box duplicate = original;      // copy constructor runs

    cout << duplicate.label << " " << duplicate.size << "\n";  // widget (copy) 10
    return 0;
}

The big gotcha lives in the next chapter on memory: if your class owns a raw pointer to heap memory, the default copy constructor copies the pointer, not the data - so two objects end up pointing at the same memory, and both will try to free it. That's the double-free bug. The rule of thumb is the Rule of Three/Five: if you write a custom destructor, you almost certainly need a custom copy constructor (and copy assignment) too. In modern C++ the cleaner fix is to hold a std::vector or smart pointer so the compiler-generated copy just works.

Note also that taking the parameter by reference is required, not optional: a copy constructor that took its argument by value would need to copy the argument to call itself - infinite recursion that won't even compile.

Next: Destructors

A constructor sets an object up; a destructor tears it down. When an object goes out of scope or is deleted, its destructor runs automatically - the perfect place to release files, network connections, or heap memory the object was holding. The next page covers how destructors work, when exactly they fire, and how they pair with constructors to give C++ its powerful RAII pattern.