クラス

[C++] コンストラクタの後ろにコロンを付ける意味と使い方

2025-01-18更新日: 2025-01-18

C++において、コンストラクタの後ろにコロンを付けるのは「メンバ初期化リスト」を使用するためです。

これは、クラスのメンバ変数をコンストラクタの本体が実行される前に初期化するための構文です。

特に、定数メンバや参照メンバ、または親クラスのコンストラクタを呼び出す場合に必要です。

例えば、MyClass(int x) : memberVar(x) {}のように使います。

メンバ初期化リストを使うことで、効率的な初期化が可能になります。

目次から探す

メンバ初期化リストとは何か
メンバ初期化リストの使い方
メンバ初期化リストが必要なケース
メンバ初期化リストの応用例
メンバ初期化リストの注意点
まとめ

メンバ初期化リストとは何か

C++におけるメンバ初期化リストは、クラスのコンストラクタ内でメンバ変数を初期化するための特別な構文です。

通常、コンストラクタの本体内でメンバ変数に値を代入することが一般的ですが、メンバ初期化リストを使用することで、より効率的に初期化を行うことができます。

特に、定数メンバや参照メンバの初期化には必須であり、親クラスのコンストラクタを呼び出す際にも利用されます。

このリストを使うことで、初期化の順序やパフォーマンスを最適化することが可能です。

メンバ初期化リストの使い方

基本的な使い方

メンバ初期化リストは、コンストラクタの引数リストの後にコロンを付け、その後に初期化したいメンバ変数を指定します。

以下は基本的な使い方の例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int x;
    MyClass(int value) : x(value) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(10);
    cout << "xの値: " << obj.x << endl;
    return 0;
}

xの値: 10

複数のメンバ変数を初期化する場合

複数のメンバ変数を初期化する場合は、カンマで区切って指定します。

以下の例では、2つのメンバ変数を初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int x;
    int y;
    MyClass(int value1, int value2) : x(value1), y(value2) { // 複数のメンバを初期化
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(10, 20);
    cout << "xの値: " << obj.x << ", yの値: " << obj.y << endl;
    return 0;
}

xの値: 10, yの値: 20

親クラスのコンストラクタ呼び出し

メンバ初期化リストを使用して、親クラスのコンストラクタを呼び出すこともできます。

以下の例では、親クラスのコンストラクタに引数を渡しています。

#include <iostream>
using namespace std;
class Base {
public:
    Base(int value) {
        cout << "Baseのコンストラクタ: " << value << endl;
    }
};
class Derived : public Base {
public:
    Derived(int value) : Base(value) { // 親クラスのコンストラクタを呼び出し
        // コンストラクタの本体
    }
};
int main() {
    Derived obj(30);
    return 0;
}

Baseのコンストラクタ: 30

定数メンバや参照メンバの初期化

定数メンバや参照メンバは、メンバ初期化リストを使用しないと初期化できません。

以下の例では、定数メンバを初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    const int x; // 定数メンバ
    MyClass(int value) : x(value) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(50);
    cout << "xの値: " << obj.x << endl;
    return 0;
}

xの値: 50

メンバ初期化リストを使わない場合の挙動

メンバ初期化リストを使わずにメンバ変数を初期化すると、コンストラクタの本体内で代入が行われます。

この場合、初期化の順序が異なるため、意図しない結果を招くことがあります。

以下の例を見てみましょう。

#include <iostream>
using namespace std;
class MyClass {
public:
    int x;
    MyClass(int value) {
        x = value; // メンバ初期化リストを使用しない
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(70);
    cout << "xの値: " << obj.x << endl;
    return 0;
}

xの値: 70

この場合、出力結果は問題ありませんが、初期化の順序やパフォーマンスに影響を与える可能性があります。

特に、定数メンバや参照メンバを使用する場合は、メンバ初期化リストを使用することが重要です。

メンバ初期化リストが必要なケース

定数メンバの初期化

C++では、定数メンバは初期化時に一度だけ値を設定でき、その後は変更できません。

定数メンバを初期化するためには、メンバ初期化リストを使用する必要があります。

以下の例では、定数メンバを初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    const int x; // 定数メンバ
    MyClass(int value) : x(value) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(100);
    cout << "xの値: " << obj.x << endl;
    return 0;
}

xの値: 100

参照メンバの初期化

参照メンバも初期化時に一度だけ値を設定でき、その後は変更できません。

