第7章: クラスを使いこなす

// 悪い例：浅いコピーの問題点
#include <iostream>

class ResourceHolder {
private:
    int* m_data; // 動的に確保したデータへのポインタ
public:
    ResourceHolder(int value) {
        m_data = new int(value); // メモリを確保
        std::cout << "Resource " << *m_data << " created. (at " << m_data << ")" << std::endl;
    }
    ~ResourceHolder() {
        std::cout << "Resource " << *m_data << " destroyed. (at " << m_data << ")" << std::endl;
        delete m_data; // メモリを解放
    }
    // コピーコンストラクタや代入演算子を定義していない！
};

int main() {
    ResourceHolder r1(10);
    ResourceHolder r2 = r1; // 浅いコピーが発生！
    // r1.m_data と r2.m_data は同じアドレスを指してしまう
    
    // main()終了時、r1とr2のデストラクタが呼ばれる
    // 同じメモリを2回deleteしようとしてクラッシュ！💥
    return 0;
}

#include <iostream>

class ResourceHolder {
private:
    int* m_data; // リソースとして動的に確保したintへのポインタ

public:
    // コンストラクタ: intを1つ動的に確保し、値を設定
    ResourceHolder(int value) {
        m_data = new int(value);
        std::cout << "Resource " << *m_data << " created. (at " << m_data << ")" << std::endl;
    }

    // デストラクタ: 確保したメモリを解放
    ~ResourceHolder() {
        if (m_data != nullptr) {
            std::cout << "Resource " << *m_data << " destroyed. (at " << m_data << ")" << std::endl;
            delete m_data;
        }
    }

    // --- ここからが本題です ---

    // 1. コピーコンストラクタ (深いコピー)
    // ResourceHolder r2 = r1; のように、オブジェクトの作成と同時にコピーするときに呼ばれる
    ResourceHolder(const ResourceHolder& other) {
        // ① 新しいメモリを確保する
        // ② otherの「値」(*other.m_data)を、新しいメモリにコピーする
        m_data = new int(*other.m_data);
        std::cout << "COPY CONSTRUCTOR: New resource " << *m_data << " created. (at " << m_data << ")" << std::endl;
    }

    // 2. コピー代入演算子 (深いコピー)
    // r3 = r1; のように、既存のオブジェクトに代入するときに呼ばれる
    ResourceHolder& operator=(const ResourceHolder& other) {
        std::cout << "COPY ASSIGNMENT OPERATOR called." << std::endl;

        // ① 自己代入のチェック (a = a; のような無駄な処理を防ぐ)
        if (this == &other) {
            return *this; // 何もせず自分自身を返す
        }

        // ② 自分が元々持っていた古いリソースを解放する
        delete m_data;

        // ③ 新しいリソースを確保し、相手の値をコピーする
        m_data = new int(*other.m_data);

        return *this; // 自分自身を返すことで、a = b = c; のような連続代入が可能になる
    }

    void print() const {
        std::cout << "Value: " << *m_data << ", Address: " << m_data << std::endl;
    }
};

int main() {
    std::cout << "--- rh1の作成 ---" << std::endl;
    ResourceHolder rh1(10);

    std::cout << "\n--- rh2をrh1で初期化 ---" << std::endl;
    ResourceHolder rh2 = rh1; // コピーコンストラクタが呼ばれる

    std::cout << "\n--- rh3の作成 ---" << std::endl;
    ResourceHolder rh3(20);

    std::cout << "\n--- rh3にrh1を代入 ---" << std::endl;
    rh3 = rh1; // コピー代入演算子が呼ばれる

    std::cout << "\n--- 各オブジェクトの状態 ---" << std::endl;
    std::cout << "rh1: "; rh1.print();
    std::cout << "rh2: "; rh2.print(); // rh1とは別のメモリを持っている
    std::cout << "rh3: "; rh3.print(); // rh1とは別のメモリを持っている

    std::cout << "\n--- main関数終了 ---" << std::endl;
    return 0; // ここでrh1, rh2, rh3のデストラクタが呼ばれ、それぞれが確保したメモリを安全に解放する
}

#include <iostream>

class Vector2D {
public:
    double x, y;

    Vector2D(double x = 0.0, double y = 0.0) : x(x), y(y) {}

    // メンバ関数として + 演算子をオーバーロード
    Vector2D operator+(const Vector2D& rhs) const {
        return Vector2D(this->x + rhs.x, this->y + rhs.y);
    }

