Signal innerhalb Klasse Handhabung

Ich habe Probleme mit signal Funktion, ich brauche, dass der zweite ParameterSignal innerhalb Klasse Handhabung

signal (SIGINT, myClass_function);

aber soweit ich weiß, eine Funktion meiner Klasse aufrufen muss es statische nichtig. Und so kann ich nicht die gleiche Instanz von meinem Objekt Zugriff auf die Variablen zugreifen, die ich brauche

foo.h

class Foo { 
public: 
    std::vector<my_struct> vm = std::vector<my_struct>(50); 

    static void myClass_function(int parameter) { 
    // handling signal here 
    // i need to access vm here 
    } 

};

foo.cpp

void Foo::something() { 
    // call signal 
    signal(SIGINT, myClass_function);  
}

wenn Benutzer drücken Strg + C, müssen alle Daten von Vektor VM sauber sein. Keine Möglichkeit, das zu tun? kann mir jemand helfen?

Quelle

2016-06-16 Melissia_M

Helfen Sie mit was? Ihr Verständnis davon, wie ein Signal-Handler funktioniert, ist absolut richtig. Der Signalhandler wird asynchron aufgerufen, wenn der Prozess ein Signal empfängt. Das ist es. Nichts mehr. Nicht weniger. Der Signalhandler erhält nicht nur irgendeinen anderen Parameter, er kann auch keine Bibliotheksfunktion oder einen Code aufrufen, der nicht wiedereintritt. Der gesamte Signalhandler hat, um damit zu arbeiten, dass er als Ergebnis eines Signals aufgerufen wurde. Es ist Aufgabe des Signal-Handlers herauszufinden, was er benötigt und wo er herkommt. –

Und wenn es ein Signal gibt, welches "Foo" 'vm' sollte vom Signal-Handler verwendet werden? – md5i

Überprüfen Sie die Antwort von Luc Touraille in diesem Beitrag: [Ist es möglich, Signal innerhalb einer C++ - Klasse zu verwenden?] (Http://stackoverflow.com/questions/343219/is-it-possible-to-use-signal-inside -ak-Klasse). – chema989

Die Lösung kann als Singleton Wrapper deklariert werden, der die richtige Instanz behandelt. Ich schlage vor, den nächsten Code basiert auf der Idee von Luc Touraille:

#include <iostream> 
#include <signal.h> 


class Foo; 


class Wrap { 
    Foo* foo; 

    Wrap() = default; 

public: 
    static Wrap& getInstance() { 
     static Wrap* w = new Wrap(); 
     return *w; 
    } 

    void set(Foo* foo_) { 
     foo = foo_; 
    } 

    Foo* get() { 
     return foo; 
    } 
}; 


class Foo { 
    int x; 

public: 
    Foo(int x_) 
     : x(x_) { } 

    void something() { 
     // call signal 
     static Wrap& w = Wrap::getInstance(); 
     w.set(this); 
     signal(SIGINT, Foo::myHandler); 
     raise(SIGINT); 
    } 

    static void myHandler(int parameter) { 
     static Wrap& w = Wrap::getInstance(); 
     fprintf(stderr, "%d %d\n", w.get()->x, parameter); 
    } 
}; 

int main() { 
    Foo f(10); 
    Foo f2(100); 
    f.something(); 
    f2.something(); 
}

Ausgang:

10 2 
100 2

Ich schlage vor, Sie das, wenn Sie möchten mehrere Instanzen von Foo. Auf der anderen Seite, wenn Sie nur eine Instanz von Foo benötigen, brauchen Sie den Singleton-Wrap nicht und Foo sollte Singleton sein.

Quelle

2016-06-16 13:46:09 chema989

Antwort

Verwandte Themen