______________________________________________________________________

  9   Classes                                          [class]

  ______________________________________________________________________

1 A class is a type.   Its  name  becomes  a  class-name  (_class.name_)
  within its scope.
          class-name:
                  identifier
                  template-id
  Class-specifiers  and elaborated-type-specifiers (_dcl.type.elab_) are
  used to make class-names.  An object of a class consists of a  (possi­
  bly empty) sequence of members and base class objects.
          class-specifier:
                  class-head { member-specificationopt }
          class-head:
                  class-key identifieropt base-clauseopt
                  class-key nested-name-specifier identifier base-clauseopt
          class-key:
                  class
                  struct
                  union

2 A  class-name is inserted into the scope in which it is declared imme­
  diately after the class-name is seen.  The class-name is also inserted
  into  the scope of the class itself.  For purposes of access checking,
  the inserted class name is treated as if it were a public member name.
  A  class-specifier  is  commonly referred to as a class definition.  A
  class is considered defined after the  closing  brace  of  its  class-
  specifier  has  been seen even though its member functions are in gen­
  eral not yet defined.

3 A class with an empty sequence of members and base class objects is an
  empty class.  Objects of an empty class have a nonzero size.

  +-------                 BEGIN BOX 1                -------+
  Bill  Gibbons suggest that a base class subobject should be allowed to
  occupy zero bytes of the complete object.  This would permit two  base
  class subobjects to have the same address, for example.
  +-------                  END BOX 1                 -------+

  [Note:  Class  objects  can  be assigned, passed as arguments to func­
  tions, and returned by functions (except objects of classes for  which
  copying has been restricted; see _class.copy_).  Other plausible oper­
  ators, such as equality comparison, can be defined by  the  user;  see
  _over.oper_.  ]

4 A  structure is a class defined with the class-key struct; its members
  and   base   classes   (_class.derived_)   are   public   by   default
  (_class.access_).   A  union  is  a  class  defined with the class-key
  union; its members are public by default and it holds only one  member
  at  a  time  (_class.union_).   [Note:  Aggregates  of  class type are
  described in _dcl.init.aggr_.  ] A POD-struct1) is an aggregate  class
  that  has  no  members of type pointer to member, non-POD-struct, non-
  POD-union (or array of such types) or  reference,  and  has  no  user-
  defined copy assignment operator and no user-defined destructor.  Sim­
  ilarly, a POD-union is an aggregate union that has no members of  type
  pointer  to  member,  non-POD-struct,  non-POD-union (or array of such
  types) or reference, and has no user-defined copy assignment  operator
  and no user-defined destructor.

  +-------                 BEGIN BOX 2                -------+
  Change:  To  complete  Monterey  motion 2d), user-declared destructors
  were added to the list of members that a POD struct/union cannot have.
  +-------                  END BOX 2                 -------+

  9.1  Class names                                          [class.name]

1 A class definition introduces a new type.  [Example:
          struct X { int a; };
          struct Y { int a; };
          X a1;
          Y a2;
          int a3;
  declares three variables of three different types.  This implies that
          a1 = a2;        // error: Y assigned to X
          a1 = a3;        // error: int assigned to X
  are type mismatches, and that
          int f(X);
          int f(Y);
  declare  an  overloaded  (_over_) function f() and not simply a single
  function f() twice.  For the same reason,
          struct S { int a; };
          struct S { int a; };  // error, double definition
  is ill-formed because it defines S twice.  ]

