Jo :)

also ich hätte 2 fragen.

1.
Wenn man sein windows runterfäht werden ja bekanntlich alle laufenden Programme beendet.

ist es möglich das mein programm, erkennt das es beendet werden soll und schnell noch eine Funktion aufruft, bevor es abgewürgt wird ?

oder besser das es schon frühzeitug erkennt das der Pc am runterfahren is und dann schon schnell ne funktion aufruft ?

2.
Wie ist es möglich das mein programm mehrere dinge gleichzeitig macht....

z.b. ein CS server kann ja nicht die rückmeldung von einem Clienten abwarten, bis er mit dem nächsten cleint weitermacht, sonst hätten ja alle spieler den gleichen ping (und auch einen übelst hohen xD)....

ich hab mich noch nie mit (falls es das überhaupt sein sollte) THREADS beschäftigt....

wie stell ich sowas an ? ._.

1. Windows sendet deinem Programm die Messages WM_QUERYENDSESSION und WM_ENDSESSION, bevor es runterfährt. Wenn man auf WM_QUERYENDSESSION passen reagiert, kann man das Runterfahren auch abbrechen.

2. Das geht mit Threads. Wie du mit Threads umgehts hängt vom Framework ab: WinAPI, MFC, Boost, Qt, wxWidgets, ...

Mit Threads handelt man sich allerdings auch Probleme ein, z.B. Deadlocks und muss sich Gedanken um Sachen wie kritischer Abschnitte machen.

Wenn du dich noch nicht mit Threads beschäftigt hast liest du am besten erstmal grundlegendes wie: http://de.wikipedia.org/wiki/Thread_(Informatik)

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

Windows sendet deinem Programm die Messages WM_QUERYENDSESSION und WM_ENDSESSION, bevor es runterfährt. Wenn man auf WM_QUERYENDSESSION passen reagiert, kann man das Runterfahren auch abbrechen.

wie kann ich auf diese nachricht reagieren ?

mach ich da ne neue (spezielle) funktion ? oder wie ? :/

unter win32 würdest du diese message im vom dir registrierten winproc abfangen und entsprechend das machen was du so vorhast. Aber so wie du die frage stellst wäre es erstmal interessant zu wissen was du für ein framework benutzt, was du vorhast etc pp

There is nothing wrong with high standards. It's your problem that you don't meet them.
If you think it's simple, then you have misunderstood the problem.
When a customer says "nothing has changed", assume they're lying.

genau... win32 consolen anwendung :) (WinAPI)

kannst du mal nen kleinen beispielcode geben wie ich das genau mache?

ach und zu den threads:

gegeben sei folgendes programm:
Quellcode:#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <iostream>
using namespace std;

#define MAXTHREADS 2

bool t1run = true;
bool t2run = true;


DWORD WINAPI Thread1(LPVOID data)
{
    while(t1run==true)
    {
        if(t1run==true)    {cout << "Message from: THREAD 1\n"; Sleep(100);}
        else            {return 0;}
    }
}

DWORD WINAPI Thread2(LPVOID data)
{
    while(t2run==true)
    {
        if(t2run==true)    {cout << "Message from: THREAD 2\n"; Sleep(100);}
        else            {return 0;}
    }
}


void main(void)
{
    HANDLE hThread[MAXTHREADS];
    DWORD  dwThreadID[MAXTHREADS];

    cout << "Alle Threads starten..." << endl;

    // Alle Threads starten
    for (int index=0; index<MAXTHREADS; index++)
    {
        hThread[index] = CreateThread(NULL,                        // Sicherheitsinfos
                                                0,                            // Größe des Stack
                                               Thread1,                // Threadfunktion
                                                (LPVOID)index,            // 32-bit paramter der Threadfunktion übergeben wird
                                                0,                            // Creation Flags, 0=sofort starten.
                                                &dwThreadID[index]);    // Id speichern

                hThread[index] = CreateThread(NULL,        
                                                0,    
                                               Thread2,    
                                                (LPVOID)index,    
                                                0,    
                                                &dwThreadID[index]);
    }







    // Auf die Threads warten, bis sie fertig sind
    WaitForMultipleObjects(MAXTHREADS,            // Anzahl der Threads, auf die gewartete werden muss
                                    hThread,    // Handles der Threads
                                    TRUE,        // Für alle warten?
                                    5000);        // Wie lange soll gewartet werden, INFINITE = unendlich lange

    




    for (int index=0; index<2; index++)
        CloseHandle(hThread[index]);

    t1run = false;
    t2run = false;

    printf("\nAlle Threads beendet. :D \n");


    while(1)
    {
        printf("\nSchleife erreicht!!\n");
        Sleep(50);
    }


} ist das programm soweit richitg? (ich mein ned Kompilier fehler^^)
also erstellt man so threads ?
oder giebt es da ne bessere möglichkeit ?

