10 Classes [class]

10.3 Class members [class.mem]

10.3.4 Constructors [class.ctor]

1
#
Constructors do not have names.
In a declaration of a constructor, the declarator is a function declarator ([dcl.fct]) of the form
ptr-declarator ( parameter-declaration-clause ) noexcept-specifier attribute-specifier-seq
where the ptr-declarator consists solely of an id-expression, an optional attribute-specifier-seq, and optional surrounding parentheses, and the id-expression has one of the following forms:
The class-name shall not be a typedef-name.
In a constructor declaration, each decl-specifier in the optional decl-specifier-seq shall be friend, inline, constexpr, or an explicit-specifier.
[ Example
: 
struct S {
  S();              // declares the constructor
};

S::S() { }          // defines the constructor
— end example
 ]
2
#
A constructor is used to initialize objects of its class type.
Because constructors do not have names, they are never found during name lookup; however an explicit type conversion using the functional notation ([expr.type.conv]) will cause a constructor to be called to initialize an object.
[ Note
:
For initialization of objects of class type see [class.init].
— end note
 ]
3
#
A constructor can be invoked for a const, volatile or const volatile object.
const and volatile semantics ([dcl.type.cv]) are not applied on an object under construction.
They come into effect when the constructor for the most derived object ([intro.object]) ends.
4
#
A default constructor for a class X is a constructor of class X for which each parameter that is not a function parameter pack has a default argument (including the case of a constructor with no parameters).
If there is no user-declared constructor for class X, a non-explicit constructor having no parameters is implicitly declared as defaulted ([dcl.fct.def]).
An implicitly-declared default constructor is an inline public member of its class.
5
#
A defaulted default constructor for class X is defined as deleted if:
  • (5.1)
    X is a union that has a variant member with a non-trivial default constructor and no variant member of X has a default member initializer,
  • (5.2)
    X is a non-union class that has a variant member M with a non-trivial default constructor and no variant member of the anonymous union containing M has a default member initializer,
  • (5.3)
    any non-static data member with no default member initializer ([class.mem]) is of reference type,
  • (5.4)
    any non-variant non-static data member of const-qualified type (or array thereof) with no brace-or-equal-initializer does not have a user-provided default constructor,
  • (5.5)
    X is a union and all of its variant members are of const-qualified type (or array thereof),
  • (5.6)
    X is a non-union class and all members of any anonymous union member are of const-qualified type (or array thereof),
  • (5.7)
    any potentially constructed subobject, except for a non-static data member with a brace-or-equal-initializer, has class type M (or array thereof) and either M has no default constructor or overload resolution ([over.match]) as applied to find M's corresponding constructor results in an ambiguity or in a function that is deleted or inaccessible from the defaulted default constructor, or
  • (5.8)
    any potentially constructed subobject has a type with a destructor that is deleted or inaccessible from the defaulted default constructor.
6
#
A default constructor is trivial if it is not user-provided and if:
  • (6.1)
    its class has no virtual functions ([class.virtual]) and no virtual base classes ([class.mi]), and
  • (6.2)
    no non-static data member of its class has a default member initializer ([class.mem]), and
  • (6.3)
    all the direct base classes of its class have trivial default constructors, and
  • (6.4)
    for all the non-static data members of its class that are of class type (or array thereof), each such class has a trivial default constructor.
Otherwise, the default constructor is non-trivial.
7
#
A default constructor that is defaulted and not defined as deleted is implicitly defined when it is odr-used ([basic.def.odr]) to create an object of its class type ([intro.object]), when it is needed for constant evaluation ([expr.const]), or when it is explicitly defaulted after its first declaration.
The implicitly-defined default constructor performs the set of initializations of the class that would be performed by a user-written default constructor for that class with no ctor-initializer and an empty compound-statement.
If that user-written default constructor would be ill-formed, the program is ill-formed.
If that user-written default constructor would satisfy the requirements of a constexpr constructor ([dcl.constexpr]), the implicitly-defined default constructor is constexpr.
Before the defaulted default constructor for a class is implicitly defined, all the non-user-provided default constructors for its base classes and its non-static data members shall have been implicitly defined.
[ Note
:
An implicitly-declared default constructor has an exception specification ([except.spec]).
An explicitly-defaulted definition might have an implicit exception specification, see [dcl.fct.def].
— end note
 ]
8
#
Default constructors are called implicitly to create class objects of static, thread, or automatic storage duration ([basic.stc.static], [basic.stc.thread], [basic.stc.auto]) defined without an initializer ([dcl.init]), are called to create class objects of dynamic storage duration ([basic.stc.dynamic]) created by a new-expression in which the new-initializer is omitted ([expr.new]), or are called when the explicit type conversion syntax ([expr.type.conv]) is used.
A program is ill-formed if the default constructor for an object is implicitly used and the constructor is not accessible ([class.access]).
9
#
[ Note
:
[class.base.init] describes the order in which constructors for base classes and non-static data members are called and describes how arguments can be specified for the calls to these constructors.
— end note
 ]
10
#
A return statement in the body of a constructor shall not specify a return value.
The address of a constructor shall not be taken.
11
#
A functional notation type conversion ([expr.type.conv]) can be used to create new objects of its type.
[ Note
:
The syntax looks like an explicit call of the constructor.
— end note
 ]
[ Example
: 
complex zz = complex(1,2.3);
cprint( complex(7.8,1.2) );
— end example
 ]
12
#
An object created in this way is unnamed.
[ Note
:
[class.temporary] describes the lifetime of temporary objects.
— end note
 ]
[ Note
:
Explicit constructor calls do not yield lvalues, see [basic.lval].
— end note
 ]
13
#
[ Note
:
Some language constructs have special semantics when used during construction; see [class.base.init] and [class.cdtor].
— end note
 ]
14
#
During the construction of an object, if the value of the object or any of its subobjects is accessed through a glvalue that is not obtained, directly or indirectly, from the constructor's this pointer, the value of the object or subobject thus obtained is unspecified.
[ Example
: 
struct C;
void no_opt(C*);

struct C {
  int c;
  C() : c(0) { no_opt(this); }
};

const C cobj;

void no_opt(C* cptr) {
  int i = cobj.c * 100;         // value of cobj.c is unspecified
  cptr->c = 1;
  cout << cobj.c * 100          // value of cobj.c is unspecified
       << '\n';
}

extern struct D d;
struct D {
  D(int a) : a(a), b(d.a) {}
  int a, b;
};
D d = D(1);                     // value of d.b is unspecified
— end example
 ]