[C++] コンストラクタを省略するとどうなるのか解説

#include <iostream>
class MyClass {
public:
    int value; // 初期化されない
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    std::cout << "value: " << obj.value << std::endl; // 未初期化の値が表示される
    return 0;
}

value: 0 // 未初期化のため、出力は不定

#include <iostream>
class MyClass {
public:
    int number; // 組み込み型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    std::cout << "number: " << obj.number << std::endl; // 未初期化の値が表示される
    return 0;
}

number: 0 // 未初期化のため、出力は不定

#include <iostream>
class InnerClass {
public:
    InnerClass() {
        std::cout << "InnerClassのコンストラクタ" << std::endl;
    }
};
class MyClass {
public:
    InnerClass inner; // クラス型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    return 0;
}

InnerClassのコンストラクタ // 出力されない

#include <iostream>
class MyClass {
public:
    MyClass(int val) { // ユーザー定義コンストラクタ
        value = val;
    }
    int value;
};
int main() {
    MyClass obj(10); // ユーザー定義コンストラクタを呼び出す
    std::cout << "value: " << obj.value << std::endl; // 正常に初期化される
    return 0;
}

value: 10 // 正常に初期化された値が表示される

#include <iostream>
class InnerClass {
public:
    InnerClass() {
        std::cout << "InnerClassのコンストラクタ" << std::endl;
    }
};
class MyClass {
public:
    InnerClass inner; // クラス型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    return 0;
}

InnerClassのコンストラクタ // 自動生成されたデフォルトコンストラクタが呼ばれる

#include <iostream>
class MyClass {
public:
    MyClass(int val) { // ユーザー定義コンストラクタ
        value = val;
    }
    int value;
};
int main() {
    // MyClass obj; // エラー: デフォルトコンストラクタが存在しない
    MyClass obj(10); // ユーザー定義コンストラクタを呼び出す
    std::cout << "value: " << obj.value << std::endl;
    return 0;
}

value: 10 // ユーザー定義コンストラクタが呼ばれる

#include <iostream>
class MyClass {
public:
    MyClass() { // 明示的なデフォルトコンストラクタ
        value = 0;
    }
    MyClass(int val) { // ユーザー定義コンストラクタ
        value = val;
    }
    int value;
};
int main() {
    MyClass obj1; // 明示的なデフォルトコンストラクタが呼ばれる
    MyClass obj2(10); // ユーザー定義コンストラクタが呼ばれる
    std::cout << "obj1 value: " << obj1.value << std::endl;
    std::cout << "obj2 value: " << obj2.value << std::endl;
    return 0;
}

obj1 value: 0
obj2 value: 10 // 両方のコンストラクタが正常に呼ばれる

#include <iostream>
class SimpleClass {
public:
    int value; // コンストラクタを省略
};
int main() {
    SimpleClass obj; // デフォルトコンストラクタが自動生成される
    obj.value = 5; // 値を直接代入
    std::cout << "value: " << obj.value << std::endl; // 簡潔なコード
    return 0;
}

value: 5 // コードが簡潔で読みやすい

#include <iostream>
class MyClass {
public:
    int number; // 未初期化の組み込み型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    std::cout << "number: " << obj.number << std::endl; // 未初期化の値が表示される
    return 0;
}

number: 0 // 未初期化のため、出力は不定

#include <iostream>
class MyClass {
public:
    int value; // 未初期化のメンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    if (obj.value > 10) { // 未初期化の値を使用
        std::cout << "value is greater than 10" << std::endl;
    } else {
        std::cout << "value is 10 or less" << std::endl; // 意図しない動作の可能性
    }
    return 0;
}

value is 10 or less // 未初期化のため、出力は不定

#include <iostream>
class MyClass {
public:
    MyClass() { // 明示的なデフォルトコンストラクタ
        value = 0; // 初期化
    }
    int value; // メンバ変数
};
int main() {
    MyClass obj; // 明示的なデフォルトコンストラクタが呼ばれる
    std::cout << "value: " << obj.value << std::endl; // 初期化された値が表示される
    return 0;
}

