static specifier

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

C++ language

General topics
Preprocessor Comments Keywords	ASCII chart Escape sequences History of C++
Flow control
Conditional execution statements
if statement	switch statement
Iteration statements
for loop range-for loop (C++11)	while loop do-while loop
Jump statements
continue statement break statement	goto statement return statement
Functions
function declaration
lambda function declaration
function template
inline specifier
exception specifications (deprecated)
noexcept specifier (C++11)
Exceptions
throw expression	try-catch block
Namespaces
namespace declaration	namespace aliases
Types
fundamental types compound types enumeration types	union types function types
decltype specifier (C++11)
Specifiers
cv specifiers
storage duration specifiers
constexpr specifier (C++11)
auto specifier (C++11)
alignas specifier (C++11)
Initialization
default initialization value initialization zero initialization copy initialization direct initialization	aggregate initialization list initialization (C++11) constant initialization reference initialization

Literals
integer literals character literals floating-point literals string literals	boolean literals nullptr (C++11) user-defined (C++11)
Expressions
value categories order of evaluation	operators operator precedence
alternative representations
Utilities
Types
typedef declaration
type alias declaration (C++11)
attributes (C++11)
Casts
implicit conversions
const_cast conversion
static_cast conversion
dynamic_cast conversion
reinterpret_cast conversion
C-style and functional cast
Memory allocation
new expression	delete expression
Classes
class declaration this pointer access specifiers	friend specifier initializer lists
Class-specific function properties
virtual function override specifier (C++11) final specifier (C++11)	explicit (C++11) static
Special member functions
default constructor copy constructor move constructor (C++11)	copy assignment move assignment (C++11) destructor
Templates
class template
function template
template specialization
parameter packs (C++11)
Miscellaneous
Inline assembly

 

Inside a class, declares members not bound to specific instances.

Syntax

static data_member
static member_function

1) Declares a static data member:

2) Declares a static member function.

Explanation

Static members of a class are not associated with the objects of the class: they are independent objects with static storage duration or regular functions defined in namespace scope, only once in the program.

The static keyword is only used with the declaration of a static member, inside the class definition, but not with the definition:

class X {
    static int n; // declaration (uses 'static')
};
int X::n = 1; // definition (does not use 'static')

The declaration inside the class body is not a definition and may declare the member to be of incomplete type (other than void).

struct Foo;
struct S {
   static int a[]; // incomplete type
   static Foo x; // incomplete type
};
 
int S::a[10]; // definition, complete type
struct Foo {};
Foo S::x; // definition, complete type

To refer to a static member n of class T, two forms may be used: qualified name T::m or member access expression e.m or e->m, where e is an expression that evaluates to T or T* respectively. When in the same class scope, the qualification is unnecessary:

struct X {
    static void f(); // function declaration
    static int n; // member declaration
};
 
X g() { return X(); } // some function returning X
 
void f() {
    X::f();  // qualified name access to static function
    g().f(); // expression member access to static function
}
 
int X::n = 7; // definition
 
void X::f() { // definiton
    n = 1; // X::n is accessible as just n in this scope.
}

Static members obey the class member access rules (private, protected, public).

Static member functions

Static member functions are not associated with any object. When called, they have no this pointer. They cannot be virtual, const, or volatile. They cannot access non-static data members of the class. Address of a static member function may be stored in a regular pointer to function, but not in a pointer to member function.

Static data members

The static member objects are not part of the object. If the static member is declared thread_local(since C++11), there is one such object per thread. Otherwise, there is only one instance of the static member object in the entire program, with static storage duration. The static members exist even if no objects of the class have been defined.

Static data members cannot be mutable.

Static data members of classes in namespace scope have external linkage.

Local classes (classes defined inside functions) and unnamed classes, including member classes of unnamed classes, cannot have static data members.

Constant static members

If a static data member of integral or enumeration type is declared const (and not volatile), it can be initialized with a brace-or-equal initializer that is a constant expression, right inside the class definition. In this case, no definition is needed:

struct X {
    const static int n = 1;
    const static int m{2}; // since C++11
};
// const int X::n = 2; // ERROR: redefinition

If a static data member of LiteralType is declared constexpr, it can be initialized with a brace-or-equal initializer that is a constant expression inside the class definition. A definition at namespace scope is still required, but it should not have an initializer: struct X { constexpr static int n = 1; }; constexpr int X::n;

(since C++11)

References

• C++11 standard (ISO/IEC 14882:2011):

• 9.4 Static members [class.static]

• C++98 standard (ISO/IEC 14882:1998):

• 9.4 Static members [class.static]

See also

• static storage specifier