static members

Inside a class definition, the keyword static declares members that are not bound to class instances.

Outside a class definition, it has a different meaning: see storage duration.

Syntax

A declaration for a static member is a member declaration whose declaration specifiers contain the keyword static. The keyword static usually appears before other specifiers (which is why the syntax is often informally described as static data-member or static member-function

The name of any static data member and static member function must be different from the name of the containing class.

Explanation

Static members of a class are not associated with the objects of the class: they are independent variables with staticor thread(since C++11) storage duration

The static

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[]; // declaration, incomplete type
    static Foo x;   // declaration, incomplete type
    static S s;     // declaration, incomplete type (inside its own definition)
};
 
int S::a[10]; // definition, complete type
struct Foo {};
Foo S::x;     // definition, complete type
S S::s;       // definition, complete type

To refer to a static member m 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*

struct X
{
    static void f(); // declaration
    static int n;    // declaration
};
 
X g() { return X(); } // some function returning X
 
void f()
{
    X::f();  // X::f is a qualified name of static member function
    g().f(); // g().f is member access expression referring to a static member function
}
 
int X::n = 7; // definition
 
void X::f() // definition
{
    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.

Static member functions cannot be virtual, const, volatile, or ref-qualified

The 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

Static data members are not associated with any object. They exist even if no objects of the class have been defined. There is only one instance of the static data member in the entire program with static storage duration , unless the keyword thread_local is used, in which case there is one such object per thread with thread storage duration (since C++11)

Static data members cannot be mutable.

Static data members of a class in namespace scope have external linkage if the class itself has external linkage (is not a member of unnamed namespace

struct X
{
    inline static int fully_usable = 1; // No out-of-class definition required, ODR-usable
    inline static const std::string class_name{"X"}; // Likewise
 
    static const int non_addressable = 1; // C.f. non-inline constants, usable
                                          // for its value, but not ODR-usable
    // static const std::string class_name{"X"}; // Non-integral declaration of this
                                                 // form is disallowed entirely
};

Constant static members

If a static data member of integral or enumeration type is declared const (and not volatile), it can be initialized with an initializer in which every expression is a constant expression

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

struct X
{
    constexpr static int arr[] = { 1, 2, 3 };        // OK
    constexpr static std::complex<double> n = {1,2}; // OK
    constexpr static int k; // Error: constexpr static requires an initializer
};

If a const non-inline(since C++17) static data member or a constexpr static data member(since C++11)(until C++17) is ODR-use

struct X
{
    static const int n = 1;
    static constexpr int m = 4;
};
 
const int *p = &X::n, *q = &X::m; // X::n and X::m are ODR-used
const int X::n;             // … so a definition is necessary
constexpr int X::m;         // … (except for X::m in C++17)

Keywords

static

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

References

See also

• static storage specifier