calling non-static member function from static member function in a class

>>>> Is there any way to call non-static member function from static member function of the same class.

For the non-static member function you need an instance of the class, while the static member function works without an instance as a *globally* accessible function. So to call a non-static member you need to create or retrieve an instance

1. Create an instance

void MyClass::static_func()
{
     MyClass any;
     any.non_static_func();
}

The above compiles as long as you have a (default) constructor that takes no arguments.

However, it might be not that you want, in case there is already an instance of your class where you want to have access to by calling the non-static member function.

2. Add a static member to the class and store the last instance

class MyClass
{
      static MyClass* myLastPtr;
      ...
public:
      MyClass();
      static void static_func();
      void non_static_func();
};


// myclass.cpp

#include "myclass.h"

...
// initialize the static member
MyClass* MyClass::myLastPtr = NULL;

// constructor
MyClass::MyClass
{
      myLastPtr = this;
}

void MyClass::static_func()
{
     if (MyClass::myLastPtr != NULL)
     {
          myLastPtr->non_static_func();
     }
}


Here, you use the static class member to provide the last instance of the class for global or static access.

Note, the above only makes sense if your class is a singleton or never has two instances active at same time, e. g. dialog classes mostly will fulfil that requirement.

A variant of (2) is to collect *all* instances of a class in a statically defined  container. Here the constructor would look like

// constructor
MyClass::MyClass
{
      myAllContainer.add(this);   // add the instance to the all container
                                                 // which is a static member of the MyClass
}



3. Pass the instance as an argument to the static function

void MyClass::static_func(void * p)
{
     if (p != NULL)
     {
          ((MyClass*) p)->non_static_func();
     }
}

Note the cast is only necessary oif your argument *has* to be a void pointer or a baseclass pointer because you were not allowed to change the argument types. If the argunment type would be MyClass* you don't need a cast. In case of a baseclass pointer passed you could omit the cast by making the non_static_func a virtual function.