    // メンバ関数として == 演算子をオーバーロード
    bool operator==(const Vector2D& rhs) const {
        return (this->x == rhs.x) && (this->y == rhs.y);
    }
};

// 非メンバ関数として << 演算子をオーバーロード
// 第1引数が std::ostream& なので、メンバ関数にはできない
std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

int main() {
    Vector2D v1(1.0, 2.0);
    Vector2D v2(3.0, 4.0);

    // operator+ が呼ばれる
    Vector2D v3 = v1 + v2;
    std::cout << "v1: " << v1 << std::endl; // operator<<
    std::cout << "v2: " << v2 << std::endl; // operator<<
    std::cout << "v3 = v1 + v2: " << v3 << std::endl; // operator<<

    // operator== が呼ばれる
    if (v1 == Vector2D(1.0, 2.0)) {
        std::cout << "v1 is equal to (1.0, 2.0)" << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>

class Player {
private:
    std::string name;
    // (1) staticメンバ変数の宣言
    static int playerCount;

public:
    Player(const std::string& name) : name(name) {
        playerCount++; // オブジェクトが生成されるたびにインクリメント
        std::cout << name << " がゲームに参加しました。現在のプレイヤー数: " << playerCount << std::endl;
    }

    ~Player() {
        playerCount--; // オブジェクトが破棄されるたびにデクリメント
        std::cout << name << " がゲームから退出しました。現在のプレイヤー数: " << playerCount << std::endl;
    }

    // (2) staticメンバ関数の宣言
    static int getPlayerCount() {
        // name などの非staticメンバにはアクセスできない
        return playerCount;
    }
};

// (3) staticメンバ変数の定義と初期化
int Player::playerCount = 0;

int main() {
    // オブジェクトがなくてもstaticメンバ関数を呼び出せる
    std::cout << "ゲーム開始時のプレイヤー数: " << Player::getPlayerCount() << std::endl;
    std::cout << "---" << std::endl;

    Player p1("Alice");
    Player p2("Bob");

    {
        Player p3("Charlie");
        std::cout << "現在のプレイヤー数 (p1経由): " << p1.getPlayerCount() << std::endl;
    } // p3のスコープが終わり、デストラクタが呼ばれる

    std::cout << "---" << std::endl;
    std::cout << "ゲーム終了時のプレイヤー数: " << Player::getPlayerCount() << std::endl;

    return 0;
}

#include <iostream>

class Point {
private:
    int x, y;

public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 自身の参照を返すことで、メソッドチェーンを可能にする
    Point& setX(int newX) {
        this->x = newX;
        return *this; // 自分自身の参照を返す
    }

    Point& setY(int newY) {
        this->y = newY;
        return *this; // 自分自身の参照を返す
    }

    void print() const {
        std::cout << "(" << this->x << ", " << this->y << ")" << std::endl;
    }
};

int main() {
    Point p;

    // メソッドチェーン
    p.setX(10).setY(20);

    p.print();

    return 0;
}

#include <iostream>

// ここに Complex クラスを実装してください

int main() {
    Complex c1(1.0, 2.0); // 1 + 2i
    Complex c2(3.0, 4.0); // 3 + 4i
    Complex sum = c1 + c2;
    Complex product = c1 * c2;

    std::cout << "c1: " << c1 << std::endl;
    std::cout << "c2: " << c2 << std::endl;
    std::cout << "c1 + c2 = " << sum << std::endl;
    std::cout << "c1 * c2 = " << product << std::endl;
    return 0;
}

#include <iostream>

// ここに IntArray クラスを実装してください

int main() {
    IntArray arr1(5); // サイズ5の配列を作成
    for (int i = 0; i < 5; ++i) {
        arr1.set(i, i * 10); // 0, 10, 20, 30, 40
    }

    IntArray arr2 = arr1; // コピーコンストラクタ
    IntArray arr3(3);
    arr3 = arr1;          // コピー代入演算子

    std::cout << "arr1: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << arr1.get(i) << " ";
    }
    std::cout << std::endl;

    std::cout << "arr2 (コピー): ";
    for (int i = 0; i < 5; ++i) {
        std::cout << arr2.get(i) << " ";
    }
    std::cout << std::endl;

    std::cout << "arr3 (代入): ";
    for (int i = 0; i < 5; ++i) {
        std::cout << arr3.get(i) << " ";
    }
    std::cout << std::endl;

    return 0;
}