モダン第1章：【C++11】スマートポインタとRAII（所有権設計とメモリ安全性）

### ■ なぜ unique_ptr はコピーできないのか？
`std::unique_ptr` の最大の特徴は、**コピーコンストラクタとコピー代入演算子が削除（= delete）されている**点です。

```cpp
std::unique_ptr<Enemy> p1 = std::make_unique<NormalEnemy>(10, 2);
std::unique_ptr<Enemy> p2 = p1; // コンパイルエラー！コピーは絶対に禁止！
```

もしこれが許可されていたら、`p1` と `p2` が同じヒープ実体を指してしまいます。するとスコープを抜けた際、**2回 delete** されてクラッシュ（二重解放）してしまいます。

### ■ 所有権の移動（Move Semantics）
コピーは禁止ですが、**「持ち主の変更（譲渡）」**は許可されています。それが `std::move()` です。

```cpp
std::unique_ptr<Enemy> p2 = std::move(p1);
// p1 は nullptr になり、p2 が新たな唯一の所有者となる！
```

ゲーム内では、敵を倒した瞬間に生成されたアイテムカプセルが：
1. 敵の内部で `std::make_unique<Item>()` される
2. ステージの `m_items` リストへ `std::move()` される
3. プレイヤーが触れた瞬間、プレイヤーへ引き渡される
という**「所有権のリレー」**が極めて安全に行われます。

### ■ 管理ブロック（Control Block）と参照カウント
`std::shared_ptr` を作成すると、ヒープ領域に**「実体」**と**「管理ブロック」**の2つが確保されます。

- **use_count**: 現在の実体所有者数（これが 0 になると実体が `delete` される）
- **weak_count**: 監視中の `std::weak_ptr` の数（これも 0 になると管理ブロック自体が破棄される）

```cpp
// プレイヤー周囲の護衛ビットドローンを生成
std::shared_ptr<BitDrone> drone = std::make_shared<BitDrone>(0.0f);
// use_count: 1

m_player.addDrone(drone);
// プレイヤー内部の vector にコピー保存される → use_count: 2

// ゲームループで drone 変数のスコープが終わっても、
// m_player が所有権を持っているので use_count: 1 となり実体は生き続ける！
```

### ■ 循環参照（死のロック）と weak_ptr の必然性
もし「ビット機」が親の「プレイヤー」へのポインタを `shared_ptr<Player>` で持ってしまうと：
- プレイヤーはビット機を所有（use_count = 1）
- ビット機はプレイヤーを所有（use_count = 1）
互いに参照し合っているため、ゲームが終わってもどちらの `use_count` も 0 にならず、**永遠にデストラクタが呼ばれない死のメモリリーク**が発生します。

これを防ぐため、逆参照や監視側には `std::weak_ptr<Player>` を使います。
`weak_ptr` は参照カウントを増やさず、使うときだけ `drone->lock()` して一時的な `shared_ptr` を取り出します。

#pragma once
#include <vector>
#include <memory>
#include <string>
#include "Common.h"
#include "Player.h"
#include "Enemy.h"
#include "Item.h"
#include "Bullet.h"
#include "Particle.h"

class Game {
private:
    // 【モダンC++の極致】生ポインタはゼロ！すべてスマートポインタで管理
    std::vector<std::unique_ptr<Enemy>> m_enemies;  // 敵の単独所有
    std::vector<std::unique_ptr<Item>>  m_items;    // ドロップアイテムの単独所有
    std::vector<Bullet>                 m_bullets;  // 弾丸
    std::vector<Particle>               m_particles;// 火花粒子
    Player                              m_player;   // 自機

    int  m_enemyDir;
    int  m_enemyMoveTimer;
    int  m_ufoTimer;
    int  m_score;
    bool m_gameOver;
    bool m_gameClear;

public:
    Game();
    // デストラクタに手動 delete ループは1行も不要！
    // vector破棄に伴い、各 unique_ptr が派生クラスの仮想デストラクタを自動起動
    ~Game() = default;

    void init();
    void processInput();
    void update();
    void render();
};

#pragma once
#include <vector>
#include <memory>
#include <string>
#include "Common.h"
#include "Bullet.h"
#include "BitDrone.h"

class Player {
private:
    int  m_x;
    int  m_y;
    bool m_hasTripleShot;
    // 護衛ビットドローンを共有所有（shared_ptr）
    std::vector<std::shared_ptr<BitDrone>> m_drones;

public:
    Player(int startX, int startY);
    ~Player() = default;

