______________________________________________________________________
12 Special member functions [special]
______________________________________________________________________
1 The default constructor (_class.ctor_), copy constructor and copy
assignment operator (_class.copy_), and destructor (_class.dtor_) are
special member functions. The implementation will implicitly declare
these member functions for a class type when the program does not
explicitly declare them, except as noted in _class.ctor_. The imple-
mentation will implicitly define them if they are used, as specified
in _class.ctor_, _class.dtor_ and _class.copy_. Programs shall not
define implicitly-declared special member functions. Programs may
explicitly refer to implicitly declared special member functions.
[Example: a program may explicitly call, take the address of or form a
pointer to member to an implicitly declared special member function.
struct A { }; // implicitly-declared `A::operator='
struct B : A {
B& operator=(const B &);
};
B& B::operator=(const B& s) {
this->A::operator=(s); // well-formed
}
--end example] [Note: the special member functions affect the way
objects of class type are created, copied, and destroyed, and how val-
ues can be converted to values of other types. Often such special
member functions are called implicitly. ]
2 Special member functions obey the usual access rules (clause
_class.access_). [Example: declaring a constructor protected ensures
that only derived classes and friends can create objects using it. ]
12.1 Constructors [class.ctor]
1 Constructors do not have names. A special declarator syntax using an
optional function-specifier (_dcl.fct.spec_) followed by the construc-
tor's class name followed by a parameter list is used to declare or
define the constructor. In such a declaration, optional parentheses
around the constructor class name are ignored. [Example:
class C {
public:
C(); // declares the constructor
};
C::C() { } // 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_. ]
3 A typedef-name that names a class is a class-name (_dcl.typedef_);
however, a typedef-name that names a class shall not be used as the
identifier in the declarator for a constructor declaration.
4 A constructor shall not be virtual (_class.virtual_) or static
(_class.static_). A constructor can be invoked for a const, volatile
or const volatile object. A constructor shall not be declared const,
volatile, or const volatile (_class.this_). const and volatile seman-
tics (_dcl.type.cv_) are not applied on an object under construction.
Such semantics only come into effect once the constructor for the most
derived object (_intro.object_) ends.
5 A default constructor for a class X is a constructor of class X that
can be called without an argument. If there is no user-declared con-
structor for class X, a default constructor is implicitly declared.
An implicitly-declared default constructor is an inline public member
of its class. A constructor is trivial if it is an implicitly-
declared default constructor and if:
--its class has no virtual functions (_class.virtual_) and no virtual
base classes (_class.mi_), and
--all the direct base classes of its class have trivial constructors,
and
--for all the nonstatic data members of its class that are of class
type (or array thereof), each such class has a trivial constructor.
6 Otherwise, the constructor is non-trivial.
7 An implicitly-declared default constructor for a class is implicitly
defined when it is used to create an object of its class type
(_intro.object_). 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 an empty mem-ini-
tializer-list (_class.base.init_) and an empty function body. If that
user-written default constructor would be ill-formed, the program is
ill-formed. Before the implicitly-declared default constructor for a
class is implicitly defined, all the implicitly-declared default con-
structors for its base classes and its nonstatic data members shall
have been implicitly defined. [Note: an implicitly-declared default
constructor has an exception-specification (_except.spec_). ]
8 Default constructors are called implicitly to create class objects of
static or automatic storage duration (_basic.stc.static_,
_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 (clause _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. ]
10A copy constructor for a class X is a constructor with a first parame-
ter of type X& or of type const X&. [Note: see _class.copy_ for more
information on copy constructors. ]
11A union member shall not be of a class type (or array thereof) that
has a non-trivial constructor.
12No return type (not even void) shall be specified for a constructor.
A return statement in the body of a constructor shall not specify a
return value. The address of a constructor shall not be taken.
13A 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. ] [Example:
complex zz = complex(1,2.3);
cprint( complex(7.8,1.2) );
--end example] An object created in this way is unnamed. [Note:
_class.temporary_ describes the lifetime of temporary objects. ]
[Note: explicit constructor calls do not yield lvalues, see
_basic.lval_. ]
14[Note: some language constructs have special semantics when used dur-
ing construction; see _class.base.init_ and _class.cdtor_. ]
15During the construction of a const object, if the value of the object
or any of its subobjects is accessed through an lvalue 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
<< '0;
}
--end example]
12.2 Temporary objects [class.temporary]
1 Temporaries of class type are created in various contexts: binding an
rvalue to a reference (_dcl.init.ref_), returning an rvalue
(_stmt.return_), a conversion that creates an rvalue (_conv.lval_,
_expr.static.cast_, _expr.const.cast_, _expr.cast_), throwing an
exception (_except.throw_), entering a handler (_except.handle_), and
in some initializations (_dcl.init_). [Note: the lifetime of excep-
tion objects is described in _except.throw_. ] Even when the creation
of the temporary object is avoided, all the semantic restrictions must
be respected as if the temporary object was created. [Example: even
if the copy constructor is not called, all the semantic restrictions,
such as accessibility (clause _class.access_), shall be satisfied. ]
2 [Example:
class X {
// ...
public:
// ...
X(int);
X(const X&);
~X();
};
X f(X);
void g()
{
X a(1);
X b = f(X(2));
a = f(a);
}
Here, an implementation might use a temporary in which to construct
X(2) before passing it to f() using X's copy-constructor; alterna-
tively, X(2) might be constructed in the space used to hold the argu-
ment. Also, a temporary might be used to hold the result of f(X(2))
before copying it to b using X's copy-constructor; alternatively,
f()'s result might be constructed in b. On the other hand, the
expression a=f(a) requires a temporary for either the argument a or
the result of f(a) to avoid undesired aliasing of a. ]
3 When an implementation introduces a temporary object of a class that
has a non-trivial constructor (_class.ctor_), it shall ensure that a
constructor is called for the temporary object. Similarly, the
destructor shall be called for a temporary with a non-trivial
destructor (_class.dtor_). Temporary objects are destroyed as the
last step in evaluating the full-expression (_intro.execution_) that
(lexically) contains the point where they were created. This is true
even if that evaluation ends in throwing an exception.
4 There are two contexts in which temporaries are destroyed at a differ-
ent point than the end of the full-expression. The first context is
when an expression appears as an initializer for a declarator defining
an object. In that context, the temporary that holds the result of
the expression shall persist until the object's initialization is com-
plete. The object is initialized from a copy of the temporary; during
this copying, an implementation can call the copy constructor many
times; the temporary is destroyed after it has been copied, before or
when the initialization completes. If many temporaries are created by
the evaluation of the initializer, the temporaries are destroyed in
reverse order of the completion of their construction.
5 The second context is when a reference is bound to a temporary. The
temporary to which the reference is bound or the temporary that is the
complete object to a subobject of which the temporary is bound per-
sists for the lifetime of the reference or until the end of the scope
in which the temporary is created, whichever comes first. A temporary
holding the result of an initializer expression for a declarator that
declares a reference persists until the end of the scope in which the
reference declaration occurs. A temporary bound to a reference member
in a constructor's ctor-initializer (_class.base.init_) persists until
the constructor exits. A temporary bound to a reference parameter in
a function call (_expr.call_) persists until the completion of the
full expression containing the call. A temporary bound to the
returned value in a function return statement (_stmt.return_) persists
until the function exits. In all these cases, the temporaries created
during the evaluation of the expression initializing the reference,
except the temporary to which the reference is bound, are destroyed at
the end of the full-expression in which they are created and in the
reverse order of the completion of their construction. If the life-
time of two or more temporaries to which references are bound ends at
the same point, these temporaries are destroyed at that point in the
reverse order of the completion of their construction. In addition,
the destruction of temporaries bound to references shall take into
account the ordering of destruction of objects with static or auto-
matic storage duration (_basic.stc.static_, _basic.stc.auto_); that
is, if obj1 is an object with static or automatic storage duration
created before the temporary is created, the temporary shall be
destroyed before obj1 is destroyed; if obj2 is an object with static
or automatic storage duration created after the temporary is created,
the temporary shall be destroyed after obj2 is destroyed. [Example:
class C {
// ...
public:
C();
C(int);
friend C operator+(const C&, const C&);
~C();
};
C obj1;
const C& cr = C(16)+C(23);
C obj2;
the expression C(16)+C(23) creates three temporaries. A first tempo-
rary T1 to hold the result of the expression C(16), a second temporary
T2 to hold the result of the expression C(23), and a third temporary
T3 to hold the result of the addition of these two expressions. The
temporary T3 is then bound to the reference cr. It is unspecified
whether T1 or T2 is created first. On an implementation where T1 is
created before T2, it is guaranteed that T2 is destroyed before T1.
The temporaries T1 and T2 are bound to the reference parameters of
operator+; these temporaries are destroyed at the end of the full
expression containing the call to operator+. The temporary T3 bound
to the reference cr is destroyed at the end of cr's lifetime, that is,
at the end of the program. In addition, the order in which T3 is
destroyed takes into account the destruction order of other objects
with static storage duration. That is, because obj1 is constructed
before T3, and T3 is constructed before obj2, it is guaranteed that
obj2 is destroyed before T3, and that T3 is destroyed before obj1. ]
12.3 Conversions [class.conv]
1 Type conversions of class objects can be specified by constructors and
by conversion functions. These conversions are called user-defined
conversions and are used for implicit type conversions (clause
_conv_), for initialization (_dcl.init_), and for explicit type con-
versions (_expr.cast_, _expr.static.cast_).
2 User-defined conversions are applied only where they are unambiguous
(_class.member.lookup_, _class.conv.fct_). Conversions obey the
access control rules (clause _class.access_). Access control is
applied after ambiguity resolution (_basic.lookup_).
3 [Note: See _over.match_ for a discussion of the use of conversions in
function calls as well as examples below. ]
12.3.1 Conversion by constructor [class.conv.ctor]
1 A constructor declared without the function-specifier explicit that
can be called with a single parameter specifies a conversion from the
type of its first parameter to the type of its class. Such a con-
structor is called a converting constructor. [Example:
class X {
// ...
public:
X(int);
X(const char*, int =0);
};
void f(X arg)
{
X a = 1; // `a = X(1)'
X b = "Jessie"; // `b = X("Jessie",0)'
a = 2; // `a = X(2)'
f(3); // `f(X(3))'
}
--end example]
2 An explicit constructor constructs objects just like non-explicit con-
structors, but does so only where the direct-initialization syntax
(_dcl.init_) or where casts (_expr.static.cast_, _expr.cast_) are
explicitly used. A default constructor may be an explicit construc-
tor; such a constructor will be used to perform default-initialization
(_dcl.init_). [Example:
class Z {
public:
explicit Z();
explicit Z(int);
// ...
};
Z a; // ok: default-initialization performed
Z a1 = 1; // error: no implicit conversion
Z a3 = Z(1); // ok: direct initialization syntax used
Z a2(1); // ok: direct initialization syntax used
Z* p = new Z(1); // ok: direct initialization syntax used
Z a4 = (Z)1; // ok: explicit cast used
Z a5 = static_cast<Z>(1); // ok: explicit cast used
--end example]
3 A copy-constructor (_class.copy_) is a converting constructor. An
implicitly-declared copy constructor is not an explicit constructor;
it may be called for implicit type conversions.
4 At most one user-defined conversion (constructor or conversion func-
tion) is implicitly applied to a single value. [Example:
class X {
// ...
public:
operator int();
};
class Y {
// ...
public:
operator X();
};
Y a;
int b = a; // error:
// `a.operator X().operator int()' not tried
int c = X(a); // ok: `a.operator X().operator int()'
--end example]
5 User-defined conversions are used implicitly only if they are unam-
biguous. A conversion function in a derived class does not hide a
conversion function in a base class unless the two functions convert
to the same type. Function overload resolution (_over.match.best_)
selects the best conversion function to perform the conversion.
[Example:
class X {
public:
// ...
operator int();
};
class Y : public X {
public:
// ...
operator char();
};
void f(Y& a)
{
if (a) { // ill-formed:
// `X::operator int()' or `Y::operator char()'
// ...
}
}
--end example]
12.3.2 Conversion functions [class.conv.fct]
1 A member function of a class X with a name of the form
conversion-function-id:
operator conversion-type-id
conversion-type-id:
type-specifier-seq conversion-declaratoropt
conversion-declarator:
ptr-operator conversion-declaratoropt
specifies a conversion from X to the type specified by the conversion-
type-id. Such member functions are called conversion functions.
Classes, enumerations, and typedef-names shall not be declared in the
type-specifier-seq. Neither parameter types nor return type can be
specified. The type of a conversion function (_dcl.fct_) is "function
taking no parameter returning conversion-type-id." A conversion func-
tion is never used to convert a (possibly cv-qualified) object to the
(possibly cv-qualified) same object type (or a reference to it), to a
(possibly cv-qualified) base class of that type (or a reference to
it), or to (possibly cv-qualified) void.1)
_________________________
1) Even though never directly called to perform a conversion, such
conversion functions can be declared and can potentially be reached
through a call to a virtual conversion function in a base class
2 [Example:
class X {
// ...
public:
operator int();
};
void f(X a)
{
int i = int(a);
i = (int)a;
i = a;
}
In all three cases the value assigned will be converted by
X::operator int(). --end example]
3 User-defined conversions are not restricted to use in assignments and
initializations. [Example:
void g(X a, X b)
{
int i = (a) ? 1+a : 0;
int j = (a&&b) ? a+b : i;
if (a) { // ...
}
}
--end example]
4 The conversion-type-id shall not represent a function type nor an
array type. The conversion-type-id in a conversion-function-id is the
longest possible sequence of conversion-declarators. [Note: this pre-
vents ambiguities between the declarator operator * and its expression
counterparts. [Example:
&ac.operator int*i; // syntax error:
// parsed as: `&(ac.operator int *) i'
// not as: `&(ac.operator int)*i'
The * is the pointer declarator and not the multiplication operator.
] ]
5 Conversion functions are inherited.
6 Conversion functions can be virtual.
12.4 Destructors [class.dtor]
1 A special declarator syntax using an optional function-specifier
(_dcl.fct.spec_) followed by ~ followed by the destructor's class name
followed by an empty parameter list is used to declare the destructor
in a class definition. In such a declaration, the ~ followed by the
destructor's class name can be enclosed in optional parentheses; such
parentheses are ignored. A typedef-name that names a class is a
class-name (_dcl.typedef_); however, a typedef-name that names a class
shall not be used as the identifier in the declarator for a destructor
declaration.
2 A destructor is used to destroy objects of its class type. A destruc-
tor takes no parameters, and no return type can be specified for it
(not even void). The address of a destructor shall not be taken. A
destructor shall not be static. A destructor can be invoked for a
const, volatile or const volatile object. A destructor shall not be
declared const, volatile or const volatile (_class.this_). const and
volatile semantics (_dcl.type.cv_) are not applied on an object under
destruction. Such semantics stop being into effect once the destruc-
tor for the most derived object (_intro.object_) starts.
3 If a class has no user-declared destructor, a destructor is declared
implicitly. An implicitly-declared destructor is an inline public
member of its class. A destructor is trivial if it is an implicitly-
declared destructor and if:
--all of the direct base classes of its class have trivial destructors
and
--for all of the non-static data members of its class that are of
class type (or array thereof), each such class has a trivial
destructor.
4 Otherwise, the destructor is non-trivial.
5 An implicitly-declared destructor is implicitly defined when it is
used to destroy an object of its class type (_basic.stc_). A program
is ill-formed if the class for which a destructor is implicitly
defined has:
--a non-static data member of class type (or array thereof) with an
inaccessible destructor, or
--a base class with an inaccessible destructor.
Before the implicitly-declared destructor for a class is implicitly
defined, all the implicitly-declared destructors for its base classes
and its nonstatic data members shall have been implicitly defined.
[Note: an implicitly-declared destructor has an exception-specifica-
tion (_except.spec_). ]
6 A destructor for class X calls the destructors for X's direct members,
the destructors for X's direct base classes and, if X is the type of
the most derived class (_class.base.init_), its destructor calls the
destructors for X's virtual base classes. All destructors are called
as if they were referenced with a qualified name, that is, ignoring
any possible virtual overriding destructors in more derived classes.
Bases and members are destroyed in the reverse order of the completion
of their constructor (see _class.base.init_). A return statement
(_stmt.return_) in a destructor might not directly return to the
caller; before transferring control to the caller, the destructors for
the members and bases are called. Destructors for elements of an
array are called in reverse order of their construction (see
_class.init_).
7 A destructor can be declared virtual (_class.virtual_) or pure virtual
(_class.abstract_); if any objects of that class or any derived class
are created in the program, the destructor shall be defined. If a
class has a base class with a virtual destructor, its destructor
(whether user- or implicitly- declared) is virtual.
8 [Note: some language constructs have special semantics when used dur-
ing destruction; see _class.cdtor_. ]
9 A union member shall not be of a class type (or array thereof) that
has a non-trivial destructor.
10Destructors are invoked implicitly (1) for a constructed object with
static storage duration (_basic.stc.static_) at program termination
(_basic.start.term_), (2) for a constructed object with automatic
storage duration (_basic.stc.auto_) when the block in which the object
is created exits (_stmt.dcl_), (3) for a constructed temporary object
when the lifetime of the temporary object ends (_class.temporary_),
(4) for a constructed object allocated by a new-expression
(_expr.new_), through use of a delete-expression (_expr.delete_), (5)
in several situations due to the handling of exceptions (_except.han-
dle_). A program is ill-formed if an object of class type or array
thereof is declared and the destructor for the class is not accessible
at the point of the declaration. Destructors can also be invoked
explicitly.
11At the point of definition of a virtual destructor (including an
implicit definition (_class.copy_)), non-placement operator delete
shall be looked up in the scope of the destructor's class
(_basic.lookup.unqual_) and if found shall be accessible and unambigu-
ous. [Note: this assures that an operator delete corresponding to the
dynamic type of an object is available for the delete-expression
(_class.free_). ]
12In an explicit destructor call, the destructor name appears as a ~
followed by a type-name that names the destructor's class type. The
invocation of a destructor is subject to the usual rules for member
functions (_class.mfct_), that is, if the object is not of the
destructor's class type and not of a class derived from the destruc-
tor's class type, the program has undefined behavior (except that
invoking delete on a null pointer has no effect). [Example:
struct B {
virtual ~B() { }
};
struct D : B {
~D() { }
};
D D_object;
typedef B B_alias;
B* B_ptr = &D_object;
void f() {
D_object.B::~B(); // calls `B''s destructor
B_ptr->~B(); // calls `D''s destructor
B_ptr->~B_alias(); // calls `D''s destructor
B_ptr->B_alias::~B(); // calls `B''s destructor
B_ptr->B_alias::~B_alias(); // error, no `B_alias' in class `B'
}
--end example] [Note: an explicit destructor call must always be
written using a member access operator (_expr.ref_); in particular,
the unary-expression ~X() in a member function is not an explicit
destructor call (_expr.unary.op_). ]
13[Note: explicit calls of destructors are rarely needed. One use of
such calls is for objects placed at specific addresses using a new-
expression with the placement option. Such use of explicit placement
and destruction of objects can be necessary to cope with dedicated
hardware resources and for writing memory management facilities. For
example,
void* operator new(size_t, void* p) { return p; }
struct X {
// ...
X(int);
~X();
};
void f(X* p);
void g() // rare, specialized use:
{
char* buf = new char[sizeof(X)];
X* p = new(buf) X(222); // use `buf[]' and initialize
f(p);
p->X::~X(); // cleanup
}
--end note]
14Once a destructor is invoked for an object, the object no longer
exists; the behavior is undefined if the destructor is invoked for an
object whose lifetime has ended (_basic.life_). [Example: if the
destructor for an automatic object is explicitly invoked, and the
block is subsequently left in a manner that would ordinarily invoke
implicit destruction of the object, the behavior is undefined. ]
15[Note: the notation for explicit call of a destructor can be used for
any scalar type name (_expr.pseudo_). Allowing this makes it possible
to write code without having to know if a destructor exists for a
given type. For example,
typedef int I;
I* p;
// ...
p->I::~I();
--end note]
12.5 Free store [class.free]
1 When an object is created with a new-expression (_expr.new_), an allo-
cation function operator new() for non-array objects or
operator new[]() for arrays) is (implicitly) called to get the
required storage (_basic.stc.dynamic.allocation_).
2 When a new-expression is used to create an object of class T (or array
thereof), the allocation function is looked up in the scope of class
T; if no allocation function is found, the global allocation function
is used (_basic.stc.dynamic.allocation_).
3 When a new-expression is executed, the selected allocation function
shall be called with the amount of space requested (possibly zero) as
its first argument.
4 Any allocation function for a class T is a static member (even if not
explicitly declared static).
5 [Example:
class Arena;
struct B {
void* operator new(size_t, Arena*);
};
struct D1 : B {
};
Arena* ap;
void foo(int i)
{
new (ap) D1; // calls `B::operator new(size_t, Arena*)'
new D1[i]; // calls `::operator new[](size_t)'
new D1; // ill-formed: `::operator new(size_t)' hidden
}
--end example]
6 When an object is deleted with a delete-expression (_expr.delete_), a
deallocation function operator delete() for non-array objects or
operator delete[]() for arrays) is (implicitly) called to reclaim the
storage occupied by the object (_basic.stc.dynamic.deallocation_).
7 When a delete-expression is used to deallocate an array of objects of
class T, the deallocation function to be called is determined by look-
ing up the name of operator delete[] in the scope of class T. If the
result of this lookup is ambiguous or inaccessible, the program is
ill-formed. If no deallocation function is found in that scope, the
global deallocation function (_basic.stc.dynamic.deallocation_) is
used; see _expr.delete_.
8 When a delete-expression deallocates an object whose static type has a
virtual destructor, it invokes the non-placement operator delete, if
any, that is a member of the object's dynamic type. [Note: if it
exists, that non-placement operator delete was found by the lookup at
the definition of the dynamic type's virtual destructor
(_class.dtor_). ] If no such member operator delete exists, the
delete-expression calls the global deallocation function
(_basic.stc.dynamic.deallocation_). Otherwise, the static and dynamic
types of the object shall be identical and the deallocation function
to be called is determined by looking up the name of operator delete
in the scope of the class that is the static type of the object.2) If
the result of the lookup is ambiguous or inaccessible, the program is
ill-formed. If no deallocation function is found in that scope, the
global deallocation function (_basic.stc.dynamic.deallocation_) is
used; see _expr.delete_.
9 When a delete-expression is executed, the selected deallocation func-
tion shall be called with the address of the block of storage to be
reclaimed as its first argument and (if the two-parameter style is
used) the size of the block as its second argument.3)
10Any deallocation function for a class X is a static member (even if
not explicitly declared static). [Example:
class X {
// ...
void operator delete(void*);
void operator delete[](void*, size_t);
};
class Y {
// ...
void operator delete(void*, size_t);
void operator delete[](void*);
};
--end example]
11Since member allocation and deallocation functions are static they
cannot be virtual. [Note: however, when the cast-expression of a
delete-expression refers to an object of class type, because the deal-
location function actually called is looked up in the scope of the
class that is the dynamic type of the object, if the destructor is
virtual, the effect is the same. For example,
struct B {
virtual ~B();
void operator delete(void*, size_t);
};
struct D : B {
void operator delete(void*);
};
_________________________
2) A similar look up is not needed for the array version of the delete
operator because _expr.delete_ requires that in this situation, the
static type of the delete-expression's operand be the same as its dy-
namic type.
3) If the static type in the delete-expression is different from the
dynamic type and the destructor is not virtual the size might be in-
correct, but that case is already undefined; see _expr.delete_.
void f()
{
B* bp = new D;
delete bp; //1: uses `D::operator delete(void*)'
}
Here, storage for the non-array object of class D is deallocated by
D::operator delete(), due to the virtual destructor. ] [Note: virtual
destructors have no effect on the deallocation function actually
called when the cast-expression of a delete-expression refers to an
array of objects of class type. For example,
struct B {
virtual ~B();
void operator delete[](void*, size_t);
};
struct D : B {
void operator delete[](void*, size_t);
};
void f(int i)
{
D* dp = new D[i];
delete [] dp; // uses `D::operator delete[](void*, size_t)'
B* bp = new D[i];
delete[] bp; // undefined behavior
}
--end note]
12Access to the deallocation function is checked statically. Hence,
even though a different one might actually be executed, the statically
visible deallocation function is required to be accessible. [Example:
for the call on line //1 above, if B::operator delete() had been pri-
vate, the delete expression would have been ill-formed. ]
12.6 Initialization [class.init]
1 When no initializer is specified for an object of (possibly cv-quali-
fied) class type (or array thereof), or the initializer has the form
(), the object is initialized as specified in _dcl.init_. [Note: if
the class is a non-POD, it is default-initialized. ]
2 An object of class type (or array thereof) can be explicitly initial-
ized; see _class.expl.init_ and _class.base.init_.
3 When an array of class objects is initialized (either explicitly or
implicitly), the constructor shall be called for each element of the
array, following the subscript order; see _dcl.array_. [Note:
destructors for the array elements are called in reverse order of
their construction. ]
12.6.1 Explicit initialization [class.expl.init]
1 An object of class type can be initialized with a parenthesized
expression-list, where the expression-list is construed as an argument
list for a constructor that is called to initialize the object.
Alternatively, a single assignment-expression can be specified as an
initializer using the = form of initialization. Either direct-ini-
tialization semantics or copy-initialization semantics apply; see
_dcl.init_. [Example:
class complex {
// ...
public:
complex();
complex(double);
complex(double,double);
// ...
};
complex sqrt(complex,complex);
complex a(1); // initialize by a call of
// `complex(double)'
complex b = a; // initialize by a copy of `a'
complex c = complex(1,2); // construct `complex(1,2)'
// using `complex(double,double)'
// copy it into `c'
complex d = sqrt(b,c); // call `sqrt(complex,complex)'
// and copy the result into `d'
complex e; // initialize by a call of
// `complex()'
complex f = 3; // construct `complex(3) using'
// `complex(double)'
// copy it into `f'
complex g = { 1, 2 }; // error; constructor is required
--end example] [Note: overloading of the assignment operator
(_over.ass_) has no effect on initialization. ]
2 When an aggregate (whether class or array) contains members of class
type and is initialized by a brace-enclosed initializer-list
(_dcl.init.aggr_), each such member is copy-initialized (see
_dcl.init_) by the corresponding assignment-expression. If there are
fewer initializers in the initializer-list than members of the aggre-
gate, each member not explicitly initialized shall be default-initial-
ized (_dcl.init_). [Note: _dcl.init.aggr_ describes how assignment-
expressions in an initializer-list are paired with the aggregate mem-
bers they initialize. ] [Example:
complex v[6] = { 1,complex(1,2),complex(),2 };
Here, complex::complex(double) is called for the initialization of
v[0] and v[3], complex::complex(double,double) is called for the ini-
tialization of v[1], complex::complex() is called for the initializa-
tion v[2], v[4], and v[5]. For another example,
class X {
public:
int i;
float f;
complex c;
} x = { 99, 88.8, 77.7 };
Here, x.i is initialized with 99, x.f is initialized with 88.8, and
complex::complex(double) is called for the initialization of x.c. ]
[Note: braces can be elided in the initializer-list for any aggregate,
even if the aggregate has members of a class type with user-defined
type conversions; see _dcl.init.aggr_. ]
3 [Note: if T is a class type with no default constructor, any declara-
tion of an object of type T (or array thereof) is ill-formed if no
initializer is explicitly specified (see _class.init_ and _dcl.init_).
]
4 [Note: the order in which objects with static storage duration are
initialized is described in _basic.start.init_ and _stmt.dcl_. ]
12.6.2 Initializing bases and members [class.base.init]
1 In the definition of a constructor for a class, initializers for
direct and virtual base subobjects and nonstatic data members can be
specified by a ctor-initializer, which has the form
ctor-initializer:
: mem-initializer-list
mem-initializer-list:
mem-initializer
mem-initializer , mem-initializer-list
mem-initializer:
mem-initializer-id ( expression-listopt )
mem-initializer-id:
::opt nested-name-specifieropt class-name
identifier
2 Names in a mem-initializer-id are looked up in the scope of the con-
structor's class and, if not found in that scope, are looked up in the
scope containing the constructor's definition. [Note: if the con-
structor's class contains a member with the same name as a direct or
virtual base class of the class, a mem-initializer-id naming the mem-
ber or base class and composed of a single identifier refers to the
class member. A mem-initializer-id for the hidden base class may be
specified using a qualified name. ] Unless the mem-initializer-id
names a nonstatic data member of the constructor's class or a direct
or virtual base of that class, the mem-initializer is ill-formed. A
mem-initializer-list can initialize a base class using any name that
denotes that base class type. [Example:
struct A { A(); };
typedef A global_A;
struct B { };
struct C: public A, public B { C(); };
C::C(): global_A() { } // mem-initializer for base `A'
--end example] If a mem-initializer-id is ambiguous because it desig-
nates both a direct non-virtual base class and an inherited virtual
base class, the mem-initializer is ill-formed. [Example:
struct A { A(); };
struct B: public virtual A { };
struct C: public A, public B { C(); };
C::C(): A() { } // ill-formed: which `A'?
--end example] A ctor-initializer may initialize the member of an
anonymous union that is a member of the constructor's class. If a
ctor-initializer specifies more than one mem-initializer for the same
member, for the same base class or for multiple members of the same
union (including members of anonymous unions), the ctor-initializer is
ill-formed.
3 The expression-list in a mem-initializer is used to initialize the
base class or nonstatic data member subobject denoted by the mem-ini-
tializer-id. The semantics of a mem-initializer are as follows:
--if the expression-list of the mem-initializer is omitted, the base
class or member subobject is default-initialized (see _dcl.init_);
--otherwise, the subobject indicated by mem-initializer-id is direct-
initialized using expression-list as the initializer (see
_dcl.init_).
[Example:
struct B1 { B1(int); /* ... */ };
struct B2 { B2(int); /* ... */ };
struct D : B1, B2 {
D(int);
B1 b;
const int c;
};
D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4)
{ /* ... */ }
D d(10);
--end example] There is a sequence point (_intro.execution_) after
the initialization of each base and member. The expression-list of a
mem-initializer is evaluated as part of the initialization of the cor-
responding base or member.
4 If a given nonstatic data member or base class is not named by a mem-
initializer-id (including the case where there is no mem-initializer-
list because the constructor has no ctor-initializer), then
--If the entity is a nonstatic data member of (possibly cv-qualified)
class type (or array thereof) or a base class, and the entity class
is a non-POD class, the entity is default-initialized (_dcl.init_).
If the entity is a nonstatic data member of a const-qualified type,
the entity class shall have a user-declared default constructor.
--Otherwise, the entity is not initialized. If the entity is of
const-qualified type or reference type, or of a (possibly cv-quali-
fied) POD class type (or array thereof) containing (directly or
indirectly) a member of a const-qualified type, the program is ill-
formed.
After the call to a constructor for class X has completed, if a member
of X is neither specified in the constructor's mem-initializers, nor
default-initialized, nor initialized during execution of the body of
the constructor, the member has indeterminate value.
5 Initialization shall proceed in the following order:
--First, and only for the constructor of the most derived class as
described below, virtual base classes shall be initialized in the
order they appear on a depth-first left-to-right traversal of the
directed acyclic graph of base classes, where "left-to-right" is the
order of appearance of the base class names in the derived class
base-specifier-list.
--Then, direct base classes shall be initialized in declaration order
as they appear in the base-specifier-list (regardless of the order
of the mem-initializers).
--Then, nonstatic data members shall be initialized in the order they
were declared in the class definition (again regardless of the order
of the mem-initializers).
--Finally, the body of the constructor is executed.
[Note: the declaration order is mandated to ensure that base and mem-
ber subobjects are destroyed in the reverse order of initialization.
]
6 All sub-objects representing virtual base classes are initialized by
the constructor of the most derived class (_intro.object_). If the
constructor of the most derived class does not specify a mem-initial-
izer for a virtual base class V, then V's default constructor is
called to initialize the virtual base class subobject. If V does not
have an accessible default constructor, the initialization is ill-
formed. A mem-initializer naming a virtual base class shall be
ignored during execution of the constructor of any class that is not
the most derived class. [Example:
class V {
public:
V();
V(int);
// ...
};
class A : public virtual V {
public:
A();
A(int);
// ...
};
class B : public virtual V {
public:
B();
B(int);
// ...
};
class C : public A, public B, private virtual V {
public:
C();
C(int);
// ...
};
A::A(int i) : V(i) { /* ... */ }
B::B(int i) { /* ... */ }
C::C(int i) { /* ... */ }
V v(1); // use `V(int)'
A a(2); // use `V(int)'
B b(3); // use `V()'
C c(4); // use `V()'
--end example]
7 Names in the expression-list of a mem-initializer are evaluated in the
scope of the constructor for which the mem-initializer is specified.
[Example:
class X {
int a;
int b;
int i;
int j;
public:
const int& r;
X(int i): r(a), b(i), i(i), j(this->i) {}
};
initializes X::r to refer to X::a, initializes X::b with the value of
the constructor parameter i, initializes X::i with the value of the
constructor parameter i, and initializes X::j with the value of X::i;
this takes place each time an object of class X is created. ] [Note:
because the mem-initializer are evaluated in the scope of the con-
structor, the this pointer can be used in the expression-list of a
mem-initializer to refer to the object being initialized. ]
8 Member functions (including virtual member functions, _class.virtual_)
can be called for an object under construction. Similarly, an object
under construction can be the operand of the typeid operator
(_expr.typeid_) or of a dynamic_cast (_expr.dynamic.cast_). However,
if these operations are performed in a ctor-initializer (or in a func-
tion called directly or indirectly from a ctor-initializer) before all
the mem-initializers for base classes have completed, the result of
the operation is undefined. [Example:
class A {
public:
A(int);
};
class B : public A {
int j;
public:
int f();
B() : A(f()), // undefined: calls member function
// but base `A' not yet initialized
j(f()) { } // well-defined: bases are all initialized
};
class C {
public:
C(int);
};
class D : public B, C {
int i;
public:
D() : C(f()), // undefined: calls member function
// but base `C' not yet initialized
i(f()) {} // well-defined: bases are all initialized
};
--end example]
9 [Note: _class.cdtor_ describes the result of virtual function calls,
typeid and dynamic_casts during construction for the well-defined
cases; that is, describes the polymorphic behavior of an object under
construction. ]
12.7 Construction and destruction [class.cdtor]
1 For an object of non-POD class type (clause _class_), before the con-
structor begins execution and after the destructor finishes execution,
referring to any nonstatic member or base class of the object results
in undefined behavior. [Example:
struct X { int i; };
struct Y : X { };
struct A { int a; };
struct B : public A { int j; Y y; };
extern B bobj;
B* pb = &bobj; // ok
int* p1 = &bobj.a; // undefined, refers to base class member
int* p2 = &bobj.y.i; // undefined, refers to member's member
A* pa = &bobj; // undefined, upcast to a base class type
B bobj; // definition of `bobj'
extern X xobj;
int* p3 = &xobj.i; // Ok, `X' is a POD class
X xobj;
For another example,
struct W { int j; };
struct X : public virtual W { };
struct Y {
int *p;
X x;
Y() : p(&x.j) // undefined, `x' is not yet constructed
{ }
};
--end example]
2 To explicitly or implicitly convert a pointer (an lvalue) referring to
an object of class X to a pointer (reference) to a direct or indirect
base class B of X, the construction of X and the construction of all
of its direct or indirect bases that directly or indirectly derive
from B shall have started and the destruction of these classes shall
not have completed, otherwise the conversion results in undefined
behavior. To form a pointer to (or access the value of) a direct non-
static member of an object obj, the construction of obj shall have
started and its destruction shall not have completed, otherwise the
computation of the pointer value (or accessing the member value)
results in undefined behavior. [Example:
struct A { };
struct B : virtual A { };
struct C : B { };
struct D : virtual A { D(A*); };
struct X { X(A*); };
struct E : C, D, X {
E() : D(this), // undefined: upcast from `E*' to `A*'
// might use path `E*' -> `D*' -> `A*'
// but `D' is not constructed
// `D((C*)this)', // defined:
// `E*' -> `C*' defined because `E()' has started
// and `C*' -> `A*' defined because
// `C' fully constructed
X(this) // defined: upon construction of `X',
// `C'/`B'/`D'/`A' sublattice is fully constructed
{ }
};
--end example]
3 Member functions, including virtual functions (_class.virtual_), can
be called during construction or destruction (_class.base.init_).
When a virtual function is called directly or indirectly from a con-
structor (including from the mem-initializer for a data member) or
from a destructor, and the object to which the call applies is the
object under construction or destruction, the function called is the
one defined in the constructor or destructor's own class or in one of
its bases, but not a function overriding it in a class derived from
the constructor or destructor's class, or overriding it in one of the
other base classes of the most derived object (_intro.object_). If
the virtual function call uses an explicit class member access
(_expr.ref_) and the object-expression refers to the object under con-
struction or destruction but its type is neither the constructor or
destructor's own class or one of its bases, the result of the call is
undefined. [Example:
class V {
public:
virtual void f();
virtual void g();
};
class A : public virtual V {
public:
virtual void f();
};
class B : public virtual V {
public:
virtual void g();
B(V*, A*);
};
class D : public A, B {
public:
virtual void f();
virtual void g();
D() : B((A*)this, this) { }
};
B::B(V* v, A* a) {
f(); // calls `V::f', not `A::f'
g(); // calls `B::g', not `D::g'
v->g(); // `v' is base of `B', the call is well-defined, calls `B::g'
a->f(); // undefined behavior, `a''s type not a base of `B'
}
--end example]
4 The typeid operator (_expr.typeid_) can be used during construction or
destruction (_class.base.init_). When typeid is used in a constructor
(including from the mem-initializer for a data member) or in a
destructor, or used in a function called (directly or indirectly) from
a constructor or destructor, if the operand of typeid refers to the
object under construction or destruction, typeid yields the type_info
representing the constructor or destructor's class. If the operand of
typeid refers to the object under construction or destruction and the
static type of the operand is neither the constructor or destructor's
class nor one of its bases, the result of typeid is undefined.
5 Dynamic_casts (_expr.dynamic.cast_) can be used during construction or
destruction (_class.base.init_). When a dynamic_cast is used in a
constructor (including from the mem-initializer for a data member) or
in a destructor, or used in a function called (directly or indirectly)
from a constructor or destructor, if the operand of the dynamic_cast
refers to the object under construction or destruction, this object is
considered to be a most derived object that has the type of the con-
structor or destructor's class. If the operand of the dynamic_cast
refers to the object under construction or destruction and the static
type of the operand is not a pointer to or object of the constructor
or destructor's own class or one of its bases, the dynamic_cast
results in undefined behavior.
6 [Example:
class V {
public:
virtual void f();
};
class A : public virtual V { };
class B : public virtual V {
public:
B(V*, A*);
};
class D : public A, B {
public:
D() : B((A*)this, this) { }
};
B::B(V* v, A* a) {
typeid(*this); // type_info for `B'
typeid(*v); // well-defined: `*v' has type `V', a base of `B'
// yields `type_info' for `B'
typeid(*a); // undefined behavior: type `A' not a base of `B'
dynamic_cast<B*>(v); // well-defined: `v' of type `V*', `V' base of `B'
// results in `B*'
dynamic_cast<B*>(a); // undefined behavior,
// `a' has type `A*', `A' not a base of `B'
}
--end example]
12.8 Copying class objects [class.copy]
1 A class object can be copied in two ways, by initialization
(_class.ctor_, _dcl.init_), including for function argument passing
(_expr.call_) and for function value return (_stmt.return_), and by
assignment (_expr.ass_). Conceptually, these two operations are
implemented by a copy constructor (_class.ctor_) and copy assignment
operator (_over.ass_).
2 A non-template constructor for class X is a copy constructor if its
first parameter is of type X&, const X&, volatile X& or const volatile
X&, and either there are no other parameters or else all other parame-
ters have default arguments (_dcl.fct.default_).4) [Example:
X::X(const X&) and X::X(X&, int=1) are copy constructors.
class X {
// ...
public:
X(int);
X(const X&, int = 1);
};
X a(1); // calls `X(int)';
X b(a, 0); // calls `X(const X&, int)';
X c = b; // calls `X(const X&, int)';
--end example] [Note: all forms of copy constructor may be declared
for a class. [Example:
class X {
// ...
public:
X(const X&);
X(X&); // OK
};
--end example] --end note] [Note: if a class X only has a copy con-
structor with a parameter of type X&, an initializer of type const X
or volatile X cannot initialize an object of type (possibily cv-
_________________________
4) Because a template constructor is never a copy constructor, the
presence of such a template does not suppress the implicit declaration
of a copy constructor. Template constructors participate in overload
resolution with other constructors, including copy constructors, and a
template constructor may be used to copy an object if it provides a
better match than other constructors.
qualified) X. [Example:
struct X {
X(); // default constructor
X(X&); // copy constructor with a nonconst parameter
};
const X cx;
X x = cx; // error - `X::X(X&)' cannot copy `cx' into `x'
--end example] --end note]
3 A declaration of a constructor for a class X is ill-formed if its
first parameter is of type (optionally cv-qualified) X and either
there are no other parameters or else all other parameters have
default arguments.
4 If the class definition does not explicitly declare a copy construc-
tor, one is declared implicitly. Thus, for the class definition
struct X {
X(const X&, int);
};
a copy constructor is implicitly-declared. If the user-declared con-
structor is later defined as
X::X(const X& x, int i =0) { /* ... */ }
then any use of X's copy constructor is ill-formed because of the
ambiguity; no diagnostic is required.
5 The implicitly-declared copy constructor for a class X will have the
form
X::X(const X&)
if
--each direct or virtual base class B of X has a copy constructor
whose first parameter is of type const B& or const volatile B&, and
--for all the nonstatic data members of X that are of a class type M
(or array thereof), each such class type has a copy constructor
whose first parameter is of type const M& or const volatile M&.5)
Otherwise, the implicitly declared copy constructor will have the form
X::X(X&)
An implicitly-declared copy constructor is an inline public member of
its class.
6 A copy constructor for class X is trivial if it is implicitly declared
and if
--class X has no virtual functions (_class.virtual_) and no virtual
base classes (_class.mi_), and
--each direct base class of X has a trivial copy constructor, and
_________________________
5) This implies that the reference parameter of the implicitly-de-
clared copy constructor cannot bind to a volatile lvalue; see
_diff.special_.
--for all the nonstatic data members of X that are of class type (or
array thereof), each such class type has a trivial copy constructor;
otherwise the copy constructor is non-trivial.
7 An implicitly-declared copy constructor is implicitly defined if it is
used to initialize an object of its class type from a copy of an
object of its class type or of a class type derived from its class
type6). [Note: the copy constructor is implicitly defined even if the
implementation elided its use (_class.temporary_). ] A program is
ill-formed if the class for which a copy constructor is implicitly
defined has:
--a nonstatic data member of class type (or array thereof) with an
inaccessible or ambiguous copy constructor, or
--a base class with an inaccessible or ambiguous copy constructor.
Before the implicitly-declared copy constructor for a class is implic-
itly defined, all implicitly-declared copy constructors for its direct
and virtual base classes and its nonstatic data members shall have
been implicitly defined. [Note: an implicitly-declared copy construc-
tor has an exception-specification (_except.spec_). ]
8 The implicitly-defined copy constructor for class X performs a member-
wise copy of its subobjects. The order of copying is the same as the
order of initialization of bases and members in a user-defined con-
structor (see _class.base.init_). Each subobject is copied in the
manner appropriate to its type:
--if the subobject is of class type, the copy constructor for the
class is used;
--if the subobject is an array, each element is copied, in the manner
appropriate to the element type;
--if the subobject is of scalar type, the built-in assignment operator
is used.
Virtual base class subobjects shall be copied only once by the implic-
itly-defined copy constructor (see _class.base.init_).
9 A user-declared copy assignment operator X::operator= is a non-static
non-template member function of class X with exactly one parameter of
type X, X&, const X&, volatile X& or const volatile X&.7) [Note: an
_________________________
6) See _dcl.init_ for more details on direct and copy initialization.
7) Because a template assignment operator is never a copy assignment
operator, the presence of such a template does not suppress the im-
plicit declaration of a copy assignment operator. Template assignment
operators participate in overload resolution with other assignment op-
erators, including copy assignment operators, and a template assign-
ment operator may be used to assign an object if it provides a better
match than other assignment operators.
overloaded assignment operator must be declared to have only one
parameter; see _over.ass_. ] [Note: more than one form of copy
assignment operator may be declared for a class. ] [Note: if a class
X only has a copy assignment operator with a parameter of type X&, an
expression of type const X cannot be assigned to an object of type X.
[Example:
struct X {
X();
X& operator=(X&);
};
const X cx;
X x;
void f() {
x = cx; // error:
// `X::operator=(X&)' cannot assign `cx' into `x'
}
--end example] --end note]
10If the class definition does not explicitly declare a copy assignment
operator, one is declared implicitly. The implicitly-declared copy
assignment operator for a class X will have the form
X& X::operator=(const X&)
if
--each direct base class B of X has a copy assignment operator whose
parameter is of type const B&, const volatile B& or B, and
--for all the nonstatic data members of X that are of a class type M
(or array thereof), each such class type has a copy assignment oper-
ator whose parameter is of type const M&, const volatile M& or M.8)
Otherwise, the implicitly declared copy constructor will have the form
X& X::operator=(X&)
The implicitly-declared copy assignment operator for class X has the
return type X&; it returns the object for which the assignment opera-
tor is invoked, that is, the object assigned to. An implicitly-
declared copy assignment operator is an inline public member of its
class. Because a copy assignment operator is implicitly declared for
a class if not declared by the user, a base class copy assignment
operator is always hidden by the copy assignment operator of a derived
class (_over.ass_). A using-declaration (_namespace.udecl_) that
brings in from a base class an assignment operator with a parameter
type that could be that of a copy-assignment operator for the derived
class is not considered an explicit declaration of a copy-assignment
operator and does not suppress the implicit declaration of the derived
class copy-assignment operator; the operator introduced by the using-
declaration is hidden by the implicitly-declared copy-assignment oper-
ator in the derived class.
_________________________
8) This implies that the reference parameter of the implicitly-de-
clared copy assignment operator cannot bind to a volatile lvalue; see
_diff.special_.
11A copy assignment operator for class X is trivial if it is implicitly
declared and if
--class X has no virtual functions (_class.virtual_) and no virtual
base classes (_class.mi_), and
--each direct base class of X has a trivial copy assignment operator,
and
--for all the nonstatic data members of X that are of class type (or
array thereof), each such class type has a trivial copy assignment
operator;
otherwise the copy assignment operator is non-trivial.
12An implicitly-declared copy assignment operator is implicitly defined
when an object of its class type is assigned a value of its class type
or a value of a class type derived from its class type. A program is
ill-formed if the class for which a copy assignment operator is
implicitly defined has:
--a nonstatic data member of const type, or
--a nonstatic data member of reference type, or
--a nonstatic data member of class type (or array thereof) with an
inaccessible copy assignment operator, or
--a base class with an inaccessible copy assignment operator.
Before the implicitly-declared copy assignment operator for a class is
implicitly defined, all implicitly-declared copy assignment operators
for its direct base classes and its nonstatic data members shall have
been implicitly defined. [Note: an implicitly-declared copy assign-
ment operator has an exception-specification (_except.spec_). ]
13The implicitly-defined copy assignment operator for class X performs
memberwise assignment of its subobjects. The direct base classes of X
are assigned first, in the order of their declaration in the base-
specifier-list, and then the immediate nonstatic data members of X are
assigned, in the order in which they were declared in the class defi-
nition. Each subobject is assigned in the manner appropriate to its
type:
--if the subobject is of class type, the copy assignment operator for
the class is used (as if by explicit qualification; that is, ignor-
ing any possible virtual overriding functions in more derived
classes);
--if the subobject is an array, each element is assigned, in the man-
ner appropriate to the element type;
--if the subobject is of scalar type, the built-in assignment operator
is used.
It is unspecified whether subobjects representing virtual base classes
are assigned more than once by the implicitly-defined copy assignment
operator. [Example:
struct V { };
struct A : virtual V { };
struct B : virtual V { };
struct C : B, A { };
it is unspecified whether the virtual base class subobject V is
assigned twice by the implicitly-defined copy assignment operator for
C. --end example]
14A program is ill-formed if the copy constructor or the copy assignment
operator for an object is implicitly used and the special member func-
tion is not accessible (clause _class.access_). [Note: Copying one
object into another using the copy constructor or the copy assignment
operator does not change the layout or size of either object. ]
15Whenever a temporary class object is copied using a copy constructor,
and this object and the copy have the same cv-unqualified type, an
implementation is permitted to treat the original and the copy as two
different ways of referring to the same object and not perform a copy
at all, even if the class copy constructor or destructor have side
effects. For a function with a class return type, if the expression
in the return statement is the name of a local object, and the cv-
unqualified type of the local object is the same as the function
return type, an implementation is permitted to omit creating the tem-
porary object to hold the function return value, even if the class
copy constructor or destructor has side effects. In these cases, the
object is destroyed at the later of times when the original and the
copy would have been destroyed without the optimization.9) [Example:
class Thing {
public:
Thing();
~Thing();
Thing(const Thing&);
Thing operator=(const Thing&);
void fun();
};
Thing f() {
Thing t;
return t;
}
Thing t2 = f();
Here t does not need to be copied when returning from f. The return
value of f may be constructed directly into the object t2. ]
_________________________
9) Because only one object is destroyed instead of two, and one copy
constructor is not executed, there is still one object destroyed for
each one constructed.