Problem with member in static member function

Question:

In my header file, I have the following pointer defined....
WinForm *winForm....

I pass in a pointer within my constructor:

SpecThread::SpecThread(WinForm *winForm)
{
   this->winForm = winForm;
}


Then I try to use it in a static method........
winForm->displayAll();

I receive an error, invalid use of member SpecThread::winForm in static member function
jeweeAsked:
Who is Participating?
 
aviadbdCommented:

>> Unless I create a non static function and call it within the static function??

You cannot call any non-static members, functions included, from within a static method.

If your handler is a single handler within your entire application, you could try the singleton approach - that way you could initialize it with your WinForm at the beginning of the application and call it from the static method.

class MySingleton
{
  protected:
    MySingleton();

  public:
    static MySingleton* GetInstance();
    void SetWinForm(WinForm* winForm);

  private:
    MySingleton* _instance;
}

check this out for how to implement:
http://www.codeproject.com/cpp/singletonrvs.asp

Good luck!
AviadBD.
0
 
AxterCommented:
If you're trying to access the modified pointer from the calling function, then you need to pass a reference to the pointer.
0
 
AxterCommented:
SpecThread::SpecThread(WinForm& *winForm) //Reference to the pointer
{
  this->winForm = winForm;
}
0
Free Tool: Path Explorer

An intuitive utility to help find the CSS path to UI elements on a webpage. These paths are used frequently in a variety of front-end development and QA automation tasks.

One of a set of tools we're offering as a way of saying thank you for being a part of the community.

 
AxterCommented:
Disregard previous comments.  Misread the question.

>>Then I try to use it in a static method........

You can not access a non-static member from a static member directly.
0
 
AxterCommented:
>>I receive an error, invalid use of member SpecThread::winForm in static member function

In order to use a none-static member in a static member function, you need to have a pointer/reference to a valid instance of the object.

Exactly what are you trying to do?
We could give you some better alternatives.
0
 
jeweeAuthor Commented:
Didn't work.  It states that it cannot declare pointers to references..
0
 
AxterCommented:
>>Didn't work.  It states that it cannot declare pointers to references..

As I stated in my follow-up comments, you can not access none-static members from a static member function directly.
0
 
jeweeAuthor Commented:
This thread class I have, the handler method has to be declared static when I try to catch a signal.  within the handler method, if the signal is caught, then I display the window.  Unless I create a non static function and call it within the static function??
0
 
AxterCommented:
If each instance of your class has an assoicated unique ID number, then you could trying creating a list or map container that pointed to each instance via ID.

Your static function can then get a pointer to then instance via the ID.
0
 
jkrCommented:
Have you read the proposals in your other Q?
0
 
AxterCommented:
Example:

class SignalThread
{
public:
      SignalThread(int signum);
      ~SignalThread();
      static void messageHandler(int signum);
      void show(){}
private:
      static std::map<int,SignalThread*> MyList;
      int My_signum;
};


SignalThread::SignalThread(int signum)
{
      My_signum = signum;
      MyList[My_signum] = this;
}

SignalThread::~SignalThread()
{
      MyList.erase(My_signum);
}

std::map<int,SignalThread*> SignalThread::MyList;

void SignalThread::messageHandler(int signum)
{
      SignalThread* window = MyList[signum];
//   signalServerFlag = 1;
   window->show();
   return;
}



int main(){
      SignalThread SignalThread1(100);
      SignalThread SignalThread2(22);
      SignalThread::messageHandler(22);
      SignalThread::messageHandler(100);
      return 0;
}
0
 
itsmeandnobodyelseCommented:
If a worker thread has to communicate with the main thread (GUI), normally its done by passing a pointer of the active window as thread parameter:

  void WinForm::createThread(...)
  {
        // pass this pointer to thread
       
        beginThread(MyThread::threadFunc, 0, this, ...);
        // CreateThread(NULL, 0, MyThread::threadFunc, this, ...);
  }

class MyThread is declared like that:

class MyThread
{
public:
             ...
       // the one and only thread function
       static void threadFunc(void* pParam);    
       static void signalHandler(..);

private:
       static WinForm* m_pWinForm;   // pointer to window
};

  void MyThread::threadFunc(void* pParam)
  {
        m_pWinForm* = (WinForm*)pParam;    //   store the window pointer

        ....
  }

  void MyThread::signalHandler(..)
  {
        ...
        m_pWinForm->displayAll(); // that works as m_pWinForm is static also
        ...
  }

Note, if you have more than one worker thread referring to different windows the solution doesn't work.

Regards, Alex
0
 
itsmeandnobodyelseCommented:
>>>> m_pWinForm* = (WinForm*)pParam;    //   store the window pointer

That's a typo, it should be

>>>> m_pWinForm = (WinForm*)pParam;    //   store the window pointer

Regards, Alex

       
0
 
jeweeAuthor Commented:
Now I am getting a ld: fatal symbol referencing error..

undefined symboll, first referenced in file SignalThread..
0
 
AxterCommented:
Can you post the code you have now?
0
 
jeweeAuthor Commented:
#include.....
#include "SignalThread.h"

SignalThread::SignalThread(MainForm *mainForm)
{
   this->mainWin = mainWin;
}
void SignalThread::run()
{
   for (;;)
   {  
      signal(SIGUSR1, messageHandler);
   }
}
//message handler method is static.
void SignalThread::messageHandler (int signum)
{
    mainWin->show();
    return;
}

//in my header file, I have the following:

#ifndef  SIGNALTHREAD_H_
#define  SIGNALTHREAD_H_

#include "MainForm.h"
#include <qthread.h>

class SignalThread: public QThread
{
   public:

      SignalThread(MainForm *mainForm);

      ~SignalThread();
      virtual void run();

      static void messageHandler(int signum);
   private:
};

#endif // SIGNALTHREAD_H

In my TestMain.cpp file, i have the following...

#include <qapplication.h>
#include <qwindowsstyle.h>
#include <iostream>
#include <qthread.h>
#include "MainForm.h"
#include "SignalThread.h"

int main( int argc, char ** argv )
{
    QApplication app( argc, argv );
    // Check if environmet variable "APPLICATION_FONT_SIZE" exists
    int fontSize = 10;
    char* fontSizeStr = getenv("APPLICATION_FONT_SIZE");
    if (fontSizeStr)
      fontSize = atoi(fontSizeStr);

        // Create main window
    MainForm mainWin;

    // Connect to Server
    mainWin.connectServer(argc, argv);

    // Show Main window
    app.setMainWidget(&mainWin);
    mainWin.show();

    app.connect( &app, SIGNAL( lastWindowClosed() ), &app, SLOT( quit() ) );

    // Begin signal thread
    SignalThread*sigThread = new SUBUI_signalThread(&mainWin);
    sigThread->start();
   
    return app.exec();


}
0
 
jeweeAuthor Commented:
oops typo....

In the main, I meant......

// Begin signal thread
    SignalThread*sigThread = new SignalThread(&mainWin);
    sigThread->start();
0
 
AxterCommented:
>>jewee,

Where is the class declaration for type MainForm?
0
 
jeweeAuthor Commented:
I am all set.  It was something else entirely differently.  Thank you for your feedback.

0
 
jeweeAuthor Commented:
PLEASE CLOSE OUT THIS QUESTION...
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.