私有静态类成员

Question

When we declare a member variable static, it is shared between all instances of the class. I've heard that you should think of the variable belonging to the class itself, not any instance. This lets us initialize the variable without instantiating any object of the class, which makes sense.

class Something
{
  public:
    static int s_nValue;
};

int Something::s_nValue = 1;

But why are we allowed to initialize a private static member?

class Something
{
   private:
      static int s_nValue;
};

int Something::s_nValue = 1;

Does private even mean anything when we are talking about static members?

Answer 1

Yes, it does mean something. Consider the following example, which throws a compiler error, because the member is private . Being able to initialize a private variable is not the same as being able to change it from any context.

class Something
{
  private:
    static int s_nValue;
};

int Something::s_nValue = 1;

int main(){
    Something::s_nValue = 2; // Compiler error here.
}

Answer 2

Private still means the same thing: you cannot use the name Something::s_nValue except in the definition of a member of Something (or a friend, or a nested class within Something ).

int Something::s_nValue = 1;

is the definition of a member of Something - namely, that static member s_nValue .

int Something::another_static_val = s_nValue;  // also okay
int OtherClass::x = Something::s_nValue;       // Illegal access!

int Something::getValue() const {
    return s_nValue;                // okay, getValue is a member of same class
}

int regularFunction() {
    return Something::s_nValue;     // Illegal access!
}

Answer 3

Does private even mean anything when we are talking about static members?

I'll try to answer with a classic example. Consider the following piece of code:

#include <iostream>

class foo {
  static int count;
  int id;
public:
  foo() : id(++count) {}
  int getid() const { return id; }
};

int foo::count = 0;

int main() {
  foo f1, f2, f3;

  std::cout << f1.getid() << std::endl;
  std::cout << f2.getid() << std::endl;
  std::cout << f3.getid() << std::endl;
}

LIVE DEMO

In the example above we use a private static int to count the instances of foo created. We made the count static member variable private because we don't want anyone else except object of type foo to mess with it.

And this is only a naive example, think of the possibilities.

Answer 4

Public, private and protected are properties of a class and not of an object. Their purpose is to let you specify which parts of this class are visible to other classes, and not to hide stuff from objects of the same class. So, you can write code like this :

class A
{
public:
bool operator<(const A& other)
{
return this->val < other.val;
}
private:
int val;
};

So, private makes sense even when applied to static members - it just says that other classes cannot see this member.