2 A class definition introduces the class name into the scope  where  it
  is defined and hides any class, object, function, or other declaration
  of that name in an enclosing scope (_basic.scope_).  If a  class  name
  is declared in a scope where an object, function, or enumerator of the
  same name is also declared, then when both declarations are in  scope,
  the  class  can be referred to only using an elaborated-type-specifier
  (_basic.lookup.elab_).  [Example:
          struct stat {
              // ...
          };

  _________________________
  1) The acronym POD stands for "plain ol' data."

          stat gstat;             // use plain `stat' to
                                  // define variable

          int stat(struct stat*); // redeclare `stat' as function
          void f()
          {
              struct stat* ps;    // `struct' prefix needed
                                  // to name struct stat
              // ...
              stat(ps);           // call stat()
              // ...
          }
     --end    example]    A    declaration    consisting    solely    of
  class-key identifier ;  is  either  a redeclaration of the name in the
  current scope or a forward declaration of the identifier  as  a  class
  name.  It introduces the class name into the current scope.  [Example:
          struct s { int a; };

          void g()
          {
              struct s;               // hide global struct `s'
                                      //  with a local declaration
              s* p;                   // refer to local struct `s'
              struct s { char* p; };  // define local struct `s'
              struct s;               // redeclaration, has no effect
          }
   --end example] [Note: Such declarations allow definition  of  classes
  that refer to each other.  [Example:
          class Vector;

          class Matrix {
              // ...
              friend Vector operator*(Matrix&, Vector&);
          };
          class Vector {
              // ...
              friend Vector operator*(Matrix&, Vector&);
          };
  Declaration  of friends is described in _class.friend_, operator func­
  tions in _over.oper_.  ] ]

3 An elaborated-type-specifier (_dcl.type.elab_) can also be used in the
  declarations of objects and functions.  It differs from a class decla­
  ration in that if a class of the elaborated name is in scope the elab­
  orated name will refer to it.  [Example:
          struct s { int a; };

          void g(int s)
          {
              struct s* p = new struct s;    // global `s'
              p->a = s;                      // local `s'
          }
   --end example]

4 [Note:  A  name declaration takes effect immediately after the identi­
  fier is seen.  For example,
          class A * A;
  first specifies A to be the name of a class and then redefines  it  as
  the name of a pointer to an object of that class.  This means that the
  elaborated form class A must be used to  refer  to  the  class.   Such
  artistry with names can be confusing and is best avoided.  ]

5 A typedef-name (_dcl.typedef_) that names a class is a class-name, but
  shall  not  be  used  in  an   elaborated-type-specifier;   see   also
  _dcl.typedef_.

  9.2  Class members                                         [class.mem]
          member-specification:
                  member-declaration member-specificationopt
                  access-specifier : member-specificationopt
          member-declaration:
                  decl-specifier-seqopt member-declarator-listopt ;
                  function-definition ;opt
                  qualified-id ;
                  using-declaration
          member-declarator-list:
                  member-declarator
                  member-declarator-list , member-declarator
          member-declarator:
                  declarator pure-specifieropt
                  declarator constant-initializeropt
                  identifieropt : constant-expression
          pure-specifier:
                   = 0
          constant-initializer:
                   = constant-expression

1 The  member-specification  in a class definition declares the full set
  of members of the class; no member can be added elsewhere.  Members of
  a  class  are  data  members,  member functions (_class.mfct_), nested
  types, and enumerators.  Data members and member functions are  static
  or   nonstatic;   see   _class.static_.    Nested  types  are  classes
  (_class.name_, _class.nest_) and enumerations (_dcl.enum_) defined  in
  the class, and arbitrary types declared as members by use of a typedef
  declaration  (_dcl.typedef_).   The  enumerators  of  an   enumeration
  (_dcl.enum_)  defined  in  the  class are member of the class.  Except
  when used to declare friends (_class.friend_) or to adjust the  access
  to  a member of a base class (_class.access.dcl_), member-declarations
  declare members of the class, and each such  member-declaration  shall
  declare  at least one member name of the class.  A member shall not be
  declared twice in the member-specification, except that a nested class
  can be declared and then later defined.

2 [Note:  a  single  name  can  denote several function members provided
  their types are sufficiently different (_over_).  ]

3 A member-declarator can contain  a  constant-initializer  only  if  it
  declares  a  static member (_class.static_) of integral or enumeration

  type, see _class.static.data_.

4 A member can be initialized using  a  constructor;  see  _class.ctor_.
  [Note:  see  clause  _special_  for  a description of constructors and
  other special member functions.  ]

5 A member shall not be auto, extern, or register.

6 The decl-specifier-seq can be omitted in constructor, destructor,  and
  conversion function declarations only.  The member-declarator-list can
  be omitted only after a class-specifier, an enum-specifier, or a decl-
  specifier-seq  of  the form friend elaborated-type-specifier.  A pure-
  specifier shall be used only in the declaration of a virtual  function
  (_class.virtual_).

7 Non-static  (_class.static_)  members  that are class objects shall be
  objects of previously defined classes.   In  particular,  a  class  cl
  shall  not contain an object of class cl, but it can contain a pointer
  or reference to an object of class cl.  When an array is used  as  the
  type of a nonstatic member all dimensions shall be specified.

8 Except  when  used to form a pointer to member (_expr.unary.op_), when
  used in the body of a nonstatic member function of its class or  of  a
  class derived from its class (_class.mfct.nonstatic_), or when used in
  a mem-initializer for a constructor for  its  class  or  for  a  class
  derived  from its class (_class.base.init_), a nonstatic data or func­
  tion member of a class shall only be referred to with the class member
  access syntax (_expr.ref_).

9 [Example: A simple example of a class definition is
          struct tnode {
              char tword[20];
              int count;
              tnode *left;
              tnode *right;
          };
  which  contains  an  array  of  twenty characters, an integer, and two
  pointers to similar structures.  Once this definition has been  given,
  the declaration
          tnode s, *sp;
  declares  s  to  be  a  tnode and sp to be a pointer to a tnode.  With
  these declarations, sp->count refers to the count member of the struc­
  ture  to which sp points; s.left refers to the left subtree pointer of
  the structure s; and s.right->tword[0] refers to the initial character
  of the tword member of the right subtree of s.  ]

10The  type  of  a nonstatic data member is data member type, not object
  type; the type of a nonstatic member function is member function type,
  not  function  type;  see _expr.unary.op_ and _class.mfct_.  [Example:
  the type of the qualified-id expression tnode::count  is  data  member
  type and the type of &tnode::count is pointer to data member (that is,
  int (tnode::*); see _expr.unary.op_).  ] [Note:  the  type  of  static
  members is described in _class.static_.  ]

11Nonstatic  data  members  of  a  (non-union) class declared without an
  intervening access-specifier are allocated so that later members  have
  higher  addresses  within  a class object.  The order of allocation of
  nonstatic data members separated by an access-specifier is implementa­
  tion-defined (_class.access.spec_).  Implementation alignment require­
  ments might cause two adjacent members not to be allocated immediately
  after each other; so might requirements for space for managing virtual
  functions (_class.virtual_) and virtual base classes (_class.mi_).

12A static data member, enumerator, member of  an  anonymous  union,  or
  nested type shall not have the same name as its class.

13Two  POD-struct (_class_) types are layout-compatible if they have the
  same number of members, and corresponding members (in order) have lay­
  out-compatible types (_basic.types_).

14Two  POD-union  (_class_) types are layout-compatible if they have the
  same number of members, and corresponding members (in any order)  have
  layout-compatible types (_basic.types_).

  +-------                 BEGIN BOX 3                -------+
  Shouldn't this be the same set of types?
  +-------                  END BOX 3                 -------+

15If  a  POD-union  contains two or more POD-structs that share a common
  initial sequence, and if the POD-union object currently  contains  one
  of  these  POD-structs,  it is permitted to inspect the common initial
  part of any of them.  Two POD-structs share a common initial  sequence
  if  corresponding  members have layout-compatible types (and, for bit-
  fields, the same widths) for a sequence of one or  more  initial  mem­
  bers.

16A  pointer  to  a POD-struct object, suitably converted, points to its
  initial member (or if that member is a bit-field, then to the unit  in
  which  it  resides)  and  vice versa.  [Note: There might therefore be
  unnamed padding within a POD-struct object, but not at its  beginning,
  as necessary to achieve appropriate alignment.  ]

  +-------                 BEGIN BOX 4                -------+
  What  was  subclause  9.3  (Scope rules for classes) in the April 28th
  1995 version of the working paper was merged with _basic.scope.class_.
  +-------                  END BOX 4                 -------+

  9.3  Member functions                                     [class.mfct]

1 Functions  declared  in  the  definition  of  a class, excluding those
  declared with a friend specifier (_class.friend_), are  called  member
  functions  of that class.  A member function may be declared static in
  which  case  it  is  a   static   member   function   of   its   class
  (_class.static_);  otherwise  it is a nonstatic member function of its
  class (_class.mfct.nonstatic_, _class.this_).

