std::is_base_of
| Definido en el archivo de encabezado <type_traits>
|
||
template< class Base, class Derived > struct is_base_of; |
(desde C++11) | |
Si Derived se deriva de Base o si ambas son de la misma clase que no es una unión (en ambos casos ignorando la calificación-cv), proporciona la constante miembro value igual a true. De lo contrario, value es false.
Si tanto Base como Derived son tipos clase que no son una unión, y no son el mismo tipo (ignorando la calificación-cv), Derived deberá ser un tipo completo; de lo contrario el comportamiento está indefinido.
El comportamiento de un programa que añade especializaciones para is_base_of o is_base_of_v (desde C++17) no está definido.
Plantilla de variable auxiliar
<tbody> </tbody> template< class Base, class Derived > inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value; |
(desde C++17) | |
Heredado de std::integral_constant
Constantes miembro
value [estático] |
true si Derived se deriva de Base o si ambas son de la misma clase que no es una unión (en ambos casos ignorando la calificación-cv), de lo contrario false. (constante miembro pública estática) |
Funciones miembro
operator bool |
Convierte el objeto a bool, devuelve value. (función miembro pública) |
operator() (C++14) |
Devuelve value. (función miembro pública) |
Tipos miembro
| Tipo | Definición |
value_type
|
bool
|
type
|
std::integral_constant<bool, value>
|
Notas
std::is_base_of<A, B>::value es true incluso si A es una clase base privada, protegida o ambigua de B. En muchas situaciones, std::is_convertible<B*, A*> es la prueba más apropriada.
Aunque ninguna clase es su propia base, std::is_base_of<T, T>::value es true porque la intención del rasgo es modelar una relación "es-una" (is-a), y T es una T. A pesar de eso, std::is_base_of<int, int>::value es false porque solamente las clases participan en la relación que este rasgo modela.
Posible implementación
namespace details {
template <typename B>
std::true_type test_pre_ptr_convertible(const volatile B*);
template <typename>
std::false_type test_pre_ptr_convertible(const volatile void*);
template <typename, typename>
auto test_pre_is_base_of(...) -> std::true_type;
template <typename B, typename D>
auto test_pre_is_base_of(int) ->
decltype(test_pre_ptr_convertible<B>(static_cast<D*>(nullptr)));
}
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_pre_is_base_of<Base, Derived>(0))::value
> { };
|
Ejemplo
#include <iostream>
#include <type_traits>
class A {};
class B : A {};
class C {};
int main()
{
std::cout << std::boolalpha;
std::cout << "a2b: " << std::is_base_of<A, B>::value << '\n';
std::cout << "b2a: " << std::is_base_of<B, A>::value << '\n';
std::cout << "c2b: " << std::is_base_of<C, B>::value << '\n';
std::cout << "same type: " << std::is_base_of<C, C>::value << '\n';
}
Salida:
a2b: true
b2a: false
c2b: false
same type: true
Véase también
(C++11)(C++20) |
Comprueba si un tipo puede convertirse a otro tipo. (plantilla de clase) |