std:: is_base_of

std::is_base_of est un BinaryTypeTrait .

Si Derived est dérivé de Base ou si les deux sont la même classe non-union (dans les deux cas en ignorant les qualifications cv), fournit la constante membre value égale à true . Sinon value est false .

Si les deux Base et Derived sont des types de classe non-union, et qu'ils ne sont pas du même type (en ignorant les qualifications cv), Derived doit être un type complet ; sinon le comportement est indéfini.

Si le programme ajoute des spécialisations pour std::is_base_of ou std::is_base_of_v (depuis C++17) , le comportement est indéfini.

Modèle de variable d'assistance

Notes

std :: is_base_of < A, B > :: value est true même si A est une classe de base privée, protégée ou ambiguë de B . Dans de nombreuses situations, std:: is_convertible < B * , A * > est le test plus approprié.

Bien qu'aucune classe ne soit sa propre base, std :: is_base_of < T, T > :: value est vrai car l'intention de ce trait est de modéliser la relation "est-un", et T est un T . Malgré cela, std :: is_base_of < int , int > :: value est false car seules les classes participent à la relation que ce trait modélise.

Implémentation Possible

namespace details
{
    template<typename B>
    std::true_type test_ptr_conv(const volatile B*);
    template<typename>
    std::false_type test_ptr_conv(const volatile void*);
    template<typename B, typename D>
    auto test_is_base_of(int) -> decltype(test_ptr_conv<B>(static_cast<D*>(nullptr)));
    template<typename, typename>
    auto test_is_base_of(...) -> std::true_type; // base privée ou ambiguë
}
template<typename Base, typename Derived>
struct is_base_of :
    std::integral_constant<
        bool,
        std::is_class<Base>::value &&
        std::is_class<Derived>::value &&
        decltype(details::test_is_base_of<Base, Derived>(0))::value
    > {};

Exemple

#include <type_traits>
class A {};
class B : A {};
class C : B {};
class D {};
union E {};
using I = int;
static_assert
(
    std::is_base_of_v<A, A> == true &&
    std::is_base_of_v<A, B> == true &&
    std::is_base_of_v<A, C> == true &&
    std::is_base_of_v<A, D> != true &&
    std::is_base_of_v<B, A> != true &&
    std::is_base_of_v<E, E> != true &&
    std::is_base_of_v<I, I> != true
);
int main() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi