______________________________________________________________________

  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-spec-
  ifier  has  been  seen even though its member functions are in general
  not yet defined.

3 Complete objects and  member  subobjects  of  class  type  shall  have
  nonzero  size.1) [Note: class objects can be assigned, passed as argu-
  ments to functions, and  returned  by  functions  (except  objects  of
  classes  for  which  copying  has  been restricted; see _class.copy_).
  Other plausible operators, 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  (clause  _class.derived_)  are  public  by  default
  (clause  _class.access_).   A union is a class defined with the class-
  key union; its members are public by default and  it  holds  only  one
  data  member  at  a  time (_class.union_).  [Note: aggregates of class
  type are described in _dcl.init.aggr_.  ] A POD-struct is an aggregate
  _________________________
  1) Base class subobjects are not so constrained.

  class  that  has no non-static data 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.  Similarly, a POD-union is an aggregate union that has  no
  non-static  data  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.  A
  POD class is a class that is either a POD-struct or a POD-union.

  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 (clause _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 {
          // ...
  };
  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 as a
  type-specifier as part of a declaration.  It differs from a class dec-
  laration  in  that  if  a class of the elaborated name is in scope the
  elaborated 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: The declaration of a class name takes effect immediately  after
  the  identifier  is  seen  in the class definition or elaborated-type-
  specifier.  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.type-
  def_.

  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
          ::opt nested-name-specifier templateopt unqualified-id ;
          using-declaration
          template-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 members of the class.  Except
  when used to declare friends (_class.friend_) or to introduce the name
  of   a   member  of  a  base  class  into  a  derived  class  (_names-
  pace.udecl_,_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 or member class
  template can be declared and then later defined.

2 A class is considered a completely-defined object type (_basic.types_)
  (or  complete  type)  at the closing } of the class-specifier.  Within
  the class member-specification, the  class  is  regarded  as  complete
  within  function  bodies,  default arguments and constructor ctor-ini-
  tializers (including such things in nested classes).  Otherwise it  is
  regarded as incomplete within its own class member-specification.

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

4 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_.

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

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

7 The decl-specifier-seq is omitted in constructor, destructor, and con-
  version 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_).

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

9 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_).

10[Note: the type of a nonstatic member function is an ordinary function
  type, and the type of a nonstatic data member is  an  ordinary  object
  type.   There  are  no  special  member  function types or data member
  types.  ]

11[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.  ]

12Nonstatic 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 unspecified
  (_class.access.spec_).  Implementation  alignment  requirements  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_).

13If  T  is the name of a class, then each of the following shall have a
  name different from T:

  --every data member of class T;

  --every member of class T that is itself a type;

  --every enumerator of every member of class T that  is  an  enumerated
    type; and

  --every member of every anonymous union that is a member of class T.

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

15Two  POD-union  (clause  _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_).

16If  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.

17A  pointer to a POD-struct object, suitably converted using a reinter-
  pret_cast, 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 align-
  ment.  ]

  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  (_dcl.fct.spec_),
  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 func-
  tion  definition  that  appears  outside of the class definition shall
  appear in a namespace scope enclosing the  class  definition.   Except

  for member function definitions that appear outside of a class defini-
  tion, and except for explicit specializations of template member func-
  tions  (_temp.spec_) appearing outside of the class definition, a mem-
  ber 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.  [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.  [Note: a name used in a member function
  definition (that is, in the parameter-declaration-clause including the
  default arguments (_dcl.fct.default_), or in the member function body,
  or, for a constructor function (_class.ctor_),  in  a  mem-initializer
  expression   (_class.base.init_))   is   looked  up  as  described  in
  _basic.lookup_.  ] [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 [Note: a member function can be declared (but  not  defined)  using  a
  typedef  for  a  function  type.   The  resulting  member function has
  exactly the same type as it would have if the function declarator were
  provided explicitly, see _dcl.fct_.  For example,

  typedef void fv(void);
  typedef void fvc(void) const;
  struct S {
          fv memfunc1;            // equivalent to: void memfunc1(void);
          void memfunc2();
          fvc memfunc3;           // equivalent to: void memfunc3(void) const;
  };
  fv  S::* pmfv1 = &S::memfunc1;
  fv  S::* pmfv2 = &S::memfunc2;
  fvc S::* pmfv3 = &S::memfunc3;
  Also see _temp.arg_.  ]

  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  (clause  _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)
                  perror("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, perror, and strcpy are not members of
  the class tnode and should be declared elsewhere.2) ]

3 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 function type (_dcl.fct_) 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.  ]

