MENU
  1. ホーム
  2. C++
  3. 基礎構文
  4. クラス
  5. [C++] クラスを初期化する方法まとめ

[C++] クラスを初期化する方法まとめ

C++でクラスを初期化する方法にはいくつかの手法があります。

まず、コンストラクタを使用してオブジェクトを初期化します。

コンストラクタはクラス名と同じ名前を持ち、戻り値を持ちません。

引数なしのデフォルトコンストラクタ、引数を取るパラメータ化されたコンストラクタ、メンバ初期化リストを使った初期化が一般的です。

また、C++11以降では、= defaultを使ってデフォルトコンストラクタを明示的に定義したり、= deleteでコンストラクタを削除することも可能です。

この記事でわかること
  • クラスの初期化方法の基本を把握
  • C++11以降の新しい初期化手法
  • 特殊な初期化方法の活用法
  • クラスの初期化における注意点
  • 応用例を通じた実践的な理解

目次から探す

クラスの基本的な初期化方法

デフォルトコンストラクタ

デフォルトコンストラクタは、引数を持たないコンストラクタです。

クラスのインスタンスを生成する際に、特に初期値を指定しない場合に使用されます。

以下は、デフォルトコンストラクタの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() { // デフォルトコンストラクタ
        cout << "デフォルトコンストラクタが呼ばれました。" << endl;
    }
};
int main() {
    MyClass obj; // インスタンス生成
    return 0;
}
デフォルトコンストラクタが呼ばれました。

パラメータ化されたコンストラクタ

パラメータ化されたコンストラクタは、引数を受け取るコンストラクタです。

これにより、インスタンス生成時に特定の値を設定できます。

以下は、パラメータ化されたコンストラクタの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = v;
        cout << "値が設定されました: " << value << endl;
    }
};
int main() {
    MyClass obj(10); // インスタンス生成
    return 0;
}
値が設定されました: 10

コピーコンストラクタ

コピーコンストラクタは、同じクラスの別のオブジェクトから新しいオブジェクトを生成するためのコンストラクタです。

オブジェクトのコピーを作成する際に使用されます。

以下は、コピーコンストラクタの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = v;
    }
    
    MyClass(const MyClass &obj) { // コピーコンストラクタ
        value = obj.value;
        cout << "コピーコンストラクタが呼ばれました: " << value << endl;
    }
};
int main() {
    MyClass obj1(20); // インスタンス生成
    MyClass obj2 = obj1; // コピー
    return 0;
}
コピーコンストラクタが呼ばれました: 20

ムーブコンストラクタ

ムーブコンストラクタは、リソースを別のオブジェクトから移動するためのコンストラクタです。

C++11以降で導入され、効率的なリソース管理が可能です。

以下は、ムーブコンストラクタの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* value;
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = new int(v);
        cout << "値が設定されました: " << *value << endl;
    }
    
    MyClass(MyClass &&obj) { // ムーブコンストラクタ
        value = obj.value;
        obj.value = nullptr; // 元のオブジェクトのポインタを無効化
        cout << "ムーブコンストラクタが呼ばれました: " << *value << endl;
    }
    
    ~MyClass() { // デストラクタ
        delete value;
    }
};
int main() {
    MyClass obj1(30); // インスタンス生成
    MyClass obj2 = std::move(obj1); // ムーブ
    return 0;
}
値が設定されました: 30
ムーブコンストラクタが呼ばれました: 30

メンバ初期化リスト

メンバ初期化リストは、コンストラクタの初期化リストを使用してメンバ変数を初期化する方法です。

これにより、初期化の順序を明示的に指定できます。

以下は、メンバ初期化リストの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value1;
    int value2;
    
    MyClass(int v1, int v2) : value1(v1), value2(v2) { // メンバ初期化リスト
        cout << "値が設定されました: " << value1 << ", " << value2 << endl;
    }
};
int main() {
    MyClass obj(40, 50); // インスタンス生成
    return 0;
}
値が設定されました: 40, 50

コンストラクタのオーバーロード

コンストラクタのオーバーロードは、同じクラス内で異なる引数を持つ複数のコンストラクタを定義することです。

これにより、異なる初期化方法を提供できます。

