      ______________________________________________________________________

      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 (_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 (_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_.  ]

      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_).  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 (_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 destruc-
      tor  (_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 const 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 (_conv_), for

      initialization  (_dcl.init_),  and  for  explicit   type   conversions
      (_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  (_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.

      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 oper-
      ator  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)

    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]
      _________________________
      1) Even though never directly called to  perform  a  conversion,  such
      conversion  operators  can  be declared and can potentially be reached
      through a call to a virtual conversion operator in a base class

    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 operators are inherited.

    6 Conversion functions can be virtual.

    7 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]

    8 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 void*();
              };

              void f(Y& a)
              {
                  if (a) {    // ill-formed:
                              // X::operator int()
                              // or Y::operator void*()
                      // ...
                  }
              }
       --end example]

      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.   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 transfer-
      ring 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 the destructor for an object is
      implicitly used and it is not accessible  (_class.access_).   Destruc-
      tors 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 class derived from the destructor'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;
              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]

    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);
              };
      _________________________
      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_.

              struct D : B {
                  void operator delete(void*);
              };
              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 copy-initialized
      (_dcl.init_)  with  an initializer of the form T() (_expr.type.conv_),
      where T represents the  type  of  the  uninitialized  member.   [Note:
      _dcl.init.aggr_  describes  how  assignment-expressions in an initial-
      izer-list are paired with the aggregate members  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.   Unless  the  mem-ini-
      tializer-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 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 in the mem-initializer-list, 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 (_class_), before the  constructor
      begins  execution  and after the destructor finishes execution, refer-
      ring 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 con-
      structor  (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:

      _________________________
      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.

              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-quali-
      fied) 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
      _________________________
      5) This implies that the reference  parameter  of  the  implicitly-de-
      clared  copy  constructor  cannot  bind  to  a  volatile  lvalue;  see
      _diff.special_.

      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

      --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_).
      _________________________
      6)  See _dcl.init_ for more details on direct and copy initialization.

    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
      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
      _________________________
      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.
      8)  This  implies  that  the reference parameter of the implicitly-de-
      clared copy assignment operator cannot bind to a volatile lvalue;  see
      _diff.special_.

      operator is always hidden by the copy assignment operator of a derived
      class (_over.ass_).

    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;

      --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 (_class.access_).  [Note:  Copying  one  object
      into  another using the copy constructor or the copy assignment opera-
      tor does not change the layout or size of either object.  ]

    15Whenever a class object is copied and the original object and the copy
      have  the  same  type, if the implementation can prove that either the
      original object or the copy will never again be  used  except  as  the
      result  of  an implicit destructor call (_class.dtor_), an implementa-
      tion 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.
      In that case, 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();
              };
              void f(Thing t) { }
              void g(Thing t) { t.fun(); }

              int main()
              {
                      Thing t1, t2, t3;
                      f(t1);
                      g(t2);
                      g(t3);
                      t3.fun();
              }
      Here t1 does not need to be copied when calling f because f  does  not
      use  its  formal parameter again after copying it. Although g uses its
      _________________________
      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.

      parameter, the call to g(t2) does not need to copy t2  because  t2  is
      not used again after it is passed to g.  On the other hand, t3 is used
      after passing it to g so calling g(t3) is required to copy t3.  ]