2 A member function may be defined (_dcl.fct.def_) in its class  defini­
  tion,  in  which  case  it  is an inline member function, or it may be
  defined outside of  its  class  definition  if  it  has  already  been
  declared  but  not defined in its class definition.  A member function
  definition that appears outside of the class definition  shall  appear
  in  a namespace scope enclosing the class definition.  Except for mem­
  ber function definitions that appear outside of  a  class  definition,
  and  except  for explicit specializations of template member functions
  (_temp.spec_) appearing outside of  the  class  definition,  a  member
  function shall not be redeclared.

3 An  inline  member  function (whether static or nonstatic) may also be
  defined outside of its class definition provided either  its  declara­
  tion  in  the  class definition or its definition outside of the class
  definition declares the function as inline  (_dcl.fct.spec_).   [Note:
  member  functions of a class in namespace scope have external linkage.
  Member functions of a local class  (_class.local_)  have  no  linkage.
  See _basic.link_.  ]

4 There  shall be at most one definition of a non-inline member function
  in a program; no diagnostic is required.  There may be more  than  one
  inline  member  function definition in a program.  See _basic.def.odr_
  and _dcl.fct.spec_.

5 If the definition of a member function is lexically outside its  class
  definition,  the  member function name shall be qualified by its class
  name using the :: operator.  A member function  definition  (that  is,
  the   parameter-declaration-clause  including  the  default  arguments
  (_dcl.fct.default_), the member function body and, for  a  constructor
  function  (_class.ctor_), the ctor-initializer (_class.base.init_)) is
  in the scope of the  member  function's  class  (_basic.scope.class_).
  [Example:
          struct X {
                  typedef int T;
                  static T count;
                  void f(T);
          };
          void X::f(T t = count) { }
  The member function f of class X is defined in global scope; the nota­
  tion X::f specifies that the function f is a member of class X and  in
  the  scope of class X.  In the function definition, the parameter type
  T refers to the typedef member T declared in class X and  the  default
  argument  count  refers  to  the  static data member count declared in
  class X.  ]

6 A static local variable in a member function always refers to the same
  object, whether or not the member function is inline.

7 Member  functions  may be mentioned in friend declarations after their
  class has been defined.

8 Member functions of a local class shall be  defined  inline  in  their
  class definition, if they are defined at all.

  9.3.1  Nonstatic member functions               [class.mfct.nonstatic]

1 A  nonstatic  member function may be called for an object of its class
  type, or for an object of a class derived (_class.derived_)  from  its
  class   type,  using  the  class  member  access  syntax  (_expr.ref_,
  _over.match.call_).  A nonstatic member function may  also  be  called
  directly    using    the    function    call    syntax   (_expr.call_,
  _over.match.call_)

  --from within the body of a member function of its class or of a class
    derived from its class, or

  --from a mem-initializer (_class.base.init_) for a constructor for its
    class or for a class derived from its class.

  If a nonstatic member function of a class X is called  for  an  object
  that  is  not  of type X, or of a type derived from X, the behavior is
  undefined.