以下は、コンストラクタのオーバーロードの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    
    MyClass() { // デフォルトコンストラクタ
        value = 0;
        cout << "デフォルトコンストラクタが呼ばれました: " << value << endl;
    }
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = v;
        cout << "値が設定されました: " << value << endl;
    }
};
int main() {
    MyClass obj1; // デフォルトコンストラクタ
    MyClass obj2(60); // パラメータ化されたコンストラクタ
    return 0;
}
デフォルトコンストラクタが呼ばれました: 0
値が設定されました: 60

C++11以降の新しい初期化方法

デリゲートコンストラクタ

デリゲートコンストラクタは、あるコンストラクタから別のコンストラクタを呼び出す機能です。

これにより、コードの重複を避けることができます。

以下は、デリゲートコンストラクタの例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value1;
    int value2;
    
    MyClass(int v1) : MyClass(v1, 0) { // デリゲートコンストラクタ
        cout << "1つの引数のコンストラクタが呼ばれました: " << value1 << endl;
    }
    
    MyClass(int v1, int v2) : value1(v1), value2(v2) { // 2つの引数のコンストラクタ
        cout << "2つの引数のコンストラクタが呼ばれました: " << value1 << ", " << value2 << endl;
    }
};
int main() {
    MyClass obj1(10); // 1つの引数のコンストラクタ
    MyClass obj2(20, 30); // 2つの引数のコンストラクタ
    return 0;
}
1つの引数のコンストラクタが呼ばれました: 10
2つの引数のコンストラクタが呼ばれました: 20, 30

= defaultによるデフォルトコンストラクタの明示

= defaultを使用することで、デフォルトコンストラクタを明示的に定義できます。

これにより、コンパイラが自動生成するデフォルトコンストラクタを使用することができます。

以下は、その例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() = default; // デフォルトコンストラクタを明示的に定義
    
    void display() {
        cout << "デフォルトコンストラクタが呼ばれました。" << endl;
    }
};
int main() {
    MyClass obj; // インスタンス生成
    obj.display(); // メソッド呼び出し
    return 0;
}
デフォルトコンストラクタが呼ばれました。

= deleteによるコンストラクタの削除

= deleteを使用することで、特定のコンストラクタを無効化できます。

これにより、意図しないオブジェクトの生成を防ぐことができます。

以下は、その例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() = delete; // デフォルトコンストラクタを削除
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        cout << "値が設定されました: " << v << endl;
    }
};
int main() {
    // MyClass obj; // エラー: デフォルトコンストラクタが削除されている
    MyClass obj(10); // 正常: パラメータ化されたコンストラクタ
    return 0;
}
値が設定されました: 10

メンバ変数の直接初期化

C++11以降では、クラスのメンバ変数を直接初期化することができます。

これにより、コンストラクタ内での初期化が不要になります。

以下は、その例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value1 = 100; // メンバ変数の直接初期化
    int value2 = 200; // メンバ変数の直接初期化
    
    void display() {
        cout << "値: " << value1 << ", " << value2 << endl;
    }
};
int main() {
    MyClass obj; // インスタンス生成
    obj.display(); // メソッド呼び出し
    return 0;
}
値: 100, 200

ユニフォーム初期化(ブレース初期化)

ユニフォーム初期化は、ブレースを使用してオブジェクトを初期化する方法です。

この方法は、初期化の一貫性を保ち、エラーを防ぐのに役立ちます。

以下は、その例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value1;
    int value2;
    
    MyClass(int v1, int v2) : value1(v1), value2(v2) {} // コンストラクタ
    
    void display() {
        cout << "値: " << value1 << ", " << value2 << endl;
    }
};
int main() {
    MyClass obj{10, 20}; // ユニフォーム初期化
    obj.display(); // メソッド呼び出し
    return 0;
}
値: 10, 20

特殊な初期化方法

静的メンバの初期化

静的メンバは、クラスに属するが、クラスのインスタンスに依存しないメンバです。

静的メンバは、クラスの外で初期化する必要があります。

