[C++] クラスのメンバ変数を初期化リストで初期化する方法

Q: 初期化リストを使わないとどうなる？

初期化リストを使わずにメンバ変数を初期化すると、コンストラクタの本体内で代入を行うことになります。 この場合、constメンバ変数や参照メンバ変数は初期化できず、コンパイルエラーが発生します。 また、初期化リストを使用しない場合、メンバ変数の初期化が遅延するため、パフォーマンスが低下する可能性があります。 特に、クラス型のメンバ変数の場合、初期化リストを使わないと余分なデフォルトコンストラクタが呼ばれることになります。

C++では、クラスのメンバ変数を初期化リストを使って初期化することができます。

初期化リストは、コンストラクタの定義の際に、コンストラクタの引数リストの後にコロン : を付け、その後にメンバ変数を初期化する形式で記述します。

初期化リストを使うことで、メンバ変数がコンストラクタの本体が実行される前に初期化されます。

特に、定数メンバや参照メンバ、またはクラス型のメンバ変数を初期化する際に有効です。

この記事でわかること

初期化リストの基本的な使い方
constメンバ変数の初期化方法
参照メンバ変数の初期化の重要性
継承クラスでの初期化リストの活用
メンバ変数の依存関係に注意する必要性

目次から探す

初期化リストとは何か

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

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

特に、constメンバ変数や参照メンバ変数の初期化には初期化リストが必須です。

また、初期化リストを使うことで、メンバ変数の初期化順序を明示的に制御できるため、依存関係のあるメンバ変数の初期化においても役立ちます。

初期化リストは、クラス設計において重要な役割を果たします。

初期化リストの使い方

基本的な初期化リストの書き方

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

以下は基本的な書き方の例です。

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    double b;
public:
    MyClass(int x, double y) : a(x), b(y) { // 初期化リストを使用
        // コンストラクタの本体
    }
    void display() {
        cout << "a: " << a << ", b: " << b << endl;
    }
};
int main() {
    MyClass obj(10, 20.5);
    obj.display();
    return 0;
}

a: 10, b: 20.5

初期化リストを使用することで、メンバ変数aとbがコンストラクタの引数xとyで初期化されます。

複数のメンバ変数を初期化する方法

複数のメンバ変数を初期化する場合、初期化リスト内でカンマ,で区切って列挙します。

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

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    double b;
    string c;
public:
    MyClass(int x, double y, string z) : a(x), b(y), c(z) { // 複数のメンバ変数を初期化
    }
    void display() {
        cout << "a: " << a << ", b: " << b << ", c: " << c << endl;
    }
};
int main() {
    MyClass obj(10, 20.5, "Hello");
    obj.display();
    return 0;
}

a: 10, b: 20.5, c: Hello

このように、初期化リストを使うことで、複数のメンバ変数を一度に初期化できます。

コンストラクタのオーバーロードと初期化リスト

コンストラクタのオーバーロードを使用することで、異なる引数の組み合わせに応じて異なる初期化を行うことができます。

以下の例では、2つの異なるコンストラクタを定義しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    double b;
public:
    MyClass(int x) : a(x), b(0.0) { // 1つの引数を受け取るコンストラクタ
    }
    MyClass(int x, double y) : a(x), b(y) { // 2つの引数を受け取るコンストラクタ
    }
    void display() {
        cout << "a: " << a << ", b: " << b << endl;
    }
};
int main() {
    MyClass obj1(10);
    MyClass obj2(20, 30.5);
    obj1.display();
    obj2.display();
    return 0;
}

a: 10, b: 0
a: 20, b: 30.5

このように、オーバーロードされたコンストラクタを使用することで、異なる初期化が可能になります。

メンバ変数の順序に関する注意点

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

初期化リストでの順序は関係ありません。

以下の例で確認できます。

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    int b;
public:
    MyClass(int x, int y) : b(y), a(x) { // 初期化リストの順序は無関係
    }
    void display() {
        cout << "a: " << a << ", b: " << b << endl;
    }
};
int main() {
    MyClass obj(10, 20);
    obj.display();
    return 0;
}

a: 10, b: 20

この例では、初期化リストでbが先に初期化されていますが、aはクラス内での宣言順に初期化されます。

このため、メンバ変数の宣言順を意識して初期化を行うことが重要です。

初期化リストが必要な場合

constメンバ変数の初期化

constメンバ変数は、一度初期化されると変更できないため、初期化リストを使用してコンストラクタ内で初期化する必要があります。

