Behandeln Sie STRG+C auf Win32

Habe ich einige Probleme mit der Handhabung von STRG+C - Ereignisse, die in einem Win32 C++ Konsole.

Grundsätzlich mein Programm sieht wie folgt aus: (basierend auf dieser anderen Frage: Windows Strg-C - Reinigung der lokale stack-Objekte in der Befehlszeile app)

bool running;

int main() {

    running = true;
    SetConsoleCtrlHandler((PHANDLER_ROUTINE) consoleHandler, TRUE);

    while (running) {
       //do work
       ...
    }

    //do cleanup
    ...

    return 0;
}

bool consoleHandler(int signal) {

    if (signal == CTRL_C_EVENT) {

        running = false;
    }
    return true;
}

Ist das problem der cleanup-code nicht ausgeführt überhaupt.

Nach der Ausführung der handler-Funktion in der Prozess beendet wird, aber ohne den code auszuführen, nachdem der main-loop. Was ist falsch?

EDIT: wie gewünscht, das ist ein minimaler Testfall ähnlich wie mein Programm: http://pastebin.com/6rLK6BU2

Habe ich nicht den "test-cleanup-Anweisung" Text in meiner Ausgabe.

Ich weiß nicht, ob das wichtig ist, ich kompiliere mit MinGW.

EDIT 2: Das problem mit den test-case-Programm ist die Verwendung der Sleep() Funktion. Ohne ihn funktioniert das Programm wie erwartet.

In Win32 die Funktion handler läuft in einem anderen thread, so dass, wenn der Hundeführer/thread beendet seine Ausführung, der Haupt-thread schlafen. Vermutlich ist dies die Ursache von Prozess-Unterbrechung?

Was bedeutet SetConsoleCtrlHandler zurück?
Sind Sie sicher, dass die ConsoleHandler Funktion läuft? Wenn du das Programm im debugger und setzen Sie einen Haltepunkt, wird es halt am Haltepunkt?
Auch, sollten Sie BOOL für die retval, und DWORD für das argument der consoleHandler. Auch, FALSCH/WAHR, in...
Und Sie deklarieren Sie eine Funktion Prototyp des consoleHandler - Funktion vor dem Aufruf SetConsoleCtrlHandler?
Wie können Sie dann überprüfen, dass der code nach der Schleife nicht ausgeführt werden? Wenn Sie einen Haltepunkt in den code ein und führen Sie in einem debugger, wird es aufhören?

InformationsquelleAutor eang | 2013-08-17

  1. 10

    Folgende code funktioniert bei mir:

    #include <windows.h> 
#include <stdio.h> 

BOOL WINAPI consoleHandler(DWORD signal) {

    if (signal == CTRL_C_EVENT)
        printf("Ctrl-C handled\n"); //do cleanup

    return TRUE;
}

int main()
{
    running = TRUE;
    if (!SetConsoleCtrlHandler(consoleHandler, TRUE)) {
        printf("\nERROR: Could not set control handler"); 
        return 1;
    }

    while (1) { /* do work */ }

    return 0;
}

    InformationsquelleAutor lpapp

  2. 10

    Laut die Dokumentation, wenn der handler (die ist falsch erklärt, BTW) erhält eine CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT oder CTRL_SHUTDOWN_EVENT signal, der Prozess ist beendet, nachdem der handler beendet. Zu tun, was Sie versuchen sollen Sie zu bewegen, Ihre cleanup-code in den handler selbst.

    Es sieht aus wie mein Programm nicht empfangen diese Ereignisse, aber nur ein CTRL_C_EVENT. Getestet nur jetzt mit einem switch im my-handler-Funktion, und drücken Sie STRG+C in der Konsole.

    InformationsquelleAutor Remy Lebeau

  3. 9

    Je nach Ihren spezifischen Anforderungen Sie haben eine Reihe von Optionen. Wenn Sie wollen einfach zu ignorieren Strg+C können Sie anrufen SetConsoleCtrlHandler vorbei NULL als HandlerRoutine parameter:

    int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCtrlHandler(NULL, TRUE);

    //do work

    return 0;
}

    Diese entfernt alle signal-Handler. Zum beenden dieser Anwendung, die Sie haben zu implementieren benutzerdefinierte Logik, um zu bestimmen, Wann abgeschaltet.

    Wenn Sie möchten, behandeln Sie Strg+C haben Sie zwei Möglichkeiten: Legen Sie einen handler für das signal, oder übergeben Sie die Tastatur-Eingaben auf normale Tastatur-handling.

    Einrichtung eine Prozedur ist ähnlich wie der code oben, aber statt der übergabe NULL als der Hundeführer Sie bieten Ihre eigene Implementierung.

    #include <windows.h>
#include <stdio.h>

volatile bool isRunnung = true;

BOOL WINAPI HandlerRoutine(_In_ DWORD dwCtrlType) {
    switch (dwCtrlType)
    {
    case CTRL_C_EVENT:
        printf("[Ctrl]+C\n");
        isRunnung = false;
        //Signal is handled - don't pass it on to the next handler
        return TRUE;
    default:
        //Pass signal on to the next handler
        return FALSE;
    }
}


int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCtrlHandler(HandlerRoutine, TRUE);

    printf("Starting\n");
    while ( isRunnung ) {
        Sleep(0);
    }
    printf("Ending\n");

   return 0;
}

    Die Ausgabe dieses Programms ist:

    Starting
[Ctrl]+C
Ending

    Beachten Sie, dass die cleanup-code ausgeführt wird, unabhängig von der code innerhalb der main while-Schleife. Signal-Handler bilden eine verkettete Liste, wo die handler-Funktionen aufgerufen werden, die auf einen last-registriert, erste genannte basis, bis einer der Handler zurückgibt TRUE. Wenn keiner der Handler TRUE zurück, wird der default-handler aufgerufen wird. Der default-handler für eine Konsole Aufrufe ExitProcess bei der Verarbeitung von Strg+C.

    Wenn Sie verhindern möchten, dass eine Vorverarbeitung und behandeln Sie Strg+C als normale Tastatur Eingabe statt, wechselt man die Konsole durch den Aufruf SetConsoleMode.

    #include <windows.h>
#include <stdio.h>

int _tmain(int argc, _TCHAR* argv[])
{
    DWORD dwMode = 0x0;
    GetConsoleMode( GetStdHandle(STD_INPUT_HANDLE), &dwMode );
    //Remove ENABLE_PROCESSED_INPUT flag
    dwMode &= ~ENABLE_PROCESSED_INPUT;
    SetConsoleMode( GetStdHandle(STD_INPUT_HANDLE), dwMode );

    while ( true ) {
        //Ctrl+C can be read using ReadConsoleInput, etc.
    }

    return 0;
}

    Einmal die ENABLE_PROCESSED_INPUT flag entfernt Strg+C wird nicht mehr vom system verarbeitet und an die Konsole wie normale Tastatur-Eingaben. Es kann gelesen werden mit ReadConsoleInput oder ReadFile.

    Disclaimer: Die oben wurde getestet auf Windows 8 64bit, zusammengestellt für 32-und 64-bit -, Release-und Debug-Konfigurationen.

    InformationsquelleAutor IInspectable

Schreibe einen Kommentar