为什么我可以静态调用实例函数？

Question

I was looking around the Notepad++ source code on GitHub recently, and came across a method call like this:

Window::init(hInst, parent);

I searched for the function it was referencing to, and came across a Window class- but the init function was marked virtual , so clearly it was non-static. Thinking I made a mistake, I checked the entire header to make sure there was no static overload of init , and I made sure there was no Window.cpp file. There isn't.

After poking around the source for 15 more minutes, I gave in and git cloned the repo locally so I could open it in Visual Studio. The first thing I did was to build just to make sure this wasn't an accidental merge on behalf of the project developers- the build succeeded.

The next steps I took:

• I opened the the file calling Window::init and clicked Go To Declaration on Window . It takes me to the Window class.

• I clicked Go To Declaration on the init function. It points me to the signature of the virtual method.

• I copy and paste the Window.h file into an entirely new header and replace all references of Window with Foo . When I type in Foo::init , the compiler complains that 'a nonstatic member reference must be relative to a specific object'.

TL;DR: Somehow, the Notepad++ source code calls a non-static method statically, and this builds. Doesn't work with any other class. Proof here and here .

I have spent 2 hours staring at this, but I still don't see how it's possible. Am I missing something?

Answer 1

No, it's not calling a static function. It's just calling the base class's version of init() . Basically, in tClassName::f , you are asking "I want to call that specific version of the virtual function f() in class tClassName ".

Generally, it's pretty common to call the base class's counterpart of a virtual function in the derived class. Eg, the factory method pattern:

#include "tObject.h"
#include "tObject1.h" // public inheritance from tObject
#include "tObject2.h" // public inheritance from tObject
#include "tObject3.h" // public inheritance from tObject

class BaseFactory
{
public:
   // factory method
   virtual tNode *createObject(int id)
   {
      if (id == 1) return new tObject1;
      else return new tObject2;
   }
};

class DerivedFactory: public BaseFactory
{
public:
   virtual tNode *createObject(int id)
   {
      // Overrides the default behavior only for one type
      if (id == 1) return new tObject3;
      // Call the default factory method for all other types
      else return BaseFactory::createObject(id);
   }
};

Answer 2

Am I missing something?

Yes - context. Notepad_plus_Window derives from Window , and the call to Window::init() is inside of the Notepad_plus_Window::init() method:

class Notepad_plus_Window : public Window { 
public: 
    ...
    void init(HINSTANCE, HWND, const TCHAR *cmdLine, CmdLineParams *cmdLineParams); 
    ...
};

void Notepad_plus_Window::init(HINSTANCE hInst, HWND parent, const TCHAR *cmdLine, CmdLineParams *cmdLineParams) 
{ 
    ...
    Window::init(hInst, parent); 
    ...
}

In this context, Notepad_plus_Window is calling the base class Window version of init() .

Answer 3

Maybe this will confuse you less. You're missing context, at no real fault of your own.

You're not seeing the implicit this in the call.

Take the following example:

#include <cstdio>
#include <iostream>

class Foo {
public:
  virtual void bar() {
    std::cout << "Foo" << std::endl;
  }
};

class Bar : public Foo {
public:
  virtual void bar() {
    std::cout << "Bar" << std::endl;
  }
};

int main() {
  Bar bar;
  bar.bar();        //-> bar
  bar.Foo::bar();   //-> foo

  Bar *barp = &bar;
  barp->bar();      //-> bar
  barp->Foo::bar(); //-> foo

  return 0;
}

In the above, we can specify the object on which to call a specific method in the class' hierarchy.

Answer 4

It's not a static function. It's calling a function with a specified (class) scope.

By default, init() will match functions within current class scope, if they do exist. that is an implicit this call, equals this->init(),

But with a specified class/namespace prefix, you can explicit call any particular function without dynamic binding. ie ::init() will call the init() function within global scope.

the following code may give you a better understanding

#include <iostream>

class A
{
public:
  virtual void  test()
  {
      std::cout << "A" << std::endl;
  }
};

class B : public A
{
public:
    virtual void test()
    {
        std::cout << "B" << std::endl;
    }
};

int main()
{
    A* a = new B();
    a->A::test();
    return 0;
}