¿Es posible usar la señal dentro de una clase de C++?

Question

que estoy haciendo algo como esto:

#include <signal.h> 

class myClass { 

    public: 

    void myFunction() 
    { 
    signal(SIGIO,myHandler); 
    } 

    void myHandler (int signum) 
    { 
    /** 
    * Handling code 
    */ 
    } 

    } 

estoy trabajando en Ubuntu, usando gcc.

Pero no compilará. Se queja con:

error: the argument with type void (MyClass::)(int) doesn't agree with void (*) (int)

¿Alguna pista? ¿O tal vez es solo que no puedo usar una señal dentro de las clases? ¿Las señales solo están permitidas en C?

El mensaje de error es una traducción aproximada porque mi compilador no está en inglés.

Answer 1

El segundo parámetro de la señal debe ser un puntero a una función que acepte un vacío int y de retorno. Lo que está pasando para señalizar es un puntero a una función miembro que acepta un vacío int y return (su tipo es void (myClass::*)(int)). Veo tres posibilidades para superar este problema:

1 - Su método myHandler puede ser estática: esto es muy bueno, que sea estática

class myClass 
{ 
    public: 
    void myFunction() 
    { 
     signal(SIGIO, myClass::myHandler); 
    } 

    static void myHandler (int signum) 
    { 
     // handling code 
    } 
}; 

2 - Su método no debe ser estática: si' Si planeas utilizar la señal con una sola instancia, puedes crear un objeto estático privado y escribir un método estático que simplemente llame al método en este objeto. Algo a lo largo de las líneas de

class myClass 
{ 
    public: 
    void myFunction() 
    { 
     signal(SIGIO, myClass::static_myHandler); 
    } 

    void myHandler (int signum) 
    { 
     // handling code 
    } 

    static void static_myHandler(int signum) 
    { 
     instance.myHandler(signum); 
    } 

    private: 
    static myClass instance; 
}; 

3 - Sin embargo, si usted está planeando sobre el uso de la señal con varias instancias, las cosas se pondrán más complicado. Tal vez una solución sería la de almacenar cada instancia que desea manipular en un vector estático, e invocando el método en cada uno de los siguientes:

class myClass 
{ 
    public: 
    void myFunction() // registers a handler 
    { 
     instances.push_back(this); 
    } 

    void myHandler (int signum) 
    { 
     // handling code 
    } 

    static void callHandlers (int signum) // calls the handlers 
    { 
     std::for_each(instances.begin(), 
         instances.end(), 
         std::bind2nd(std::mem_fun(&myClass::myHandler), signum)); 
    } 
    private: 
    static std::vector<myClass *> instances; 
}; 

y en algún lugar, hacer una sola llamada a

signal(SIGIO, myClass::callHandlers); 

Pero Creo que si terminas usando la última solución, probablemente deberías pensar en cambiar tu diseño de manejo :-)!

Answer 2

Lea esta sección siguiente (33,2):

C++ FAQ - pointers-to-members

Answer 3

pasar un puntero a un método, que debe ser un método estático y debe especificar el nombre de la clase.

Prueba esto:

class myClass { 
    void myFunction() 
    { 
    signal(SIGIO, myClass::myHandler); 
    } 

    static void myHandler (int signum) 
    { 
    // blabla 
    } 
}; 

Y también debe leer el enlace suministrado por Baget, la paragraph 33.2 in the C++ FAQ.

Answer 4

En realidad, los manejadores de señal C++ no tienen permitido utilizar ninguna instalación que no esté presente tanto en C como en C++ (excepto que en C++ 11 pueden usar átomos), y se requiere el uso del enlace C. Citando C++11 draft n3242 sección 18.10   "Otro soporte de ejecución" [support.runtime] (párrafo 8),

The common subset of the C and C++ languages consists of all declarations, definitions, and expressions that may appear in a well formed C++ program and also in a conforming C program. A POF (“plain old function”) is a function that uses only features from this common subset, and that does not directly or indirectly use any function that is not a POF, except that it may use functions defined in Clause 29 that are not member functions. All signal handlers shall have C linkage. A POF that could be used as a signal handler in a conforming C program does not produce undefined behavior when used as a signal handler in a C++ program. The behavior of any other function used as a signal handler in a C++ program is implementation-defined.

(Cláusula 29 siendo el uno en atómica.)

Answer 5

#include <signal.h> 

class myClass { 

private: 
    static myClass* me; 

public: 
    myClass(){ me=this; } 

    void myFunction(){ 
    signal(SIGIO,myClass::myHandler); 
    } 

    void my_method(){ } 

    static void myHandler (int signum){ 
    me->my_method(); 
} 
}