2 When an id-expression (_expr.prim_) that is not part of a class member
  access  syntax  (_expr.ref_)  and not used to form a pointer to member
  (_expr.unary.op_) is used in the body of a nonstatic  member  function
  of  class  X or used in the mem-initializer for a constructor of class
  X, if name lookup (_basic.lookup.unqual_) resolves the name in the id-
  expression to a nonstatic nontype member of class X or of a base class
  of X, the id-expression is transformed  into  a  class  member  access
  expression  (_expr.ref_)  using (*this) (_class.this_) as the postfix-
  expression to the left of the  .   operator.   The  member  name  then
  refers  to  the member of the object for which the function is called.
  Similarly during name lookup,  when  an  unqualified-id  (_expr.prim_)
  used  in the definition of a member function for class X resolves to a
  static member, an enumerator or a nested type of class X or of a  base
  class  of  X,  the  unqualified-id  is transformed into a qualified-id
  (_expr.prim_) in which the nested-name-specifier names  the  class  of
  the member function.  [Example:
          struct tnode {
                  char tword[20];
                  int count;
                  tnode *left;
                  tnode *right;
                  void set(char*, tnode* l, tnode* r);
          };
          void tnode::set(char* w, tnode* l, tnode* r)
          {
                  count = strlen(w)+1;
                  if (sizeof(tword)<=count)
                          error("tnode string too long");
                  strcpy(tword,w);
                  left = l;
                  right = r;
          }

          void f(tnode n1, tnode n2)
          {
                  n1.set("abc",&n2,0);
                  n2.set("def",0,0);
          }
  In the body of the member function tnode::set, the member names tword,
  count, left, and right refer to members of the object  for  which  the
  function  is  called.   Thus,  in  the call n1.set("abc",&n2,0), tword
  refers to n1.tword, and in the call n2.set("def",0,0),  it  refers  to
  n2.tword.   The functions strlen, error, and strcpy are not members of
  the class tnode and should be declared elsewhere.2)

3 The type of a nonstatic member function involves its class name;  thus
  the  type of the qualified-id expression tnode::set is member function
  type and the type of &tnode::set is pointer to member  function  (that
  is, void (tnode::*)(char*,tnote*,tnode*), see _expr.unary.op_).  ]

4 A  nonstatic member function may be declared const, volatile, or const
  volatile.  These cv-qualifiers affect the type  of  the  this  pointer
  (_class.this_).   They  also affect the type of the member function; a
  member function declared const is a const member  function,  a  member
  function  declared volatile is a volatile member function and a member
  function declared const volatile is a const volatile member  function.
  [Example:
          struct X {
                  void g() const;
                  void h() const volatile;
          };
  X::g  is  a  const member function and X::h is a const volatile member
  function.  ]

5 A nonstatic member function may be declared virtual  (_class.virtual_)
  or pure virtual (_class.abstract_).

  9.3.2  The this pointer                                   [class.this]

1 In the body of a nonstatic (_class.mfct_) member function, the keyword
  this is a non-lvalue expression whose value  is  the  address  of  the
  object for which the function is called.  The type of this in a member
  function of a class X is X*.   If  the  member  function  is  declared
  const,  the  type  of  this  is  const  X*,  if the member function is
  declared volatile, the type of this is volatile X*, and if the  member
  function  is  declared  const  volatile,  the  type  of  this is const
  volatile X*.

2 In a const member function, the  object  for  which  the  function  is
  called  is  accessed  through  a const access path; therefore, a const
  member function shall not modify the object and  its  non-static  data
  members.  [Example:

  _________________________
  2) See, for example, <cstring> (_lib.c.strings_).

          struct s {
              int a;
              int f() const;
              int g() { return a++; }
              int h() const { return a++; } // error
          };

          int s::f() const { return a; }
  The  a++  in the body of s::h is ill-formed because it tries to modify
  (a part of) the object for  which  s::h()  is  called.   This  is  not
  allowed in a const member function because this is a pointer to const;
  that is, *this is a const.  ]

3 Similarly, volatile semantics (_dcl.type.cv_) apply in volatile member
  functions when accessing the object and its non-static data members.

4 A  cv-qualified  member function can be called on an object-expression
  (_expr.ref_) only if the object-expression is as cv-qualified or less-
  cv-qualified than the member function.  [Example:
          void k(s& x, const s& y)
          {
              x.f();
              x.g();
              y.f();
              y.g();      // error
          }
  The  call  y.g() is ill-formed because y is const and s::g() is a non-
  const member function, that is,  s::g()  is  less-qualified  than  the
  object-expression y.  ]

5 Constructors  (_class.ctor_)  and destructors (_class.dtor_) shall not
  be declared const, volatile or const volatile.  [Note: However,  these
  functions  can  be  invoked  to  create  and  destroy objects with cv-
  qualified types, see (_class.ctor_) and (_class.dtor_).  ]

  9.4  Static members                                     [class.static]

1 A data or function member of a class may be declared static in a class
  definition, in which case it is a static member of the class.