参照メンバを初期化するためにも、メンバ初期化リストが必要です。

以下の例では、参照メンバを初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int& ref; // 参照メンバ
    MyClass(int& value) : ref(value) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    int a = 200;
    MyClass obj(a);
    cout << "refの値: " << obj.ref << endl;
    return 0;
}

refの値: 200

クラスメンバがオブジェクトの場合

クラスメンバが他のクラスのオブジェクトである場合、そのオブジェクトの初期化にはメンバ初期化リストが必要です。

以下の例では、別のクラスのオブジェクトをメンバとして持つクラスを示しています。

#include <iostream>
using namespace std;
class InnerClass {
public:
    int value;
    InnerClass(int v) : value(v) { // コンストラクタ
    }
};
class OuterClass {
public:
    InnerClass inner; // InnerClassのオブジェクト
    OuterClass(int v) : inner(v) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    OuterClass obj(300);
    cout << "inner.valueの値: " << obj.inner.value << endl;
    return 0;
}

inner.valueの値: 300

親クラスのコンストラクタ呼び出しが必要な場合

派生クラスが親クラスのコンストラクタを呼び出す必要がある場合、メンバ初期化リストを使用して親クラスのコンストラクタを指定します。

以下の例では、親クラスのコンストラクタに引数を渡しています。

#include <iostream>
using namespace std;
class Base {
public:
    Base(int value) {
        cout << "Baseのコンストラクタ: " << value << endl;
    }
};
class Derived : public Base {
public:
    Derived(int value) : Base(value) { // 親クラスのコンストラクタを呼び出し
        // コンストラクタの本体
    }
};
int main() {
    Derived obj(400);
    return 0;
}

Baseのコンストラクタ: 400

パフォーマンスの観点からの必要性

メンバ初期化リストを使用することで、オブジェクトの初期化が効率的に行われます。

特に、オブジェクトが複雑な場合や、初期化にコストがかかる場合には、メンバ初期化リストを使用することでパフォーマンスが向上します。

以下の例では、メンバ初期化リストを使用してパフォーマンスを最適化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* data; // 動的メモリを使用するメンバ
    MyClass(int size) : data(new int[size]) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
    ~MyClass() {
        delete[] data; // メモリ解放
    }
};
int main() {
    MyClass obj(5);
    cout << "オブジェクトが作成されました。" << endl;
    return 0;
}

オブジェクトが作成されました。

このように、メンバ初期化リストを使用することで、初期化の効率を高め、パフォーマンスを向上させることができます。

メンバ初期化リストの応用例

複雑なクラスの初期化

複雑なクラスの初期化では、複数のメンバ変数を効率的に初期化するためにメンバ初期化リストが役立ちます。

以下の例では、複数のメンバ変数を持つクラスを示しています。

#include <iostream>
#include <string>
using namespace std;
class ComplexClass {
public:
    int a;
    double b;
    string c;
    ComplexClass(int x, double y, const string& str) 
        : a(x), b(y), c(str) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    ComplexClass obj(1, 2.5, "Hello");
    cout << "a: " << obj.a << ", b: " << obj.b << ", c: " << obj.c << endl;
    return 0;
}

a: 1, b: 2.5, c: Hello

デフォルト引数とメンバ初期化リストの組み合わせ

デフォルト引数を使用することで、コンストラクタの引数を省略可能にし、メンバ初期化リストと組み合わせることができます。

以下の例では、デフォルト引数を使用しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int x;
    MyClass(int value = 10) : x(value) { // デフォルト引数とメンバ初期化リスト
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj1; // デフォルト引数を使用
    MyClass obj2(20); // 引数を指定
    cout << "obj1のx: " << obj1.x << ", obj2のx: " << obj2.x << endl;
    return 0;
}

obj1のx: 10, obj2のx: 20

メンバ初期化リストと例外処理

メンバ初期化リストを使用することで、例外が発生した場合の処理を簡潔に行うことができます。

以下の例では、メンバ初期化リストを使用して例外処理を行っています。

#include <iostream>
#include <stdexcept>
using namespace std;
class MyClass {
public:
    int* data;
    MyClass(int size) : data(new int[size]) { // メンバ初期化リストを使用
        if (size <= 0) {
            throw invalid_argument("サイズは正の整数でなければなりません。");
        }
    }
    ~MyClass() {
        delete[] data; // メモリ解放
    }
};
int main() {
    try {
        MyClass obj(-5); // 例外を発生させる
    } catch (const exception& e) {
        cout << "エラー: " << e.what() << endl;
    }
    return 0;
}

