C++のコンストラクタ：オブジェクトを正しく初期化する

コンストラクタとは

前のページでは、クラスを定義してメンバ変数を持たせました。しかし、生成したばかりのオブジェクトのメンバは、あなたが値を設定しない限り、そのメモリにたまたまあったゴミを保持します。コンストラクタはこれを解決します。コンストラクタは、オブジェクトが生成された瞬間に自動的に実行される特別なメンバ関数であり、その唯一の役割は、オブジェクトを有効で完全に初期化された状態にしておくことです。

コンストラクタはクラスと同じ名前を持ち、戻り値の型を持ちません——voidですらありません。あなたがコンストラクタを直接呼ぶことはありません。オブジェクトが存在するようになるたびに、コンパイラが代わりに呼び出します。

#include <iostream>
using namespace std;

class Counter {
public:
    int value;

    Counter() {          // コンストラクタ：クラスと同じ名前、戻り値の型なし
        value = 0;
        cout << "Counter created\n";
    }
};

int main() {
    Counter c;           // ここでコンストラクタが実行される
    cout << c.value << "\n";   // ゴミではなく 0
    return 0;
}

パラメータを持たないCounter()はデフォルトコンストラクタと呼ばれます——引数を渡さずにオブジェクトを生成するときに使われるものです。

引数付きコンストラクタ

引数を取らないコンストラクタでも問題ありませんが、たいていは特定の値を「もった」オブジェクトを生成したいものです。引数付きコンストラクタは引数を受け取り、それを使ってメンバを初期化します。

#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);                // 生成時に値を渡す
    cout << p.x << ", " << p.y << "\n";   // 3, 4
    return 0;
}

クラスは、引数リストが異なる限り、複数のコンストラクタを持てます——これはコンストラクタに適用された通常の関数のオーバーロードです。ここではPointを座標ありでも座標なしでも生成できます。

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point() {            // デフォルトコンストラクタ
        x = 0;
        y = 0;
    }

    Point(int startX, int startY) {   // 引数付きコンストラクタ
        x = startX;
        y = startY;
    }
};

int main() {
    Point origin;        // Point() を呼ぶ
    Point p(3, 4);       // Point(int, int) を呼ぶ

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

よくある落とし穴：Point p();はオブジェクトを生成しません——コンパイラはこれを、Pointを返すpという名前の関数の宣言として読み取ります。デフォルトコンストラクタを呼ぶには、Point p;（括弧なし）または波括弧を使ったPoint p{};と書きます。

メンバ初期化リスト

これまでの例では、コンストラクタの本体の「中」でメンバに代入していました。単純な型ではこれでも動きますが、適切な手段ではありません。本体が実行される時点で、各メンバはすでにデフォルト構築されています。本体はそれを捨てて、上書き代入しているのです。メンバ初期化リストは、本体より前に、各メンバを一度の手順で直接初期化します。

構文は、パラメータリストのあとにコロンを置き、続けてmember(value)のペアを並べます。

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

class User {
public:
    string name;
    int age;

    User(string n, int a) : name(n), age(a) {   // 初期化リスト
        // 本体は空のままでよい
    }
};

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

stringメンバの場合、これは空の文字列を構築してから代入するという手間も避けられます——初期化リストは最初の一回で正しく構築します。

初期化リストは単なる最適化ではありません。本体は代入はできても初期化はできないため、次の3つのケースでは必須です。

• constメンバ——constは一度存在してしまうと代入できません。
• 参照メンバ——参照は生まれた瞬間に束縛されなければなりません。
• 型がデフォルトコンストラクタを持たないメンバ。

class Sensor {
    const int id;        // const メンバ
    int& slot;           // 参照メンバ

public:
    Sensor(int sensorId, int& s) : id(sensorId), slot(s) {}
    // id や slot を本体で設定しようとするとコンパイルできない。
};

知っておくべき微妙な点：メンバはクラス内で宣言された順序で初期化され、初期化リストに並べた順序では初期化されません。あるメンバの初期化子が別のメンバを読む場合に重要なのは宣言順であり、両者を取り違えると、まだ初期化されていない値を使ってしまうという典型的なバグの原因になります。

デフォルト引数と委譲コンストラクタ

別々のオーバーロードが常に必要なわけではありません。デフォルト引数を使えば、一つのコンストラクタで複数のケースをカバーできます——引数を省略すると、デフォルト値が埋めてくれます。

#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;
}

デフォルト値を持つ引数付きコンストラクタと、別個のPoint()デフォルトコンストラクタを組み合わせるときは注意してください——コンパイラはPoint p;に対してどちらを呼べばよいか判断できず、あいまいだと報告します。どちらか一方の方法を選んでください。

共通のセットアップを共有する複数のコンストラクタがある場合、委譲コンストラクタ（C++11）を使えば、ロジックを繰り返す代わりに、あるコンストラクタが別のコンストラクタを呼び出せます。もう一方のコンストラクタを初期化リストに置くことで「委譲」します。

#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) {   // 上のコンストラクタに委譲する
        cout << "default delegated\n";
    }
};

int main() {
    Rectangle r;                      // フルのコンストラクタを実行し、その後デフォルトの本体を実行
    cout << r.width << "x" << r.height << "\n";   // 1x1
    return 0;
}

コピーコンストラクタ

あるオブジェクトを別のオブジェクトのコピーとして生成するとき——値渡しで渡したり、返したり、Foo b = a;と書いたりするとき——コピーコンストラクタが実行されます。そのシグネチャは、同じ型へのconst参照を取ります。

ClassName(const ClassName& other);

自分で書かなければ、コンパイラは各メンバをコピーするデフォルトのコピーコンストラクタを生成します。値（int、string、vector）だけを保持するクラスでは、それがまさに正しい挙動であり、自前のものを書くべきではありません。

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

class Box {
public:
    string label;
    int size;

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

    // カスタムのコピーコンストラクタ。ここでは動作を確認するためだけのもの：
    Box(const Box& other) : label(other.label + " (copy)"), size(other.size) {
        cout << "copy made\n";
    }
};

int main() {
    Box original("widget", 10);
    Box duplicate = original;      // コピーコンストラクタが実行される

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

大きな落とし穴は、メモリを扱う次の章にあります。クラスがヒープメモリへの生ポインタを所有している場合、デフォルトのコピーコンストラクタはデータではなくポインタをコピーします——その結果、2つのオブジェクトが同じメモリを指すことになり、両方がそれを解放しようとします。これがダブルフリー（二重解放）のバグです。経験則は「三/五の規則」です。カスタムのデストラクタを書くなら、ほぼ確実にカスタムのコピーコンストラクタ（およびコピー代入）も必要になります。現代的なC++では、より洗練された解決策はstd::vectorやスマートポインタを保持することで、コンパイラが生成するコピーがそのまま正しく動くようにすることです。

もう一点、パラメータを参照で受け取ることは任意ではなく必須です。引数を値で受け取るコピーコンストラクタは、自分自身を呼び出すために引数をコピーしなければならず——それは無限再帰となり、そもそもコンパイルすら通りません。

次は：デストラクタ

コンストラクタはオブジェクトを組み立て、デストラクタはそれを片付けます。オブジェクトがスコープを抜けるか削除されると、そのデストラクタが自動的に実行されます——オブジェクトが保持していたファイル、ネットワーク接続、ヒープメモリを解放するのに最適な場所です。次のページでは、デストラクタがどのように動くのか、正確にいつ起動するのか、そしてC++に強力なRAIIパターンをもたらすためにコンストラクタとどう対になるのかを扱います。