2 A static member s of class X may be referred to using the qualified-id
  expression X::s; it is not necessary to use the  class  member  access
  syntax  (_expr.ref_) to refer to a static member.  A static member may
  be referred to using the class member access syntax, in which case the
  object-expression is always evaluated.  [Example:
          class process {
          public:
                  static void reschedule();
          };
          process& g();

          void f()
          {
                  process::reschedule(); // ok: no object necessary
                  g().reschedule();      // g() is called
          }
    --end  example]  A  static member may be referred to directly in the
  scope  of  its  class  or  in   the   scope   of   a   class   derived
  (_class.derived_)  from  its class; in this case, the static member is
  referred to as if a qualified-id expression was used, with the nested-
  name-specifier  of  the qualified-id naming the class scope from which
  the static member is referred.  [Example:
          int g();
          struct X {
                  static int g();
          };
          struct Y : X {
                  static int i;
          }
          int Y::i = g(); // equivalent to Y::g();
   --end example]

3 The definition of a static member function or the initializer  expres­
  sion for a static data member may directly use the names of the static
  members, enumerators, and nested types of its class or of a base class
  of  its  class;  during  name  lookup (_basic.lookup.unqual_), when an
  unqualified-id (_expr.prim_) used in one of these contexts resolves to
  the declaration for one of these members, the unqualified-id is trans­
  formed into  a  qualified-id  expression  in  which  the  nested-name-
  specifier names the class scope from which the the member is referred.
  The definition of a static member shall not use directly the names  of
  the  nonstatic  members  of  its class or of a base class of its class
  (including as operands of the sizeof operator).  The definition  of  a
  static  member may only refer to these members to form pointer to mem­
  bers  (_expr.unary.op_)  or  with  the  class  member  access   syntax
  (_expr.ref_).

4 Static   members   obey   the   usual   class   member   access  rules
  (_class.access_).

5 The type of a static member does not involve its class  name.   [Exam­
  ple:  Thus, in the example above, the type of the qualified-id expres­
  sion X::g is a function type and the type of &X::g is pointer to func­
  tion type (that is, void(*)(), see _expr.unary.op_).  ]

  9.4.1  Static member functions                     [class.static.mfct]

1 [Note:  the  rules  described  in  _class.mfct_ apply to static member
  functions.  ]

2 [Note:  a  static  member  function  does  not  have  a  this  pointer
  (_class.this_).   ]  A  static  member  function shall not be virtual.
  There shall not be a static and a nonstatic member function  with  the
  same name and the same parameter types (_over.load_).  A static member
  function shall not be declared const, volatile, or const volatile.

  9.4.2  Static data members                         [class.static.data]

1 A static data member is not part of the subobjects of a class.   There
  is  only one copy of a static data member shared by all the objects of
  the class.

2 The declaration of a static data member in its class definition is not
  a  definition and may be of an incomplete type other than cv-qualified
  void.  A definition shall be provided for the static data member in  a
  namespace scope enclosing the member's class definition.  In the defi­
  nition at namespace scope, the name of the static data member shall be
  qualified  by  its  class name using the :: operator.  The initializer
  expression in the definition of a static data member is in  the  scope
  of its class (_basic.scope.class_).  [Example:
          class process {
                  static process* run_chain;
                  static process* running;
          };
          process* process::running = get_main();
          process* process::run_chain = running;
  The static data member run_chain of class process is defined in global
  scope; the  notation  process::run_chain  specifies  that  the  member
  run_chain  is a member of class process and in the scope of class pro­
  cess.  In the static data member definition, the  initializer  expres­
  sion refers to the static data member running of class process.  ]

3 [Note: once the static data member has been defined, it exists even if
  no objects of its class have been created.  [Example: in  the  example
  above, run_chain and running exist even if no objects of class process
  are created by the program.  ] ]

4 If a static data member is of  const  integral  or  const  enumeration
  type,  its declaration in the class definition can specify a constant-
  initializer  which  shall   be   an   integral   constant   expression
  (_expr.const_).   In that case, the member can appear in integral con­
  stant expressions within its scope.  The member shall still be defined
  in  a  namespace  scope  and the definition of the member in namespace
  scope shall not contain an initializer.