エラー: サイズは正の整数でなければなりません。

テンプレートクラスでのメンバ初期化リストの使用

テンプレートクラスでもメンバ初期化リストを使用することができます。

以下の例では、テンプレートクラスを使用してメンバ変数を初期化しています。

#include <iostream>
using namespace std;
template <typename T>
class MyTemplateClass {
public:
    T value;
    MyTemplateClass(T v) : value(v) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyTemplateClass<int> obj1(100);
    MyTemplateClass<double> obj2(3.14);
    cout << "obj1のvalue: " << obj1.value << ", obj2のvalue: " << obj2.value << endl;
    return 0;
}

obj1のvalue: 100, obj2のvalue: 3.14

スマートポインタとメンバ初期化リスト

スマートポインタを使用する場合も、メンバ初期化リストが便利です。

以下の例では、std::unique_ptrを使用してメンバ変数を初期化しています。

#include <iostream>
#include <memory>
using namespace std;
class MyClass {
public:
    unique_ptr<int> data; // スマートポインタ
    MyClass(int value) : data(make_unique<int>(value)) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(500);
    cout << "dataの値: " << *obj.data << endl;
    return 0;
}

dataの値: 500

このように、メンバ初期化リストはさまざまなケースで応用可能であり、効率的な初期化を実現します。

メンバ初期化リストの注意点

初期化順序に関する注意

C++では、メンバ変数の初期化は、クラス内で宣言された順序に従って行われます。

メンバ初期化リストでの順序は、初期化の順序に影響を与えません。

以下の例では、初期化の順序に注意が必要です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int a;
    int b;
    MyClass(int x, int y) : b(y), a(x) { // 初期化順序は宣言順
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(1, 2);
    cout << "a: " << obj.a << ", b: " << obj.b << endl;
    return 0;
}

a: 1, b: 2

この場合、aはbよりも先に宣言されているため、aが先に初期化されます。

初期化の順序に注意が必要です。

メンバ変数の依存関係

メンバ変数が他のメンバ変数に依存している場合、初期化の順序に注意が必要です。

依存関係がある場合、初期化順序が正しくないと、未初期化の値を使用することになります。

以下の例を見てみましょう。

#include <iostream>
using namespace std;
class MyClass {
public:
    int a;
    int b;
    MyClass(int x) : a(x), b(a + 1) { // bはaに依存
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(5);
    cout << "a: " << obj.a << ", b: " << obj.b << endl;
    return 0;
}

a: 5, b: 6

この場合、bはaに依存しているため、正しい初期化が行われていますが、依存関係が複雑になると注意が必要です。

メンバ初期化リストとデフォルトコンストラクタの関係

デフォルトコンストラクタを使用する場合、メンバ初期化リストを使用しないと、メンバ変数はデフォルト値で初期化されます。

以下の例では、デフォルトコンストラクタを使用しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int a;
    MyClass() : a(10) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj;
    cout << "aの値: " << obj.a << endl;
    return 0;
}

aの値: 10

デフォルトコンストラクタを使用する場合、メンバ初期化リストを使うことで、明示的に初期化が可能です。

メンバ初期化リストでの型変換

メンバ初期化リストを使用する際、型変換に注意が必要です。

特に、異なる型の値を初期化する場合、暗黙の型変換が行われることがあります。

以下の例では、型変換の注意点を示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    double value;
    MyClass(int x) : value(x) { // intからdoubleへの型変換
        // コンストラクタの本体
    }
};
int main() {
    MyClass obj(5);
    cout << "valueの値: " << obj.value << endl;
    return 0;
}

valueの値: 5

この場合、intからdoubleへの型変換が行われていますが、意図しない結果を招く可能性があるため、注意が必要です。

メンバ初期化リストとポインタの扱い

ポインタをメンバ変数として持つクラスでは、メンバ初期化リストを使用してポインタを初期化することが重要です。

以下の例では、ポインタを初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* ptr;
    MyClass(int value) : ptr(new int(value)) { // メンバ初期化リストを使用
        // コンストラクタの本体
    }
    ~MyClass() {
        delete ptr; // メモリ解放
    }
};
int main() {
    MyClass obj(10);
    cout << "ptrの値: " << *obj.ptr << endl;
    return 0;
}