11 Classes [class]

11.4 Class members [class.mem]

11.4.8 Static members [class.static]

1
#
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 evaluated.
[ Example
: 
struct process {
  static void reschedule();
};
process& g();

void f() {
  process::reschedule();        // OK: no object necessary
  g().reschedule();             // g() is called
}
— end example
 ]
2
#
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 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
#
Static members obey the usual class member access rules ([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 definition.
[ Note
:
It cannot be specified in member declarations that appear in namespace scope.
— end note
 ]

11.4.8.1 Static member functions [class.static.mfct]

1
#
[ Note
:
The rules described in [class.mfct] apply to static member functions.
— end note
 ]
2
#
[ Note
:
A static member function does not have a this pointer ([class.this]).
— end note
 ]
A static member function shall not be virtual.
There shall not be a static and a non-static 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.

11.4.8.2 Static data members [class.static.data]

1
#
A static data member is not part of the subobjects of a class.
If a static data member is declared thread_­local there is one copy of the member per thread.
If a static data member is not declared thread_­local there is one copy of the data member that is shared by all the objects of the class.
2
#
A static data member shall not be mutable ([dcl.stc]).
A static data member shall not be a direct member ([class.mem]) of an unnamed ([class.pre]) or local ([class.local]) class or of a (possibly indirectly) nested class ([class.nest]) thereof.
3
#
The declaration of a non-inline static data member in its class definition is not a definition and may be of an incomplete type other than cv void.
The definition for a static data member that is not defined inline in the class definition shall appear in a namespace scope enclosing the member's class definition.
In the definition 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 process.
In the static data member definition, the initializer expression refers to the static data member running of class process.
— end example
 ]
[ 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.
— end example
 ]
— end note
 ]
4
#
If a non-volatile non-inline const static data member is of integral or enumeration type, its declaration in the class definition can specify a brace-or-equal-initializer in which every initializer-clause that is an assignment-expression is a constant expression ([expr.const]).
The member shall still be defined in a namespace scope if it is odr-used ([basic.def.odr]) in the program and the namespace scope definition shall not contain an initializer.
An inline static data member may be defined in the class definition and may specify a brace-or-equal-initializer.
If the member is declared with the constexpr specifier, it may be redeclared in namespace scope with no initializer (this usage is deprecated; see [depr.static.constexpr]).
Declarations of other static data members shall not specify a brace-or-equal-initializer.
5
#
[ Note
:
There is exactly one definition of a static data member that is odr-used ([basic.def.odr]) in a valid program.
— end note
 ]
6
#
[ Note
:
Static data members of a class in namespace scope have the linkage of the name of the class ([basic.link]).
— end note
 ]
7
#
Static data members are initialized and destroyed exactly like non-local variables ([basic.start.static], [basic.start.dynamic], [basic.start.term]).