5 There shall be exactly one definition of a static  data  member  in  a
  program; no diagnostic is required; see _basic.def.odr_.

6 Static  data members of a class in namespace scope have external link­
  age (_basic.link_).  A local class shall not have static data members.

7 Static  data  members  are initialized and destroyed exactly like non-
  local objects (_basic.start.init_, _basic.start.term_).

8 A static data member shall not be mutable (_dcl.stc_).

  9.5  Unions                                              [class.union]

1 In a union, at most one of the data members can be active at any time,
  that is, the value of at most one of the data members can be stored in
  a union at any time.  The size of a union is sufficient to contain the
  largest  of  its data members.  Each data member is allocated as if it
  were the sole member of a struct.  A union can have  member  functions
  (including    constructors   and   destructors),   but   not   virtual
  (_class.virtual_) functions.  A union shall not have base classes.   A
  union  shall not be used as a base class.  An object of a class with a
  non-trivial default constructor  (_class.ctor_),  a  non-trivial  copy
  constructor  (_class.copy_),  a non-trivial destructor (_class.dtor_),
  or a non-trivial copy assignment operator  (_over.ass_,  _class.copy_)
  cannot be a member of a union, nor can an array of such objects.  If a
  union contains a static data member, or a member  of  reference  type,
  the program is ill-formed.

2 A union of the form
          union { member-specification } ;
  is  called an anonymous union; it defines an unnamed object (and not a
  type).  The names of the members of an anonymous union shall  be  dis­
  tinct  from  other  names in the scope in which the union is declared;
  they are used directly in that scope without the usual  member  access
  syntax (_expr.ref_).  [Example:
          void f()
          {
              union { int a; char* p; };
              a = 1;
              // ...
              p = "Jennifer";
              // ...
          }
  Here  a  and p are used like ordinary (nonmember) variables, but since
  they are union members they have the same address.  ]

3 Anonymous unions declared at namespace scope shall be declared static.
  All other anonymous unions shall not be declared static.  An anonymous
  union shall not have private or  protected  members  (_class.access_).
  An anonymous union shall not have function members.

4 A union for which objects or pointers are declared is not an anonymous
  union.  [Example:
          union { int aa; char* p; } obj, *ptr = &obj;
          aa = 1;       // error
          ptr->aa = 1;  // ok
  The assignment to plain aa is ill formed since the member name is  not
  visible  outside  the  union,  and  even if it were visible, it is not
  associated with any particular object.   ]  [Note:  Initialization  of
  unions   with   no   user-declared   constructors   is   described  in
  (_dcl.init.aggr_).  ]

  9.6  Bit-fields                                            [class.bit]

1 A member-declarator of the form
          identifieropt : constant-expression
  specifies a bit-field; its length is set off from the  bit-field  name
  by  a colon.  Allocation of bit-fields within a class object is imple­
  mentation-defined.  Alignment of bit-fields is implementation-defined.
  Bit-fields  are  packed into some addressable allocation unit.  [Note:
  bit-fields straddle allocation units on some machines and not on  oth­
  ers.  Bit-fields are assigned right-to-left on some machines, left-to-
  right on others.  ]

2 A declaration for a bit-field that omits the  identifier  declares  an
  unnamed  bit-field.   Unnamed bit-fields are not members and cannot be
  initialized.  [Note: an unnamed bit-field is  useful  for  padding  to
  conform  to  externally-imposed  layouts.   ]  As  a  special case, an
  unnamed bit-field with a width of zero specifies alignment of the next
  bit-field at an allocation unit boundary.

3 A  bit-field  shall  not  be  a static member.  A bit-field shall have
  integral or enumeration type (_basic.fundamental_).  It is implementa­
  tion-defined  whether a plain (neither explicitly signed nor unsigned)
  char, wchar_t, short, int or long bit-field is signed or unsigned.

  +-------                 BEGIN BOX 5                -------+
  Change: The types char, wchar_t, short and long were added to the list
  above.
  +-------                  END BOX 5                 -------+

  A  bool value can successfully be stored in a bit-field of any nonzero
  size.  The address-of operator & shall not be applied to a  bit-field,
  so  there  are no pointers to bit-fields.  Nor are there references to
  bit-fields.

  9.7  Nested class declarations                            [class.nest]