und

wie beendet man threads? so ich ich es gemacht hab (mit if und while abfragen) ?

oder macht man das eigentlich anders?

Tja, ohne die Frameworkangabe wird das nachwievor unbeantwortet bleiben (siehe #001, Punkt 2).
Also Win32 API...

K:R-I)Z++
"CSS ist cascading style sheets. Und nicht so'n Ranzspiel." - dp
In memory of Voice († 2005/03/30)

So wie du Threads beendest ist es richtig, der Thread muss sich selbst beenden, in dem du ihm das signalisierts. Du kannst sie zwar mit 'BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);' abwürgen, aber dann wird der Thread an einer unbestimmten Stelle abgewürgt. Was nicht gut ist. Deine Thread tun da jetzt nichts kritisches, aber wenn sie komplexere Sachen tun würden, könnte das sehr schlecht sein, wenn sie einfach mitten drin abgewürgt werden.

Das mit den Messages von Windows ist hier so eine Sache. Dafür muss dein Porgramm einen Messageloop haben, siehe hier wie man sowas macht: MSDN: Using Messages and Message Queues

Grundsätzlich braucht man für sowas ein Fenster, auch wenn dieses unsichtbar ist, da Messages immer nur an Fenster gesendet werden.

Edit:
Quellcode:// Alle Threads starten
for (int index=0; index<MAXTHREADS; index++)
{
    hThread[index] = CreateThread(NULL, 0, Thread1, (LPVOID)index, 0, &dwThreadID[index]);
    hThread[index] = CreateThread(NULL, 0, Thread2, (LPVOID)index, 0, &dwThreadID[index]);
} Das da ist aber kaputt. MAXTHREADS ist 2, also erzeugts du Instanzen von Thread1 und Thread2 jeweils 2 mal. Das führt dazu, dass du 4 Threads hast, aber nur die Handle von 2 davon, sodas du eigentlich nur auf 2 der 4 Threads wartest. Nur durch Zufall funktioniert das ganze doch, da die beiden anderen Thread durch t1run/t2run auch zum Beenden veranlasst werden, auch wenn du nicht auf sie wartest.

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

Ok, damit wären alle fragen geklärt

vielen dank an alle :D

*

uhmm ich hätt doch noch ne frage.... wie starte ich den thread wieder ?

und wie mach mach ich eine "Pause funktion" so das der thread anhält und und bei
z.B. t1resume(); wieder da weitermacht wo er aufgehört hat ?

Mit DWORD ResumeThread(HANDLE hThread); und DWORD SuspendThread(HANDLE hThread); ginge das, aber das ist wie TerminateThread zu betrachten, es hält den Thread in einem unbestimmten Zustand an.

Besser ist es das per Event (MSDN: Using Event Objects) zu machen. Hier mal ein Codesnippet dazu.

Quellcode:HANDLE hResumeEvent;
bool bShouldSuspend = false;
bool bShouldExit = false;

DWORD ThreadProc(LPVOID data) {
    while (!bShouldExit) {
        if (bShouldSuspend) {
            WaitForSingleObject(hResumeEvent, INFINITE);
            bShouldSuspend = false;
        }
        
        // irgendwas machen
    }
}

void main() {
    hResumeEvent = CreateEvent(NULL, false, false, "ResumeEvent");
    
    // thread staten ...
    
    bShouldSuspend = true; // thread soll anhalten
    
    // ...
    
    SetEvent(hResumeEvent); // thread soll weiterlaufen
    
    // ...
    
    bShouldExit = true;
    
    // hier fehlt noch code zum aufräumen wie CloseHandle(hResumeEvent);
} Hierbei ist zu beachten, dass ein Thread der gerade suspended ist und auf das ResumeEvent wartet erstmal resumed werden muss bevor er sich beenden kann.

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way