以下の例では、constメンバ変数a`を初期化リストで初期化しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    const int a; // constメンバ変数
public:
    MyClass(int x) : a(x) { // 初期化リストで初期化
    }
    void display() {
        cout << "a: " << a << endl;
    }
};
int main() {
    MyClass obj(10);
    obj.display();
    return 0;
}

a: 10

このように、constメンバ変数は初期化リストを使わなければ初期化できません。

参照メンバ変数の初期化

参照メンバ変数も、初期化後に変更できないため、初期化リストを使用して初期化する必要があります。

以下の例では、参照メンバ変数bを初期化リストで初期化しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int& b; // 参照メンバ変数
public:
    MyClass(int& x) : b(x) { // 初期化リストで初期化
    }
    void display() {
        cout << "b: " << b << endl;
    }
};
int main() {
    int value = 20;
    MyClass obj(value);
    obj.display();
    return 0;
}

b: 20

このように、参照メンバ変数も初期化リストを使って初期化する必要があります。

クラス型メンバ変数の初期化

クラス型のメンバ変数も、初期化リストを使用して初期化することが推奨されます。

以下の例では、クラス型メンバ変数cを初期化リストで初期化しています。

#include <iostream>
using namespace std;
class InnerClass {
public:
    InnerClass() {
        cout << "InnerClassのコンストラクタ" << endl;
    }
};
class MyClass {
private:
    InnerClass c; // クラス型メンバ変数
public:
    MyClass() : c() { // 初期化リストで初期化
    }
};
int main() {
    MyClass obj;
    return 0;
}

InnerClassのコンストラクタ

このように、クラス型メンバ変数も初期化リストを使って初期化することで、適切にコンストラクタが呼び出されます。

メンバ変数が他のメンバ変数に依存する場合

メンバ変数が他のメンバ変数に依存する場合、初期化リストを使用して依存関係を考慮した順序で初期化することが重要です。

以下の例では、aがbに依存しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    int b;
public:
    MyClass(int x) : b(x), a(b + 10) { // aはbに依存している
    }
    void display() {
        cout << "a: " << a << ", b: " << b << endl;
    }
};
int main() {
    MyClass obj(20);
    obj.display();
    return 0;
}

a: 30, b: 20

このように、メンバ変数が他のメンバ変数に依存する場合は、初期化リストを使って正しい順序で初期化することが重要です。

初期化リストの応用例

継承クラスでの初期化リストの使用

継承クラスにおいても、初期化リストを使用して基底クラスのコンストラクタを呼び出すことができます。

以下の例では、基底クラスBaseのコンストラクタを初期化リストで呼び出しています。

#include <iostream>
using namespace std;
class Base {
protected:
    int baseValue;
public:
    Base(int x) : baseValue(x) { // 基底クラスのコンストラクタ
        cout << "Baseクラスのコンストラクタ" << endl;
    }
};
class Derived : public Base {
private:
    int derivedValue;
public:
    Derived(int x, int y) : Base(x), derivedValue(y) { // 初期化リストで基底クラスを初期化
        cout << "Derivedクラスのコンストラクタ" << endl;
    }
    void display() {
        cout << "baseValue: " << baseValue << ", derivedValue: " << derivedValue << endl;
    }
};
int main() {
    Derived obj(10, 20);
    obj.display();
    return 0;
}

Baseクラスのコンストラクタ
Derivedクラスのコンストラクタ
baseValue: 10, derivedValue: 20

このように、継承クラスでも初期化リストを使って基底クラスのメンバを初期化できます。

メンバ変数がポインタの場合の初期化

ポインタ型のメンバ変数を初期化する場合も、初期化リストを使用することが推奨されます。

以下の例では、ポインタ型メンバ変数ptrを初期化リストで初期化しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int* ptr; // ポインタ型メンバ変数
public:
    MyClass(int value) : ptr(new int(value)) { // 初期化リストでポインタを初期化
    }
    ~MyClass() {
        delete ptr; // メモリ解放
    }
    void display() {
        cout << "ptr: " << *ptr << endl;
    }
};
int main() {
    MyClass obj(30);
    obj.display();
    return 0;
}

ptr: 30

このように、ポインタ型メンバ変数も初期化リストを使って初期化することで、適切にメモリを確保できます。

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

デフォルト引数を使用する場合でも、初期化リストを組み合わせて使うことができます。

以下の例では、デフォルト引数を持つコンストラクタを定義しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int a;
    double b;
public:
    MyClass(int x = 0, double y = 0.0) : a(x), b(y) { // デフォルト引数と初期化リスト
    }
    void display() {
        cout << "a: " << a << ", b: " << b << endl;
    }
};
int main() {
    MyClass obj1; // デフォルト引数を使用
    MyClass obj2(10, 20.5); // 引数を指定
    obj1.display();
    obj2.display();
    return 0;
}

a: 0, b: 0
a: 10, b: 20.5

このように、デフォルト引数と初期化リストを組み合わせることで、柔軟な初期化が可能になります。

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

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

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

#include <iostream>
using namespace std;
template <typename T>
class MyTemplate {
private:
    T value; // テンプレート型メンバ変数
public:
    MyTemplate(T x) : value(x) { // 初期化リストで初期化
    }
    void display() {
        cout << "value: " << value << endl;
    }
};
int main() {
    MyTemplate<int> obj1(100);
    MyTemplate<double> obj2(200.5);
    obj1.display();
    obj2.display();
    return 0;
}