class template
<type_traits>

std::is_standard_layout

template <class T> struct is_standard_layout;
Is standard-layout type

Trait class that identifies whether T is a standard-layout type.

A standard-layout type is a type with a simple linear data structure and access control that can easily be used to communicate with code written in other programming languages, such as C, either cv-qualified or not. This is true for scalar types, standard-layout classes and arrays of any such types.

A standard-layout class is a class (defined with class, struct or union) that:
  • has no virtual functions and no virtual base classes.
  • has the same access control (private, protected, public) for all its non-static data members.
  • either has no non-static data members in the most derived class and at most one base class with non-static data members, or has no base classes with non-static data members.
  • its base class (if any) is itself also a standard-layout class. And,
  • has no base classes of the same type as its first non-static data member.

This class inherits from integral_constant as being either true_type or false_type, depending on whether T is a trivial type.

Template parameters

T
A complete type, or void (possible cv-qualified), or an array of unknown bound.

Member types

Inherited from integral_constant:
member typedefinition
value_typebool
typeeither true_type or false_type

Member constants

Inherited from integral_constant:
member constantdefinition
valueeither true or false

Member functions

Inherited from integral_constant:
operator bool
Returns value (public member function )

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// is_standard_layout example
#include <iostream>
#include <type_traits>

struct A { int i; };

struct B : A { int j; };

int main() {
  std::cout << std::boolalpha;
  std::cout << "is_standard_layout:" << std::endl;
  std::cout << "int: " << std::is_standard_layout<int>::value << std::endl;
  std::cout << "A: " << std::is_standard_layout<A>::value << std::endl;
  std::cout << "B: " << std::is_standard_layout<B>::value << std::endl;
  return 0;
}


Output:
is_standard_layout:
int: true
A: true
B: false

See also

is_pod
Is POD type (class template )
is_trivial
Is trivial type (class template )
is_trivially_copyable
Is trivially copyable (class template )

C++

<type_traits>