モダン第11章：【C++20】コンセプト（Concepts）と型制約

#include <iostream>
#include <concepts>
#include <string>

// 1. 座標を持つオブジェクトのコンセプト
template <typename T>
concept Positionable = requires(T a) {
    { a.getX() } -> std::convertible_to<float>;
    { a.getY() } -> std::convertible_to<float>;
};

// 2. 描画可能なオブジェクトのコンセプト
template <typename T>
concept Drawable = requires(T a) {
    a.draw();
};

// 3. 2つのコンセプトを合成したゲームエンティティのコンセプト
template <typename T>
concept GameEntity = Positionable<T> && Drawable<T>;

// 適合するクラス
class Player {
private:
    float x_ = 100.0f, y_ = 200.0f;
public:
    float getX() const { return x_; }
    float getY() const { return y_; }
    void draw() const {
        std::cout << "[Player] 座標 (" << x_ << ", " << y_ << ") に自機を描画\n";
    }
};

// 適合しないクラス（draw() がない）
class InvisibleTrigger {
public:
    float getX() const { return 0.0f; }
    float getY() const { return 0.0f; }
};

// 制約付き関数テンプレート（GameEntity コンセプトを満たす型しか受け付けない）
template <GameEntity T>
void processEntity(const T& entity) {
    std::cout << "エンティティ処理: X=" << entity.getX() << ", Y=" << entity.getY() << "\n";
    entity.draw();
}

int main() {
    Player p;
    processEntity(p); // OK: Positionable かつ Drawable を満たす

    // InvisibleTrigger t;
    // processEntity(t); // コンパイルエラー！'InvisibleTrigger' は 'Drawable' を満たさないため親切に拒絶される！

    return 0;
}

#include <iostream>
#include <concepts>
#include <type_traits>

template <typename T>
concept RobustDamageable = requires(T a, int damage) {
    // 1. 単純制約（Simple Requirement）：式が構文として妥当か
    a.takeDamage(damage);

    // 2. 型制約（Type Requirement）：ネストされた型名が存在するか
    typename T::HealthType;

    // 3. 複合制約（Compound Requirement）：戻り値の型と noexcept の検証
    { a.isAlive() } noexcept -> std::same_as<bool>;
    { a.getHealth() } -> std::convertible_to<int>;

    // 4. 入れ子制約（Nested Requirement）：追加の真偽値プロパティを課す
    requires sizeof(T) <= 256; // 巨大すぎるオブジェクトをヒープ外で受け取るのを防ぐ
};

struct Enemy {
    using HealthType = int;
    int hp = 100;

    void takeDamage(int dmg) { hp -= dmg; }
    bool isAlive() const noexcept { return hp > 0; }
    int getHealth() const { return hp; }
};

// 制約付き関数
void hit(RobustDamageable auto& target, int dmg) {
    target.takeDamage(dmg);
    std::cout << "ダメージ適用後HP: " << target.getHealth() 
              << " (生存: " << (target.isAlive() ? "YES" : "NO") << ")\n";
}

int main() {
    Enemy e;
    hit(e, 30);
    return 0;
}

#include <iostream>
#include <concepts>

// 基底コンセプト：一般的な敵
template <typename T>
concept EnemyUnit = requires(T e) {
    e.updateAI();
};

// より厳しいコンセプト：飛行能力を持つ敵
template <typename T>
concept FlyingEnemyUnit = EnemyUnit<T> && requires(T e) {
    e.flyAltitude();
};

// 1. 一般的な敵向けの更新処理
template <EnemyUnit T>
void updateBehavior(T& enemy) {
    std::cout << "[地上アルゴリズム] 地形コリジョンと歩行更新を実行\n";
    enemy.updateAI();
}

// 2. 飛行ユニット向けの特化更新処理（FlyingEnemyUnit は EnemyUnit を包摂するため優先される！）
template <FlyingEnemyUnit T>
void updateBehavior(T& enemy) {
    std::cout << "[飛行アルゴリズム] 3D高度計算と空中旋回更新を実行\n";
    enemy.updateAI();
}

struct Slime {
    void updateAI() { std::cout << "  スライムが前進\n"; }
};

struct Wyvern {
    void updateAI() { std::cout << "  ワイバーンが滑空\n"; }
    float flyAltitude() { return 50.0f; }
};