以下は、静的メンバの初期化の例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    static int staticValue; // 静的メンバの宣言
    
    MyClass() {
        cout << "インスタンスが生成されました。" << endl;
    }
};
int MyClass::staticValue = 100; // 静的メンバの初期化
int main() {
    MyClass obj; // インスタンス生成
    cout << "静的メンバの値: " << MyClass::staticValue << endl; // 静的メンバのアクセス
    return 0;
}
インスタンスが生成されました。
静的メンバの値: 100

定数メンバの初期化

定数メンバは、クラス内で定義された定数で、初期化はクラスの外で行う必要があります。

以下は、定数メンバの初期化の例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    static const int constValue; // 定数メンバの宣言
};
const int MyClass::constValue = 50; // 定数メンバの初期化
int main() {
    cout << "定数メンバの値: " << MyClass::constValue << endl; // 定数メンバのアクセス
    return 0;
}
定数メンバの値: 50

参照メンバの初期化

参照メンバは、初期化時に必ず初期値を指定する必要があります。

参照メンバは、コンストラクタの初期化リストを使用して初期化します。

以下は、参照メンバの初期化の例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int& refValue; // 参照メンバの宣言
    
    MyClass(int& v) : refValue(v) { // コンストラクタでの初期化
        cout << "参照メンバが初期化されました: " << refValue << endl;
    }
};
int main() {
    int value = 30;
    MyClass obj(value); // インスタンス生成
    return 0;
}
参照メンバが初期化されました: 30

継承クラスの初期化

継承クラスの初期化では、基底クラスのコンストラクタを呼び出す必要があります。

これにより、基底クラスのメンバが正しく初期化されます。

以下は、継承クラスの初期化の例です。

#include <iostream>
using namespace std;
class BaseClass {
public:
    BaseClass() {
        cout << "基底クラスのコンストラクタが呼ばれました。" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    DerivedClass() {
        cout << "派生クラスのコンストラクタが呼ばれました。" << endl;
    }
};
int main() {
    DerivedClass obj; // インスタンス生成
    return 0;
}
基底クラスのコンストラクタが呼ばれました。
派生クラスのコンストラクタが呼ばれました。

仮想関数を持つクラスの初期化

仮想関数を持つクラスの初期化では、基底クラスのコンストラクタが呼ばれた後に、派生クラスのコンストラクタが呼ばれます。

これにより、正しいオブジェクトの初期化が行われます。

以下は、仮想関数を持つクラスの初期化の例です。

#include <iostream>
using namespace std;
class BaseClass {
public:
    BaseClass() {
        cout << "基底クラスのコンストラクタが呼ばれました。" << endl;
    }
    
    virtual void display() { // 仮想関数
        cout << "基底クラスの表示" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    DerivedClass() {
        cout << "派生クラスのコンストラクタが呼ばれました。" << endl;
    }
    
    void display() override { // オーバーライド
        cout << "派生クラスの表示" << endl;
    }
};
int main() {
    DerivedClass obj; // インスタンス生成
    obj.display(); // メソッド呼び出し
    return 0;
}
基底クラスのコンストラクタが呼ばれました。
派生クラスのコンストラクタが呼ばれました。
派生クラスの表示

クラスの初期化における注意点

メンバ初期化リストの順序

メンバ初期化リストの順序は、クラスのメンバ変数が初期化される順序を決定します。

初期化リストに記載された順序ではなく、クラス内で宣言された順序で初期化されるため、注意が必要です。

以下は、メンバ初期化リストの順序に関する例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value1;
    int value2;
    