value: 0 // 明示的に初期化されている

#include <iostream>
class MyClass {
public:
    int number; // 組み込み型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    std::cout << "number: " << obj.number << std::endl; // 未初期化の値が表示される
    return 0;
}

number: 0 // 未初期化のため、出力は不定

#include <iostream>
class MyClass {
public:
    int* ptr; // ポインタ型メンバ変数
};
int main() {
    MyClass obj; // デフォルトコンストラクタが自動生成される
    // std::cout << *obj.ptr << std::endl; // エラー: 未初期化のポインタを参照
    return 0;
}

未定義の動作 // 未初期化のポインタを参照するとエラーが発生する

#include <iostream>
class A {
public:
    A() {
        std::cout << "Aのコンストラクタ" << std::endl;
    }
};
class B {
public:
    A a; // A型のメンバ変数
    B() {
        std::cout << "Bのコンストラクタ" << std::endl;
    }
};
int main() {
    B obj; // Aのコンストラクタが先に呼ばれる
    return 0;
}

Aのコンストラクタ
Bのコンストラクタ // 初期化順序に注意が必要

#include <iostream>
class MyClass {
public:
    int number;
    int* ptr;
    MyClass() : number(0), ptr(new int(10)) { // 初期化リストを使用
    }
    ~MyClass() {
        delete ptr; // メモリの解放
    }
};
int main() {
    MyClass obj; // 初期化リストが使用される
    std::cout << "number: " << obj.number << std::endl; // 初期化された値が表示される
    std::cout << "ptr: " << *obj.ptr << std::endl; // 初期化されたポインタの値が表示される
    return 0;
}

number: 0
ptr: 10 // 初期化リストを使用することで、未初期化の問題を回避

#include <iostream>
class Point {
public:
    int x; // メンバ変数
    int y; // メンバ変数
};
int main() {
    Point p; // デフォルトコンストラクタが自動生成される
    p.x = 5; // 値を直接代入
    p.y = 10; // 値を直接代入
    std::cout << "Point(" << p.x << ", " << p.y << ")" << std::endl; // シンプルな出力
    return 0;
}

Point(5, 10) // シンプルなクラス設計での省略

#include <iostream>
class Data {
public:
    int id; // POD型メンバ変数
    float value; // POD型メンバ変数
};
int main() {
    Data d; // デフォルトコンストラクタが自動生成される
    d.id = 1; // 値を直接代入
    d.value = 3.14f; // 値を直接代入
    std::cout << "Data(id: " << d.id << ", value: " << d.value << ")" << std::endl; // POD型の出力
    return 0;
}

Data(id: 1, value: 3.14) // POD型での省略

#include <iostream>
template <typename T>
class Container {
public:
    T value; // テンプレート型メンバ変数
};
int main() {
    Container<int> intContainer; // int型のテンプレートクラス
    intContainer.value = 42; // 値を直接代入
    std::cout << "intContainer value: " << intContainer.value << std::endl; // テンプレートクラスの出力
    Container<double> doubleContainer; // double型のテンプレートクラス
    doubleContainer.value = 3.14; // 値を直接代入
    std::cout << "doubleContainer value: " << doubleContainer.value << std::endl; // テンプレートクラスの出力
    return 0;
}

intContainer value: 42
doubleContainer value: 3.14 // テンプレートクラスでの省略

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers; // std::vectorのデフォルトコンストラクタを使用
    numbers.push_back(1); // 値を追加
    numbers.push_back(2); // 値を追加
    numbers.push_back(3); // 値を追加
    std::cout << "Numbers: ";
    for (int num : numbers) {
        std::cout << num << " "; // std::vectorの出力
    }
    std::cout << std::endl;
    return 0;
}

Numbers: 1 2 3 // 標準ライブラリのクラスでの省略