    void moveLeft();
    void moveRight();
    void update();
    void draw(std::vector<std::string>& buffer) const;

    // 弾を発射（3WAYやビット連動）
    void shoot(std::vector<Bullet>& bullets) const;

    void enableTripleShot() { m_hasTripleShot = true; }
    void addDrone(std::shared_ptr<BitDrone> drone);
    int  getDroneCount() const { return static_cast<int>(m_drones.size()); }
};

#pragma once
#include <vector>
#include <string>
#include "Common.h"

enum class ItemType {
    Power, // 3WAYレーザー化 ('P')
    Bit    // 援護ビットドローン追加 ('B')
};

class Item {
private:
    float    m_x;
    float    m_y;
    ItemType m_type;
    bool     m_active;

public:
    Item(float x, float y, ItemType type);
    ~Item() = default;

    void update();
    void draw(std::vector<std::string>& buffer) const;

    float getX() const { return m_x; }
    float getY() const { return m_y; }
    ItemType getType() const { return m_type; }
    bool isActive() const { return m_active; }
    void deactivate() { m_active = false; }
};

• 9割の設計は std::unique_ptr で完結せよ: オーバーヘッドゼロで生のポインタと同一速度。唯一の所有権を明確にし、安易な shared_ptr 乱用を避けるのがモダンC++の鉄則です。
• std::make_unique / std::make_shared を使え: new を書かずにヘルパー関数を使うことで、例外発生時のメモリリークを防ぎ、コードを簡潔にします。
• 共有が必要な時だけ std::shared_ptr、逆参照には std::weak_ptr: 複数の持ち主がいるリソースには参照カウントを使い、相互参照による循環参照リークは weak_ptr で断ち切ります。
• コンテナの消去とメモリ解放の同期: vector<unique_ptr<T>> から erase するだけでヒープ実体も即時自動解放され、手動 delete が1行も要らなくなります。

• 1. コンパイラがコピー用のメモリを確保するのに時間がかかるから
• 2. 2つのポインタが同じ実体を指すと、破棄時に2回 delete（二重解放）されてクラッシュするから
• 3. C++11以降ではすべてのクラスでコピーが禁止されたから
• 4. 仮想関数テーブル（vtable）のサイズが2倍になってしまうから

正解と解説を見る

正解：2つのポインタが同じ実体を指すと、破棄時に2回 delete（二重解放）されてクラッシュするから
正解は「2つのポインタが同じ実体を指すと、破棄時に2回 delete（二重解放）されてクラッシュするから」です。unique_ptr は「唯一の所有者」であることを保証するためコピーコンストラクタが削除されています。所有権を渡すには std::move() を用います。

• 1. p2 と同じヒープアドレスを指し続ける
• 2. 自動的に delete されて未定義の不正ポインタになる
• 3. nullptr（空ポインタ）になる
• 4. コンパイルエラーになり実行できない

正解と解説を見る

正解：nullptr（空ポインタ）になる
正解は「nullptr（空ポインタ）になる」です。ムーブによって所有権が p2 に完全に移譲されるため、元の p1 は安全にリセット（nullptr）され、二重解放や誤操作を防ぎます。

• 1. プログラム全体（main関数）が終了したとき
• 2. いずれか1つの shared_ptr がスコープを抜けたとき
• 3. その実体を指すすべての shared_ptr が破棄され、参照カウント（use_count）が 0 になったとき
• 4. ガベージコレクタが定期巡回して回収したとき

正解と解説を見る

正解：その実体を指すすべての shared_ptr が破棄され、参照カウント（use_count）が 0 になったとき
正解は「参照カウント（use_count）が 0 になったとき」です。最後の所有者がスコープを抜けてカウントが 0 になった瞬間に、即座に実体のデストラクタが呼ばれてメモリが返却されます。

• 1. 循環参照（Cyclic Reference）。片方を std::weak_ptr にして所有権の輪を断ち切る。
• 2. ダングリングポインタ。両方に raw ポインタを使うことで解決する。
• 3. メモリフラグメンテーション。std::make_shared を使うことで解決する。
• 4. 二重解放。基底クラスのデストラクタを virtual にすることで解決する。

正解と解説を見る

正解：循環参照（Cyclic Reference）。片方を std::weak_ptr にして所有権の輪を断ち切る。
正解は「循環参照（Cyclic Reference）。片方を std::weak_ptr にして所有権の輪を断ち切る」です。weak_ptr は参照カウンタを増やさない「見守り専用」のポインタであるため、循環参照による死のロックを完全に防ぐことができます。