c++ accessing static member function with member-selection operator (. or –>)

Question

I just noticed that we can access c++ static member function by member-selection operator (. or –>)

for example:

class StaticTest
{
private:
  int y;
  static int x;
public:
  StaticTest():y(100){

  }
  static int count()
  {
    return x;
  }
  int GetY(){return y;}
  void SetY(){
    y = this->count();                         //#1 accessing with -> operator 
  }
};

Here are how to use

  StaticTest test;
  printf_s("%d\n", StaticTest::count());      //#2
  printf_s("%d\n", test.GetY());
  printf_s("%d\n", test.count());             //#3 accessing with . operator 
  test.SetY();

what is the use case of #1 and #3?
what is the difference between #2 and #3?

Another style of #1 for accessing static member function in member function is

  void SetY(){
    y = count();                             //however, I regard it as 
  }                                          // StaticTest::count()

But now it looks more like this->count(). Is there any difference of two style calling?

Thanks

`this->count()`? is that correct. I'm confused! – W.K.S Dec 27 '11 at 07:54 — W.K.S, Dec 27 '11 at 07:54
@ErichLancaster, I test it in VC 2010, it could be built. – Chang Dec 27 '11 at 08:33 — Chang, Dec 27 '11 at 08:33

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

2

Have a look at this question.

According to the standard (C++03, 9.4 static members):

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.

So, when you already have an object and you're calling a static method on it, then there is no difference to using the class member access syntax.

If you however need to create the object first (be it by instantiating the object directly before, or by calling some function), then this creation process will of course take up a little extra time and memory. The this-Pointer, however, is never passed in to a static function, the call itself is always the same, no matter how it was written.

edited May 23 '17 at 12:34

Community

1
1

answered Dec 27 '11 at 07:57

codeling

11,056
4
42
71

Does it affect name lookup at compile time? because given a instance or this pointer, it has different meaning comparing with "class::" – Chang Dec 27 '11 at 08:42
Good question. If, then probably only very little; it might be one less lookup in the symbol table when the class name is specified (since in the other case, for an object, the class of this particular object would have to be looked up first, and only then the class itself). But I'd be very surprised if that has any noticeable effects on compile times. – codeling Dec 27 '11 at 10:16

score 1 · Answer 2 · answered Dec 27 '11 at 07:54

I'm a little confused about the answer to your first question, but with regards to your second question:

in #2 ( StaticTest::count() ), you used the count() method in a static manner, which means you called the function without creating a StaticTest object.

in #3 (test.count()), you created a StaticTest object called test, and called the method through the object (even though it was unnecessary.)

Functionally, there is no difference, but #2 is the preferred way of calling StaticMethods. Making an object when it is not needed is bad use of memory.

score 1 · Answer 3 · answered Dec 27 '11 at 07:59

C++03, 9.4 static members

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.

c++ accessing static member function with member-selection operator (. or –>)

3 Answers3