    MyClass(int v1, int v2) : value2(v2), value1(v1) { // 初期化リストの順序
        cout << "value1: " << value1 << ", value2: " << value2 << endl;
    }
};
int main() {
    MyClass obj(10, 20); // インスタンス生成
    return 0;
}
value1: 10, value2: 20

コピーコンストラクタとムーブコンストラクタの違い

コピーコンストラクタは、オブジェクトのコピーを作成するために使用されます。

一方、ムーブコンストラクタは、リソースを別のオブジェクトに移動するために使用されます。

これにより、効率的なリソース管理が可能になります。

以下は、両者の違いを示す例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* value;
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = new int(v);
        cout << "値が設定されました: " << *value << endl;
    }
    
    MyClass(const MyClass &obj) { // コピーコンストラクタ
        value = new int(*obj.value);
        cout << "コピーコンストラクタが呼ばれました: " << *value << endl;
    }
    
    MyClass(MyClass &&obj) { // ムーブコンストラクタ
        value = obj.value;
        obj.value = nullptr; // 元のオブジェクトのポインタを無効化
        cout << "ムーブコンストラクタが呼ばれました: " << *value << endl;
    }
    
    ~MyClass() { // デストラクタ
        delete value;
    }
};
int main() {
    MyClass obj1(30); // インスタンス生成
    MyClass obj2 = obj1; // コピー
    MyClass obj3 = std::move(obj1); // ムーブ
    return 0;
}
値が設定されました: 30
コピーコンストラクタが呼ばれました: 30
ムーブコンストラクタが呼ばれました: 30

メモリリークの防止

メモリリークは、動的に確保したメモリが解放されないことによって発生します。

クラスのデストラクタを適切に実装し、動的に確保したメモリを解放することで、メモリリークを防ぐことができます。

以下は、メモリリークを防ぐための例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* value;
    
    MyClass(int v) { // パラメータ化されたコンストラクタ
        value = new int(v);
    }
    
    ~MyClass() { // デストラクタ
        delete value; // メモリの解放
    }
};
int main() {
    MyClass obj(40); // インスタンス生成
    return 0; // プログラム終了時にメモリが解放される
}
(出力はありませんが、メモリリークは発生しません)

初期化と代入の違い

初期化は、オブジェクトが生成される際に値を設定することを指し、代入は既存のオブジェクトに新しい値を設定することを指します。

初期化はコンストラクタを通じて行われ、代入は代入演算子を使用して行われます。

以下は、初期化と代入の違いを示す例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    
    MyClass(int v) : value(v) { // 初期化
        cout << "初期化されました: " << value << endl;
    }
};
int main() {
    MyClass obj(50); // 初期化
    obj.value = 100; // 代入
    cout << "代入後の値: " << obj.value << endl; // 出力
    return 0;
}
初期化されました: 50
代入後の値: 100

応用例：クラスの初期化を活用する

シングルトンパターンでの初期化

シングルトンパターンは、クラスのインスタンスが1つだけであることを保証するデザインパターンです。

以下は、シングルトンパターンを用いたクラスの初期化の例です。

