std::derived_from

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Concepts library

Core language concepts same_as derived_from convertible_to common_reference_with      common_with integral signed_integral unsigned_integral floating_point swappableswappable_with destructible constructible_from default_initializable move_constructible copy_constructible assignable_from

Comparison concepts equality_comparableequality_comparable_with totally_orderedtotally_ordered_with Object concepts movable copyable semiregular regular Callable concepts invocableregular_invocable predicate relation equivalence_relation strict_weak_order

Exposition-only concepts boolean-testable

 

Defined in header <concepts>
template< class Derived, class Base > concept derived_from =   std::is_base_of_v<Base, Derived> &&   std::is_convertible_v<const volatile Derived*, const volatile Base*>;		(since C++20)

The concept derived_from<Derived, Base> is satisfied if and only if Base is a class type that is either Derived or a public and unambiguous base of Derived, ignoring cv-qualifiers.

Note that this behavior is different to std::is_base_of when Base is a private or protected base of Derived.

Example

Run this code

#include <concepts>
 
class A {};
 
class B: public A {};
 
class C: private A {};
 
int main()
{
    // std::derived_from == true only for public inheritance or exact same class
    static_assert( std::derived_from<B, B> == true );      // same class: true
    static_assert( std::derived_from<int, int> == false ); // same primitive type: false
    static_assert( std::derived_from<B, A> == true );      // public inheritance: true
    static_assert( std::derived_from<C, A> == false );     // private inheritance: false
 
    // std::is_base_of == true also for private inheritance
    static_assert( std::is_base_of_v<B, B> == true );      // same class: true
    static_assert( std::is_base_of_v<int, int> == false ); // same primitive type: false
    static_assert( std::is_base_of_v<A, B> == true );      // public inheritance: true
    static_assert( std::is_base_of_v<A, C> == true );      // private inheritance: true
}

See also

is_base_of (C++11)	checks if a type is derived from the other type (class template)
is_convertibleis_nothrow_convertible (C++11)(C++20)	checks if a type can be converted to the other type (class template)