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

FreeBSD Manual Pages

  
 
  

home | help 
std::is_poi...ble_base_of(3)  C++ Standard Libary std::is_poi...ble_base_of(3)

NAME
       std::is_pointer_interconvertible_base_of	  -  std::is_pointer_intercon-
       vertible_base_of

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

	  If Derived is	unambiguously derived from Base	and every Derived  ob-
       ject is
	  pointer-interconvertible with	its Base subobject, 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	shall be a complete type; oth-
       erwise the
	  behavior is undefined.

	  If the program adds  specializations	for  std::is_pointer_intercon-
       vertible_base_of	or
	  std::is_pointer_interconvertible_base_of_v,  the  behavior  is unde-
       fined.

Member constants
		   true	if Derived is  unambiguously  derived  from  Base  and
       every Derived object
	  value	    is pointer-interconvertible	with its Base subobject, or if
       both are	the
	  [static] same	non-union class	(in both cases ignoring	 cv-qualifica-
       tion), false
		   otherwise
		   (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_pointer_interconvertible_base_of_v<T,	U> may be true even if
       T is a private
	  or protected base class of U.

	  Let

	    * U	be a complete object type,
	    *  T be a complete object type with	cv-qualification not less than
       U,
	    * u	be any valid lvalue of U,

	  reinterpret_cast<T&>(u) always has well-defined result if
	  std::is_pointer_interconvertible_base_of_v<T,	U> is true.

	  If T and U are not the same type (ignoring cv-qualification)	and  T
       is a
	  pointer-interconvertible  base  class	 of U, then both std::is_stan-
       dard_layout_v<T>	and
	  std::is_standard_layout_v<U> are true.

	  If T is standard layout class	type, then all base classes of	T  (if
       any) are
	  pointer-interconvertible base	class of T.

		Feature-test	    macro		    Value	   Std
       Feature
							     Pointer-intercon-
       vertibility   traits:   __cpp_lib_is_pointer_interconvertible   201907L
       (C++20)	 * std::is_pointer_interconvertible_base_of,
							       *
       std::is_pointer_interconvertible_with_class

Example
       // Run this code

	#include <type_traits>

	struct Foo {};

	struct Bar {};

	class Baz : Foo, public	Bar { int x; };

	class NonStdLayout : public Baz	{ int y; };

	static_assert(std::is_pointer_interconvertible_base_of_v<Bar, Baz>);
	static_assert(std::is_pointer_interconvertible_base_of_v<Foo, Baz>);
	static_assert(not std::is_pointer_interconvertible_base_of_v<Baz, Non-
       StdLayout>);
	static_assert(std::is_pointer_interconvertible_base_of_v<NonStdLayout,
       NonStdLayout>);

	int main() {}

See also
	  is_base_of	     checks if a type is derived from the other	type
	  (C++11)	     (class template)
	  is_empty	      checks if	a type is a class (but not union) type
       and has no
	  (C++11)	     non-static	data members
			     (class template)
	  is_standard_layout checks if a type is a standard-layout type
	  (C++11)	     (class template)

http://cppreference.com		  2024.06.10	  std::is_poi...ble_base_of(3)

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

home | help