int main() {
    Slime s;
    Wyvern w;

    updateBehavior(s); // 1 が自動選択される
    updateBehavior(w); // より具体的な 2 が自動選択される！

    return 0;
}

#include <iostream>
#include <concepts>
#include <cmath>

struct AABB {
    float x, y, width, height;
};

// 衝突判定可能なオブジェクトを縛るコンセプト
template <typename T>
concept Collidable = requires(const T& a) {
    { a.getAABB() } -> std::same_as<AABB>;
};

// 2つの Collidable オブジェクト間の AABB 衝突判定（完全インライン化）
template <Collidable T1, Collidable T2>
bool checkOverlap(const T1& a, const T2& b) {
    AABB boxA = a.getAABB();
    AABB boxB = b.getAABB();

    return (boxA.x < boxB.x + boxB.width &&
            boxA.x + boxA.width > boxB.x &&
            boxA.y < boxB.y + boxB.height &&
            boxA.y + boxA.height > boxB.y);
}

// プレイヤー
struct PlayerShip {
    float x = 100.0f, y = 500.0f;
    AABB getAABB() const { return {x, y, 32.0f, 16.0f}; }
};

// 敵エイリアン
struct AlienInvader {
    float x = 110.0f, y = 505.0f;
    AABB getAABB() const { return {x, y, 24.0f, 24.0f}; }
};

// 弾丸
struct PlasmaBullet {
    float x = 200.0f, y = 200.0f;
    AABB getAABB() const { return {x, y, 4.0f, 10.0f}; }
};

int main() {
    PlayerShip player;
    AlienInvader alien;
    PlasmaBullet bullet;

    std::cout << "--- C++20 コンセプト衝突判定テスト ---\n";

    if (checkOverlap(player, alien)) {
        std::cout << "🚨 [HIT] 自機とエイリアンが衝突！シールド減少！\n";
    } else {
        std::cout << "安全：衝突なし\n";
    }

    if (checkOverlap(bullet, alien)) {
        std::cout << "💥 [HIT] 弾丸が敵に直撃！\n";
    } else {
        std::cout << "弾丸は敵に命中していません\n";
    }

    return 0;
}

• 落とし穴1：過剰制約（Over-constraining）による再利用性の低下: 必要以上に厳しい要件（特定の具象型や不必要なメンバ関数）を要求する concept を作ると、本来使えるはずの軽量構造体が拒絶されてしまいます。インターフェース分離の原則（ISP）に従い、小さく直交したコンセプト（Collidable, Movable 等）を定義して合成するのがベストプラクティスです。
• 落とし穴2：requires 節内での暗黙の型変換の過信: `{ a.getHp() } -> std::same_as<int>` は厳密に int を要求します。もし short や double を返す型も許容したい場合は、`std::convertible_to<int>` を使用してください。
• 落とし穴3：コンセプトと仮想関数（virtual）の混同: コンセプトはコンパイル時の静的ポリモーフィズムです。「異種オブジェクトを同じ std::vector<T> に格納したい」という要件には使えません。不均一なコレクションには第4章の仮想関数や第10章の std::variant を使い、単一のアルゴリズムを型安全に共有する箇所でコンセプトを使いましょう。

• 1. ポインタが自動的にすべて nullptr に初期化されるようになる
• 2. テンプレート引数が満たすべき要件を明確に宣言でき、制約違反時に簡潔で分かりやすいコンパイルエラーが得られる
• 3. すべてのクラステンプレートが実行時に動的リフレクション可能になる
• 4. メモリリークをガベージコレクションによって自動回収する

• 1. { obj.getValue() } -> std::convertible_to<int>;
• 2. obj.getValue() == int;
• 3. requires type(obj.getValue()) == int;
• 4. convert(obj.getValue(), int);

• 1. すべてのオーバーロードは常に曖昧（Ambiguous）エラーになるため、オーバーロードは禁止されている
• 2. より多くの制約（&& で結合された厳しい条件）を持つコンセプトを満たすオーバーロード関数が、コンパイラによって優先的に選択される
• 3. 最初にソースコード上で宣言された関数が常に優先され、後の関数は無視される
• 4. 実行時の CPU 負荷が最も低い関数が動的にプロファイリングされて選ばれる