Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::is_base_of(3)	      C++ Standard Libary	    std::is_base_of(3)

NAME
       std::is_base_of - std::is_base_of

Synopsis
	  Defined in header <type_traits>
	  template< class Base,	class Derived >	 (since	C++11)
	  struct is_base_of;

	  std::is_base_of is a BinaryTypeTrait.

	  If  Derived  is  derived from	Base or	if both	are the	same non-union
       class (in both
	  cases	ignoring cv-qualification), provides the member	constant value
       equal to	true.
	  Otherwise value is false.

	  If both Base and Derived are non-union class types, and they are not
       the same	type
	  (ignoring cv-qualification), Derived should be a complete type; oth-
       erwise the
	  behavior is undefined.

	  If the program adds specializations for std::is_base_of
	  or std::is_base_of_v
	  (since C++17), the behavior is undefined.

Member constants
	  value	   true	if Derived is derived from Base	or  if	both  are  the
       same non-union
	  [static] class (in both cases	ignoring cv-qualification), false oth-
       erwise
		   (public static member constant)

Member functions
	  operator bool	converts the object to bool, returns value
			(public	member function)
	  operator()	returns	value
	  (C++14)	(public	member function)

Member types
	  Type	     Definition
	  value_type bool
	  type	     std::integral_constant<bool, value>

Notes
	  std::is_base_of<A,  B>::value	 is  true even if A is a private, pro-
       tected, or ambiguous
	  base class of	B. In many situations, std::is_convertible<B*, A*>  is
       the more
	  appropriate test.

	  Although  no	class is its own base, std::is_base_of<T, T>::value is
       true because the
	  intent of the	trait is to model the "is-a" relationship, and T is  a
       T. Despite that,
	  std::is_base_of<int,	int>::value is false because only classes par-
       ticipate	in the
	  relationship that this trait models.

	  Possible Implementation

	  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>(sta-
       tic_cast<D*>(nullptr)));
	      template<typename, typename>
	      auto  test_is_base_of(...)  -> std::true_type; //	private	or am-
       biguous base
	  }

	  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
	      >	{};

Example
       // Run this code

	#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() {}

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	   Applied to	     Behavior as  published		  Cor-
       rect behavior
	  LWG  2015  C++11	 the  behavior might be	undefined if  the base
       characteristic is
			      Derived	is   an	   incomplete	 union	  type
       std::false_type in this case

See also
	  is_convertible
	  is_nothrow_convertible  checks  if  a	 type  can be converted	to the
       other type
	  (C++11)		 (class	template)
	  (C++20)
	  derived_from		 specifies that	a type is derived from another
       type
	  (C++20)		 (concept)

http://cppreference.com		  2024.06.10		    std::is_base_of(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::is_base_of&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help