[C++] 基底クラスのポインタで派生クラスの型を判定する方法

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {};
int main() {
    Base* basePtr = new Derived(); // 基底クラスのポインタ
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_castを使用
    if (derivedPtr) { // 戻り値の確認
        std::cout << "派生クラスの型です。" << std::endl;
    } else {
        std::cout << "型判定に失敗しました。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

派生クラスの型です。

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {
public:
    void show() {
        std::cout << "Derivedクラスのメソッドです。" << std::endl;
    }
};
int main() {
    Base* basePtr = new Derived(); // 基底クラスのポインタ
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_castを使用
    if (derivedPtr) { // 型判定
        derivedPtr->show(); // メソッド呼び出し
    } else {
        std::cout << "型判定に失敗しました。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

Derivedクラスのメソッドです。

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {};
class AnotherDerived : public Base {}; // 別の派生クラス
int main() {
    Base* basePtr = new AnotherDerived(); // 別の派生クラスのポインタ
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_castを使用
    if (derivedPtr) {
        std::cout << "派生クラスの型です。" << std::endl;
    } else {
        std::cout << "型判定に失敗しました。" << std::endl; // 失敗時の処理
    }
    delete basePtr; // メモリの解放
    return 0;
}

型判定に失敗しました。

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class DerivedA : public Base {
public:
    void show() {
        std::cout << "DerivedAクラスのメソッドです。" << std::endl;
    }
};
class DerivedB : public Base {
public:
    void show() {
        std::cout << "DerivedBクラスのメソッドです。" << std::endl;
    }
};
int main() {
    Base* basePtr = new DerivedA(); // 基底クラスのポインタ
    if (DerivedA* derivedA = dynamic_cast<DerivedA*>(basePtr)) {
        derivedA->show(); // DerivedAのメソッド呼び出し
    } else if (DerivedB* derivedB = dynamic_cast<DerivedB*>(basePtr)) {
        derivedB->show(); // DerivedBのメソッド呼び出し
    } else {
        std::cout << "型判定に失敗しました。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

DerivedAクラスのメソッドです。

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {
public:
    void display() {
        std::cout << "Derivedクラスのメソッドです。" << std::endl;
    }
};
int main() {
    Base* basePtr = new Derived(); // 基底クラスのポインタ
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_castを使用
    if (derivedPtr) {
        derivedPtr->display(); // メソッド呼び出し
    } else {
        std::cout << "型判定に失敗しました。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

Derivedクラスのメソッドです。

#include <iostream>
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {
public:
    void show() {
        std::cout << "Derivedクラスのメソッドです。" << std::endl;
    }
};
int main() {
    Base* basePtr = new Derived(); // 基底クラスのポインタ
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // ダウンキャスト
    if (derivedPtr) {
        derivedPtr->show(); // メソッド呼び出し
    } else {
        std::cout << "型判定に失敗しました。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

Derivedクラスのメソッドです。

#include <iostream>
#include <stdexcept> // 例外処理用
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {};
void process(Base* basePtr) {
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_castを使用
    if (!derivedPtr) {
        throw std::runtime_error("型判定に失敗しました。"); // 例外を投げる
    }
    std::cout << "処理が成功しました。" << std::endl;
}
int main() {
    Base* basePtr = new Base(); // 基底クラスのポインタ
    try {
        process(basePtr); // 型判定を行う
    } catch (const std::runtime_error& e) {
        std::cout << e.what() << std::endl; // 例外メッセージを表示
    }
    delete basePtr; // メモリの解放
    return 0;
}

型判定に失敗しました。

#include <iostream>
#include <typeinfo> // typeidを使用するためのヘッダ
class Base {
public:
    virtual ~Base() {} // 仮想デストラクタ
};
class Derived : public Base {};
int main() {
    Base* basePtr = new Derived(); // 基底クラスのポインタ
    if (typeid(*basePtr) == typeid(Derived)) { // typeidを使用した型判定
        std::cout << "basePtrはDerived型です。" << std::endl;
    } else {
        std::cout << "basePtrはDerived型ではありません。" << std::endl;
    }
    delete basePtr; // メモリの解放
    return 0;
}

basePtrはDerived型です。

#include <iostream>
#include <type_traits> // std::is_base_ofやstd::is_sameを使用するためのヘッダ
class Base {};
class Derived : public Base {};
int main() {
    std::cout << std::boolalpha; // boolをtrue/falseで表示
    // 基底クラスの判定
    std::cout << "DerivedはBaseの派生クラスか？: " 
              << std::is_base_of<Base, Derived>::value << std::endl;
    // 同じ型の判定
    std::cout << "BaseはBaseか？: " 
              << std::is_same<Base, Base>::value << std::endl;
    return 0;
}

DerivedはBaseの派生クラスか？: true
BaseはBaseか？: true