static keyword inside a class and outside it

Question

The static keyword is related to internal linkage generally, but the static keyword used inside a class has external linkage right? The variables m, n below are accessible outside the class file.

class c {
    int i;
    int j;
    static int m;
    static int n;

    public:
    void zap();
    static void clear();
};

`static` members belong to the *class*; for variables, they're accessible without an object and shared amongst instances e.g. `struct Foo { static void *bar; static void *fu(); }`, so `Foo::bar` and `Foo::fu` are legal. — obataku, Aug 27 '12 at 23:59
It's not strictly required by the Standard, but may (or may not!) help to think of static members as being static in the sense of a fixed address set at compile time, whereas non-static member data may be put on the stack or heap at various runtime-determined addresses. `static` members are basically like global variables except their identifier falls into the scope of the class declaring them. — Tony Delroy, Aug 28 '12 at 01:51

score 10 · Accepted Answer · answered Aug 28 '12 at 00:09

10

Right.

The keyword static is heavily overloaded with too many different meanings:

On a variable or function at namespace scope it gives the name internal linkage.
On a class member it makes it a static member, which doesn't affect linkage.
On a variable at function scope it gives the variable "static storage duration" as opposed to "automatic" or "dynamic" storage duration (i.e. the variable's lifetime extends to the end of the program, like global variables.)

answered Aug 28 '12 at 00:09

Jonathan Wakely

166,810
27
341
521

1

The non-class meanings are mostly the same as in C: http://stackoverflow.com/questions/572547/what-does-static-mean-in-a-c-program – Ciro Santilli OurBigBook.com Jul 01 '15 at 07:31

score 2 · Answer 2 · edited May 23 '17 at 12:22

As I stated in my comment, static members are those associated only with the class rather than individual objects.

static members belong to the class; for variables, they're accessible without an object and shared amongst instances e.g.
struct Foo {
  static void *bar;
  static void *fu();
}
so Foo::bar and Foo::fu are legal.

They are introduced in §9.4 of the C++03 standard;

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.
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 (5.2.5) 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
class process {
public:
    static void reschedule();
};
process& g();

void f()
{
    process::reschedule(); // OK: no object necessary
    g().reschedule(); // g() is called
}
A static member may be referred to directly in the scope of its class or in the scope of a class derived (clause 10) 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.
int g();
struct X {
    static int g();
};
struct Y : X {
    static int i;
};
int Y::i = g(); // equivalent to Y::g();
...

Some programmer dude · Answer 3 · 2012-08-28T00:31:36.713

1

You could say that static members are members of the class and not any specific object instance. That is, they have the same value for all object instances.

Static member functions, while not having a value, are otherwise the same. Instead of being unique for each object instance, they can be seen as part of the class. This means that they have no this pointer and can not access non-static member variables.

edited Aug 28 '12 at 00:31

answered Aug 28 '12 at 00:02

Some programmer dude

400,186
35
402
621

1

Member functions aren't usually said to have a *value*. ;-) – obataku Aug 28 '12 at 00:03

static keyword inside a class and outside it

3 Answers3