Classes

From cppreference.com
< cpp‎ | language
 
 
C++ language
General topics
Flow control
Conditional execution statements
if
Iteration statements (loops)
for
range-for (C++11)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++20)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
decltype (C++11)
auto (C++11)
alignas (C++11)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
Classes
Class-specific function properties
explicit (C++11)
static
Special member functions
Templates
Miscellaneous
 
 

A class is a user-defined type.

A class type is defined by class-specifier, which appears in decl-specifier-seq of the declaration syntax. See class declaration for the syntax of the class specifier.

A class can have the following kinds of members:

1) data members:
2) member functions:
3) nested types:
a) nested classes and enumerations defined within the class definition
b) aliases of existing types, defined with typedef or type alias (since C++11)declarations
c) the name of the class within its own definition acts as a public member type alias of itself for the purpose of lookup (except when used to name a constructor): this is known as injected-class-name
4) enumerators from all unscoped enumerations defined within the class, or introduced by using-declarations or using-enum-declarations (since C++20)
5) member templates (variable templates, (since C++14)class templates or function templates) may appear in the body of any non-local class/struct/union.

All members are defined at once in the class definition, they cannot be added to an already-defined class (unlike the members of namespaces)

A member of a class T cannot use T as its name if the member is

  • a static data member,
  • a member function,
  • a member type,
  • a member template,
  • an enumerator of an unscoped (since C++11) enumeration, or
  • a member of a member anonymous union.

However, a non-static data member may use the name T as long as there are no user-declared constructors.

A class with at least one declared or inherited virtual member function is polymorphic. Objects of this type are polymorphic objects and have runtime type information stored as part of the object representation, which may be queried with dynamic_cast and typeid. Virtual member functions participate in dynamic binding.

A class with at least one declared or inherited pure virtual member function is an abstract class. Objects of this type cannot be created.

A class with a constexpr constructor is a LiteralType: objects of this type can be manipulated by constexpr functions at compile time.

(since C++11)

Properties of classes

Trivially copyable class

A trivially copyable class is a class that

  • has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator
  • each copy constructor is either trivial or deleted
  • each move constructor is either trivial or deleted
  • each copy assignment operator is either trivial or deleted
  • each move assignment operator is either trivial or deleted, and
  • has a non-deleted trivial destructor.
(until C++20)
(since C++20)


Trivial class

A trivial class is a class that

  • is trivially copyable, and
  • has one or more default constructors, all of which are either trivial or deleted and at least one of which is not deleted.
(until C++20)
(since C++20)


Standard-layout class

A standard-layout class is a class that

  • has no non-static data members of type non-standard-layout class (or array of such types) or reference,
  • has no virtual functions and no virtual base classes,
  • has the same access control for all non-static data members,
  • has no non-standard-layout base classes,
  • has all non-static data members and bit-fields in the class and its base classes first declared in the same class, and
  • given the class as S, has no element of the set M(S) of types as a base class, where M(X) for a type X is defined as:
  • If X is a non-union class type with no (possibly inherited) non-static data members, the set M(X) is empty.
  • If X is a non-union class type whose first non-static data member has type X0 (where said member may be an anonymous union), the set M(X) consists of X0 and the elements of M(X0).
  • If X is a union type, the set M(X) is the union of all M(Ui) and the set containing all Ui, where each Ui is the type of the ith non-static data member of X.
  • If X is an array type with element type Xe, the set M(X) consists of Xe and the elements of M(Xe).
  • If X is a non-class, non-array type, the set M(X) is empty.


A standard-layout struct is a standard-layout class defined with the class keyword struct or the class keyword class. A standard-layout union is a standard-layout class defined with the class keyword union.

(since C++11)


Implicit-lifetime class

An implicit-lifetime class is a class that

  • is an aggregate, or
  • has at least one trivial eligible constructor and a trivial, non-deleted destructor.
(since C++20)


POD class

A POD class is a class that

  • is an aggregate,
  • has no user-declared copy assignment operator,
  • has no user-declared destructor, and
  • has no non-static data members of type non-POD class (or array of such types) or reference.
(until C++11)
  • is a trivial class,
  • is a standard-layout class, and
  • has no non-static data members of type non-POD class (or array of such types).
(since C++11)


A POD struct is a non-union POD class. A POD union is a union that is a POD class.

(until C++20)

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
CWG 148 C++98 POD classes could not contain pointers to member,
which are themselves POD (scalar) types
restriction removed
CWG 383 C++98 copy assignment operators or destructors could be
user-declared in POD classes if they are not defined
not allowed
CWG 1363 C++11 a class that has both trivial default constructors and non-trivial
default constructors at the same time could be trivial
it is non-trivial
CWG 1496 C++11 a class that only has constructors that
are all defined as deleted could be trivial
it is non-trivial
CWG 1672 C++11 a class could be a standard-layout class
if it has multiple empty base classes
it is not a standard-layout class
CWG 1734 C++11 a trivially copyable class could not have non-trivial
deleted copy/move constructors/assignment operators
can be trivial if deleted
CWG 1813 C++11 a class was never a standard-layout class if it has a
base class that inherits a non-static data member
it can be a standard-layout class
CWG 1881 C++11 for a standard-layout class and its base classes,
unnamed bit-fields might be declared in a
different class declaring the data members
all non-static data members
and bit-fields need to be first
declared in the same class
CWG 1909 C++98 a member template could have the same name as its class prohibited
CWG 2120 C++11 the definition of M(X) in determining a standard-
layout class did not consider the case of
a class whose first member is an array
addressed this case in
the definition of M(X)