1 A class can be defined within another class.  A class  defined  within
  another is called a nested class.  The name of a nested class is local
  to its enclosing class.  The nested class  is  in  the  scope  of  its
  enclosing  class.   Except by using explicit pointers, references, and
  object names, declarations in a nested class can use only type  names,
  static members, and enumerators from the enclosing class.  [Example:
          int x;
          int y;

          class enclose {
          public:
              int x;
              static int s;
              class inner {

                  void f(int i)
                  {
                      int a = sizeof(x); // error: refers to enclose::x
                      x = i;   // error: assign to enclose::x
                      s = i;   // ok: assign to enclose::s
                      ::x = i; // ok: assign to global x
                      y = i;       // ok: assign to global y
                  }
                  void g(enclose* p, int i)
                  {
                      p->x = i;   // ok: assign to enclose::x
                  }
              };
          };

          inner* p = 0;   // error `inner' not in scope
   --end example]

2 The  scope  of  a  nested class has no special access to members of an
  enclosing class; the usual  access  rules  (_class.access_)  shall  be
  obeyed.  The scope of an enclosing class has no special access to mem­
  bers of a nested class; the usual access rules (_class.access_)  shall
  be obeyed.  [Example:
          class E {
              int x;
              class I {
                  int y;
                  void f(E* p, int i)
                  {
                      p->x = i;   // error: E::x is private
                  }
              };
              int g(I* p)
              {
                  return p->y;    // error: I::y is private
              }
          };
   --end example]

3 Member  functions  and  static  data  members of a nested class can be
  defined in a namespace scope enclosing the definition of their  class.
  [Example:
          class enclose {
          public:
              class inner {
                  static int x;
                  void f(int i);
              };
          };
          int enclose::inner::x = 1;

          void enclose::inner::f(int i) { /* ... */ }
   --end example]

4 If  class  X  is defined in a namespace scope, a nested class Y may be
  declared in class X and later defined in the definition of class X  or
  be  later  defined  in  a  namespace scope enclosing the definition of
  class X.  [Example:
          class E {
              class I1;      // forward declaration of nested class
              class I2;
              class I1 {};  // definition of nested class
          };
          class E::I2 {};   // definition of nested class
   --end example]

5 Like a member function, a  friend  function  (_class.friend_)  defined
  within  a nested class is in the lexical scope of that class; it obeys
  the same rules for name binding as a static member  function  of  that
  class  (_class.static_) and has no special access rights to members of
  an enclosing class.

  9.8  Local class declarations                            [class.local]

1 A class can be defined within a function definition; such a  class  is
  called  a  local  class.   The  name  of a local class is local to its
  enclosing scope.  The local class is in the  scope  of  the  enclosing
  scope.   Declarations in a local class can use only type names, static
  variables, extern variables and functions, and  enumerators  from  the
  enclosing scope.  [Example:
          int x;
          void f()
          {
              static int s ;
              int x;
              extern int g();
              struct local {
                  int g() { return x; }    // error: `x' is auto
                  int h() { return s; }    // ok
                  int k() { return ::x; }  // ok
                  int l() { return g(); }  // ok
              };
              // ...
          }

          local* p = 0;   // error: `local' not in scope
   --end example]

2 An  enclosing  function  has no special access to members of the local
  class; it obeys the usual access rules (_class.access_).  Member func­
  tions of a local class shall be defined within their class definition,
  if they are defined at all.

3 If class X is a local class a nested class Y may be declared in  class
  X  and  later defined in the definition of class X or be later defined
  in the same scope as the definition of class X.  A local  class  shall
  not have static data members.

  9.9  Nested type names                             [class.nested.type]

1 Type  names obey exactly the same scope rules as other names.  In par­
  ticular, type names defined within a class definition cannot  be  used
  outside their class without qualification.  [Example:
          class X {
          public:
              typedef int I;
              class Y { /* ... */ };
              I a;
          };

          I b;     // error
          Y c;     // error
          X::Y d;  // ok
          X::I e;  // ok
   --end example]