std::is_implicit_lifetime - cppreference.com (original) (raw)
| | | | | --------------------------------------------------- | | ------------- | | template< class T > struct is_implicit_lifetime; | | (since C++23) |
std::is_implicit_lifetime is a UnaryTypeTrait.
If T is an implicit-lifetime type, provides the member constant value equal to true. For any other type, value is false.
The behavior is undefined if T is an incomplete type other than an array type or (possibly cv-qualified) void.
If the program adds specializations for std::is_implicit_lifetime or std::is_implicit_lifetime_v, the behavior is undefined.
Contents
[edit] Template parameters
[edit] Helper variable template
| template< class T > constexpr bool is_implicit_lifetime_v = is_implicit_lifetime<T>::value; | | (since C++23) | | --------------------------------------------------------------------------------------------------- | | ------------- |
Inherited from std::integral_constant
Member constants
| | true if T is an implicit-lifetime type, false otherwise (public static member constant) | | ------------------------------------------------------------------------------------------ |
Member functions
| | converts the object to bool, returns value (public member function) | | ---------------------------------------------------------------------- | | | returns value (public member function) |
Member types
[edit] Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
| __cpp_lib_is_implicit_lifetime | 202302L | (C++23) | std::is_implicit_lifetime |
[edit] Example
// The following types are collectively called implicit-lifetime types:
// * scalar types:
// * arithmetic types
// * enumeration types
// * pointer types
// * pointer-to-member types
// * std::nullptr_t
// * implicit-lifetime class types
// * is an aggregate whose destructor is not user-provided
// * has at least one trivial eligible constructor and a trivial,
// non-deleted destructor
// * array types
// * cv-qualified versions of these types.
#include
static_assert(std::is_implicit_lifetime_v); // arithmetic type is a scalar type
static_assert(std::is_implicit_lifetime_v); // cv-qualified a scalar type
enum E { e };
static_assert(std::is_implicit_lifetime_v); // enumeration type is a scalar type
static_assert(std::is_implicit_lifetime_v<int*>); // pointer type is a scalar type
static_assert(std::is_implicit_lifetime_v<std::nullptr_t>); // scalar type
struct S { int x, y; };
// S is an implicit-lifetime class: an aggregate without user-provided destructor
static_assert(std::is_implicit_lifetime_v);
static_assert(std::is_implicit_lifetime_v<int S::*>); // pointer-to-member
struct X { ~X() = delete; };
// X is not implicit-lifetime class due to deleted destructor
static_assert(!std::is_implicit_lifetime_v);
static_assert(std::is_implicit_lifetime_v<int[8]>); // array type
static_assert(std::is_implicit_lifetime_v<volatile int[8]>); // cv-qualified array type
int main() {}