C++の抽象クラスと純粋仮想関数とは？使い方と実装例を解説

// 純粋仮想関数の基本形
// ポイント: "= 0" を付けると「実装なし・派生クラスに実装を強制」の意味になる
struct Interface {
    virtual ~Interface() = default;          // 破壊時の多態性のために仮想デストラクタを用意
    virtual int compute(int x) const = 0;    // 純粋仮想関数
    virtual void reset() noexcept = 0;       // noexcept も付けられる
};

// 例: 面積を返す抽象クラス
#include <iostream>

class Shape {
public:
    virtual ~Shape() = default;       // 仮想デストラクタ(重要)
    virtual double area() const = 0;  // 純粋仮想関数: 派生クラスに実装を強制
};

#define _USE_MATH_DEFINES
#include <cmath>

// 円: 半径 r の面積は πr^2
class Circle : public Shape {
    double r_;
public:
    explicit Circle(double r) : r_(r) {}
    double area() const override {           // override を付けて間違いを検出
        return M_PI * r_ * r_;
    }
};

// 長方形: 幅 w, 高さ h の面積は w*h
class Rectangle : public Shape {
    double w_, h_;
public:
    Rectangle(double w, double h) : w_(w), h_(h) {}
    double area() const override {
        return w_ * h_;
    }
};

#define _USE_MATH_DEFINES
#include <cmath>
#include <iostream>

class Shape {
   public:
    virtual ~Shape() = default;      // 仮想デストラクタ(重要)
    virtual double area() const = 0; // 純粋仮想関数: 派生クラスに実装を強制
};

// 円: 半径 r の面積は πr^2
class Circle : public Shape {
    double r_;

   public:
    explicit Circle(double r) : r_(r) {}
    double area() const override { // override を付けて間違いを検出
        return M_PI * r_ * r_;
    }
};

// 長方形: 幅 w, 高さ h の面積は w*h
class Rectangle : public Shape {
    double w_, h_;

   public:
    Rectangle(double w, double h) : w_(w), h_(h) {}
    double area() const override {
        return w_ * h_;
    }
};

// Shape& 経由で面積を表示するユーティリティ関数
void printArea(const Shape& s, const char* name) {
    std::cout << name << " area = " << s.area() << '\n';
}

int main() {
    Circle c(2.0);         // 半径2
    Rectangle r(3.0, 4.0); // 幅3, 高さ4

    // 参照で呼び出すと、実体の型に応じた area() が呼ばれる
    printArea(c, "Circle");
    printArea(r, "Rectangle");
}

int main() {
    // Circle c(1.5);
    // Rectangle r(2.0, 5.0);
    Circle* c = new Circle(1.5);
    Rectangle* r = new Rectangle(2.0, 5.0);

    bool useCircle = true; // 条件: 実行時に選択すると仮定
    Shape* s = useCircle ? static_cast<Shape*>(c) : static_cast<Shape*>(r);

    // ポインタ経由でも、実体の型に応じて適切な area() が呼ばれる
    std::cout << "Selected area = " << s->area() << '\n';

    delete c;
    delete r;
}

// コンパイルエラーの例:
// Shape s;            // NG: 抽象クラスはインスタンス化できない
// auto p = new Shape; // NG: 同上

// 純粋仮想デストラクタの正しい定義方法
class Base {
public:
    virtual ~Base() = 0;  // 純粋仮想デストラクタ
};

Base::~Base() {}          // 本体定義が必須(空でよい)

// Base は依然として抽象クラスのまま

struct I {
    virtual int f(int) const = 0;
};

struct ImplBad : I {
    // int f(int) { ... }  // const が抜けている → オーバーライドではない
    int f(int) { return 42; } // 実は別関数(警告にも気づきにくい)
};

struct ImplGood : I {
    int f(int) const override { return 7; } // 正しく一致
};

// 悪い例: 仮想でないデストラクタ
struct BadBase {
    ~BadBase() { std::cout << "~BadBase\n"; }
    virtual void f() = 0;
};
struct BadDerived : BadBase {
    ~BadDerived() { std::cout << "~BadDerived\n"; }
    void f() override {}
};

int main() {
    BadBase* p = new BadDerived();
    delete p; // ~BadDerived が呼ばれない可能性(未定義動作)
}

struct GoodBase {
    virtual ~GoodBase() { std::cout << "~GoodBase\n"; }
    virtual void f() = 0;
};
struct GoodDerived : GoodBase {
    ~GoodDerived() override { std::cout << "~GoodDerived\n"; }
    void f() override {}
};

int main() {
    GoodBase* p = new GoodDerived();
    delete p; // ~GoodDerived → ~GoodBase の順で安全に破壊
}

#include <iostream>

struct A {
    A() {
        // 純粋仮想呼び出しは危険。A の構築中は派生の vtable が有効でない
        // g(); // ← 実行時に "pure virtual method called" になることがある
    }
    virtual ~A() = default;
    virtual void g() = 0;
};

struct B : A {
    void g() override { std::cout << "B::g\n"; }
};