[class.prop] (original) (raw)

11 Classes [class]

11.2 Properties of classes [class.prop]

A trivially copyable class is a class:

• that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator ([special], [class.copy.ctor], [class.copy.assign]),
• where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and
• that has a trivial, non-deleted destructor ([class.dtor]).

A class C is default-movable if

• overload resolution for direct-initializing an object of type Cfrom an xvalue of type C selects a constructor that is a direct member of C and is neither user-provided nor deleted,
• overload resolution for assigning to an lvalue of type C from an xvalue of type C selects an assignment operator function that is a direct member of C and is neither user-provided nor deleted, and
• C has a destructor that is neither user-provided nor deleted.

A class is eligible for trivial relocation unless it

• has any virtual base classes,
• has a base class that is not a trivially relocatable class,
• has a non-static data member of an object type that is not of a trivially relocatable type, or
• has a deleted destructor,

except that it is implementation-defined whether an otherwise-eligible union having one or more subobjects of polymorphic class type is eligible for trivial relocation.

A class C is a trivially relocatable classif it is eligible for trivial relocation and

• has the trivially_relocatable_if_eligible class-property-specifier,
• is a union with no user-declared special member functions, or
• is default-movable.

[Note 1:

A class with const-qualified or reference non-static data members can be trivially relocatable.

— _end note_]

A class C is eligible for replacement unless

• it has a base class that is not a replaceable class,
• it has a non-static data member that is not of a replaceable type,
• overload resolution fails or selects a deleted constructor when direct-initializing an object of type C from an xvalue of typeC ([dcl.init.general]),
• overload resolution fails or selects a deleted assignment operator function when assigning to an lvalue of type C from an xvalue of typeC ([expr.assign], [over.assign])), or
• it has a deleted destructor.

A class C is a replaceable class if it is eligible for replacement and

• has the replaceable_if_eligible class-property-specifier,
• is a union with no user-declared special member functions, or
• is default-movable.

[Note 2:

Accessibility of the special member functions is not considered when establishing trivial relocatability or replaceability.

— _end note_]

[Note 3:

Not all trivially copyable classes are trivially relocatable or replaceable.

— _end note_]

A class S is a standard-layout class if it:

• has no non-static data members of type non-standard-layout class (or array of such types) or reference,
• has no virtual functions and novirtual base classes,
• has the same access controlfor all non-static data members,
• has no non-standard-layout base classes,
• has at most one base class subobject of any given type,
• has all non-static data members and bit-fields in the class and its base classes first declared in the same class, and
• has no element of the set M(S) of types as a base class, where for any type X, M(X) is defined as follows.88
  [Note 4:
  M(X) is the set of the types of all non-base-class subobjects that can be at a zero offset in X.
  — _end note_]
  • If X is a non-union class type with no non-static data members, the set M(X) is empty.
  • If X is a non-union class type with a non-static data member of type that is either of zero size or is the first non-static data member of X(where said member may be an anonymous union), the set M(X) consists of and the elements of.
  • If X is a union type, the set M(X) is the union of all and the set containing all , where each is the type of the non-static data member of X.
  • If X is an array type with element type , the set M(X) consists of and the elements of .
  • If X is a non-class, non-array type, the set M(X) is empty.

[Example 1: struct B { int i; }; struct C : B { }; struct D : C { }; struct E : D { char : 4; }; struct Q {};struct S : Q { };struct T : Q { };struct U : S, T { }; — _end example_]

[Note 5:

Standard-layout classes are useful for communicating with code written in other programming languages.

— _end note_]

[Example 2: struct N { int i;int j;virtual ~N();};struct T { int i;private: int j;};struct SL { int i;int j;~SL();};struct POD { int i;int j;}; — _end example_]

A class S is an implicit-lifetime class if

• it is an aggregate whose destructor is not user-provided or
• it has at least one trivial eligible constructor and a trivial, non-deleted destructor.