4 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
  _________________________
  2) See, for example, <cstring> (_lib.c.strings_).

  member  function  shall  not modify the object and its non-static data
  members.  [Example:
  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 has const type.  ]

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-quali-
  fied 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 (clause
  _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 referenced.  [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 If  an  unqualified-id  (_expr.prim_)  is  used in the definition of a
  static member following the member's declarator-id,  and  name  lookup
  (_basic.lookup.unqual_)  finds  that  the  unqualified-id  refers to a
  static member, enumerator, or nested type of the member's class (or of
  a base class of the member's class), the unqualified-id is transformed
  into a qualified-id  expression  in  which  the  nested-name-specifier
  names  the class scope from which the member is referenced.  The defi-
  nition of a static member shall not use directly the names of the non-
  static members of its class or of a base class of its class (including
  as operands of the sizeof operator).  The definition of a static  mem-
  ber  may  only  refer  to  these  members  to  form pointer to members
  (_expr.unary.op_) or with the class member access syntax (_expr.ref_).

4 Static  members  obey  the  usual  class  member  access rules (clause
  _class.access_).  When used in the declaration of a class member,  the
  static  specifier  shall  only be used in the member declarations that
  appear within  the  member-specification  of  the  class  declaration.
  [Note:  it  cannot  be specified in member declarations that appear in
  namespace scope.  ]

  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.   The  definition  for  a  static  data member shall appear 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 if it is used in the program  and  the  namespace
  scope definition shall not contain an initializer.

5 There  shall be exactly one definition of a static data member that is
  used in a program; no diagnostic  is  required;  see  _basic.def.odr_.
  Unnamed  classes  and  classes contained directly or indirectly within
  unnamed classes shall not contain static data members.  [Note: this is
  because  there  is  no  mechanism  to provide the definitions for such
  static data members.  ]

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.vir-
  tual_) 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
  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 pro-
  gram is ill-formed.

2 A union of the form
  union { member-specification } ;
  is called an anonymous union; it defines an unnamed object of  unnamed
  type.   The  member-specification  of  an  anonymous  union shall only
  define non-static data members.  [Note:  nested  types  and  functions
  cannot be declared within an anonymous union.  ] The names of the mem-
  bers of an anonymous union shall be distinct from  the  names  of  any
  other  entity  in  the scope in which the anonymous union is declared.
  For the purpose of name look up, after the anonymous union definition,
  the members of the anonymous union are considered to have been defined
  in the scope in which the anonymous union is declared.  [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 in a named namespace or in the global names-
  pace shall be declared static.  Anonymous  unions  declared  at  block
  scope  shall  be  declared with any storage class allowed for a block-
  scope variable, or with no storage class.   A  storage  class  is  not
  allowed  in  a declaration of an anonymous union in a class scope.  An
  anonymous union shall not have private or  protected  members  (clause
  _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.  The bit-field attribute is not part of the  type  of  the
  class  member.  The constant-expression shall be an integral constant-
  expression with a value greater than or equal to zero.  The  constant-
  expression  may be larger than the number of bits in the object repre-
  sentation (_basic.types_) of the bit-field's type; in such  cases  the
  extra  bits  are  used  as  padding bits and do not participate in the
  value representation (_basic.types_) of the bit-field.  Allocation  of
  bit-fields within a class object is implementation-defined.  Alignment
  of bit-fields is implementation-defined.  Bit-fields are  packed  into
  some  addressable allocation unit.  [Note: bit-fields straddle alloca-
  tion units on  some  machines  and  not  on  others.   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.   Only  when  declaring  an
  unnamed  bit-field  may  the  constant-expression  be a value equal to
  zero.

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,  short,  int  or  long  bit-field is signed or unsigned.  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.  A non-const reference shall  not
  be  bound  to a bit-field (_dcl.init.ref_).  [Note: if the initializer
  for a reference of type const T& is an lvalue that refers  to  a  bit-
  field,  the  reference is bound to a temporary initialized to hold the
  value of the bit-field; the reference is not bound  to  the  bit-field
  directly.  See _dcl.init.ref_.  ]

4 If  the value true or false is stored into a bit-field of type bool of
  any size (including a one bit bit-field), the original bool value  and
  the  value  of  the bit-field shall compare equal.  If the value of an
  enumerator is stored into a bit-field of the same enumeration type and
  the  number  of  bits in the bit-field is large enough to hold all the
  values of that enumeration type, the original enumerator value and the
  value of the bit-field shall compare equal.  [Example:

  enum BOOL { f=0, t=1 };
  struct A {
          BOOL b:1;
  };
  A a;
  void f() {
          a.b = t;
          if (a.b == t)           // shall yield true
          { /* ... */ }
  }
   --end example]

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

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

4 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, and has the same access to names outside the function  as  does
  the  enclosing  function.   Declarations in a local class can use only
  type names, static variables, extern variables and functions, and enu-
  merators 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 (clause _class.access_).   Mem-
  ber  functions  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 class nested within
  a local class is a local class.

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