#include <iostream>
using namespace std;
class Singleton {
private:
    static Singleton* instance; // インスタンスのポインタ
    Singleton() { // コンストラクタはプライベート
        cout << "シングルトンインスタンスが生成されました。" << endl;
    }
public:
    static Singleton* getInstance() { // インスタンス取得メソッド
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr; // 静的メンバの初期化
int main() {
    Singleton* s1 = Singleton::getInstance(); // インスタンス取得
    Singleton* s2 = Singleton::getInstance(); // 同じインスタンスを取得
    return 0;
}
シングルトンインスタンスが生成されました。

ファクトリーパターンでの初期化

ファクトリーパターンは、オブジェクトの生成を専門のファクトリーメソッドに委譲するデザインパターンです。

以下は、ファクトリーパターンを用いたクラスの初期化の例です。

#include <iostream>
using namespace std;
class Product {
public:
    virtual void use() = 0; // 純粋仮想関数
};
class ConcreteProduct : public Product {
public:
    void use() override {
        cout << "ConcreteProductが使用されました。" << endl;
    }
};
class Factory {
public:
    static Product* createProduct() { // ファクトリーメソッド
        return new ConcreteProduct(); // ConcreteProductのインスタンスを生成
    }
};
int main() {
    Product* product = Factory::createProduct(); // インスタンス生成
    product->use(); // メソッド呼び出し
    delete product; // メモリ解放
    return 0;
}
ConcreteProductが使用されました。

テンプレートクラスの初期化

テンプレートクラスは、型に依存しないクラスを定義するための機能です。

以下は、テンプレートクラスを用いた初期化の例です。

#include <iostream>
using namespace std;
template <typename T>
class MyTemplateClass {
private:
    T value;
    
public:
    MyTemplateClass(T v) : value(v) { // コンストラクタ
        cout << "値が設定されました: " << value << endl;
    }
};
int main() {
    MyTemplateClass<int> intObj(10); // int型のインスタンス生成
    MyTemplateClass<double> doubleObj(20.5); // double型のインスタンス生成
    return 0;
}
値が設定されました: 10
値が設定されました: 20.5

スマートポインタを使った初期化

スマートポインタは、動的メモリ管理を簡素化し、メモリリークを防ぐためのクラスです。

以下は、std::unique_ptrを用いたクラスの初期化の例です。

#include <iostream>
#include <memory> // スマートポインタ用
using namespace std;
class MyClass {
public:
    MyClass() {
        cout << "MyClassのインスタンスが生成されました。" << endl;
    }
    
    ~MyClass() {
        cout << "MyClassのインスタンスが解放されました。" << endl;
    }
};
int main() {
    unique_ptr<MyClass> ptr = make_unique<MyClass>(); // スマートポインタによる初期化
    return 0; // スマートポインタが自動的にメモリを解放
}
MyClassのインスタンスが生成されました。
MyClassのインスタンスが解放されました。

クラス内での動的メモリ管理

クラス内で動的メモリを管理する場合、コンストラクタでメモリを確保し、デストラクタで解放することが重要です。

以下は、クラス内での動的メモリ管理の例です。

#include <iostream>
using namespace std;
class MyClass {
private:
    int* data;
    
public:
    MyClass(int size) { // コンストラクタ
        data = new int[size]; // 動的メモリの確保
        cout << "データ配列が生成されました。" << endl;
    }
    
    ~MyClass() { // デストラクタ
        delete[] data; // メモリの解放
        cout << "データ配列が解放されました。" << endl;
    }
};
int main() {
    MyClass obj(5); // インスタンス生成
    return 0;
}
データ配列が生成されました。
データ配列が解放されました。

よくある質問

デフォルトコンストラクタが自動生成される条件は？

デフォルトコンストラクタが自動生成される条件は以下の通りです。

  • クラス内にユーザー定義のコンストラクタが存在しない場合。
  • クラス内にメンバ変数がすべてデフォルト初期化可能な型である場合。
  • クラスが継承している基底クラスがデフォルトコンストラクタを持っている場合。

自動生成されたデフォルトコンストラクタは、何も処理を行わない空のコンストラクタです。

メンバ初期化リストを使うべき理由は？

メンバ初期化リストを使うべき理由は以下の通りです。

  • 初期化の順序を明示的に指定できるため、意図しない初期化を防げる。
  • constメンバや参照メンバを初期化する際に、初期化リストを使用しないとエラーになる。
  • パフォーマンスの向上が期待できる。

特に、オブジェクトの初期化が複雑な場合、初期化リストを使用することで、余分なコピーを避けることができる。

コピーコンストラクタとムーブコンストラクタはどのように使い分ける？

コピーコンストラクタとムーブコンストラクタの使い分けは以下の通りです。

  • コピーコンストラクタ: オブジェクトのコピーを作成する際に使用します。

元のオブジェクトの状態を保持したまま、新しいオブジェクトを生成します。

主に、リソースを共有せずに独立したコピーが必要な場合に使用します。

  • ムーブコンストラクタ: リソースを別のオブジェクトに移動する際に使用します。

元のオブジェクトのリソースを新しいオブジェクトに移し、元のオブジェクトは無効化します。

主に、パフォーマンスを向上させるために、リソースの所有権を移動させる場合に使用します。

このように、コピーコンストラクタは「コピー」、ムーブコンストラクタは「移動」に特化しているため、状況に応じて使い分けることが重要です。

まとめ

この記事では、C++におけるクラスの初期化方法やその注意点、応用例について詳しく解説しました。

クラスの初期化は、プログラムの動作に大きな影響を与える重要な要素であり、適切な初期化方法を選択することが求められます。

これを踏まえ、実際のプログラミングにおいては、初期化の手法を意識しながら、効率的で安全なコードを書くことを心がけてください。

目次に戻る

当サイトはリンクフリーです。出典元を明記していただければ、ご自由に引用していただいて構いません。

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

クラス
  • URLをコピーしました！

関連記事

目次から探す