ich möchte ein for-Schleife mit einem Button abbrechen, nur funktioniert das leider nicht...

Dass passiert bei Klick auf den Button:

void MyWriter::OnStop() 
{
	StopDataIO = true;
}

So sieht die For-Schleife aus:

for (i = 1; i <= BufferAnzahl; i++)
		{
			DoEvents();
			// DataIO wird abgebrochen, wenn der Stop-Button gedrückt wurde
			// oder wenn 10 Fehler gefunden wurden und das Häkchen dafür gesetzt ist, dann abzubrechen
			if (StopDataIO == true || (StopAfterErrors && FoundErrors >= 10))
			{
				// StatusBar auf 100% setzen
				m_ProgressBar.SetPos(BufferAnzahl);
				// Schleife abbrechen
				break;
			}		
			Start();
			m_ProgressBar.SetPos(i);
		}

Mit diesem DoEvents möchte ich eigentlich alle offenen Messages abarbeiten:

void MyWriter::DoEvents()   // Evtl. Anstehende Events ausführen
{
    MSG msg;                    // Message Variable

    while (PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) {    // Solange Messages vorhanden

        if (!AfxGetThread()->PumpMessage()) return;     
    }
}

So. Leider passiert bei Klick auf den Stopp-Button garnichts, die Schleife wird nicht unterbrochen. Er kriegt das wohl garnicht mit, das man auf den Stopp-Button klickt. Nach Abarbeitung der Schleife wird die Variable dann auch hübsch auf true gesetzt, nur dann ist es zu spät...

Ich kopiere am besten mal ne Menge Quelltext

void MyWriter::OnStart() 
{
	// Startbutton verstecken, Stopbutton zeigen
	m_StartButton->ShowWindow(false);
	m_StopButton->ShowWindow(true);	

	UpdateData(FALSE);

	// Event RunEvent zeigt an, ob DataIO läuft
	DataIORunEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
	if (DataIORunEvent != NULL)
	{		
		UpdateData(false);
		DataIOMutex = CreateMutex( NULL, TRUE, NULL );				// Mutex für den DataIO Thread

		// Thread für DataIO starten, this übergibt die instanz von MyWriter, die _beginthread aufruft
		// Wichtig, weil Thread auch Memeber-Variablen der Instanz verändern soll
		// dafür wird in eine nicht-Member Funktion ThreadTransferDataIO() gesprungen, die einen zeiger auf die Insatanz erstellt
		// Über diesen Zeiger werden dann die Member-Variablen und Funktionen aufgerufen

		_beginthread(ThreadTransferDataIO, 0, this);
		do {
			WaitForSingleObject( DataIOMutex, INFINITE );
			ReleaseMutex( DataIOMutex );
		} while ( WaitForSingleObject( DataIORunEvent, 75L ) == WAIT_TIMEOUT );

		UpdateData(FALSE);
	}

	else
	{
		m_TextUpdate += "FEHLER: Konnte kein Terminal-Event erstellen! \r\n";
		UpdateData(FALSE);

	}

	// Start Button wieder anzeigen, Stop-Button verstecken
	m_StartButton->ShowWindow(true);
	m_StopButton->ShowWindow(false);

	UpdateData(FALSE);
}

// -------------------------- DATA-IO -------------------------- //

void __cdecl ThreadTransferDataIO(void *_this)
{
	MyWriter* ThisWriter = (MyWriter*) _this;
	ThisWriter->SwitchModus();
	ThisWriter = NULL;
}

void MyWriter::SwitchModus(void)
{		
	// Ermittlung der aktuellen Systemzeit zur Restzeitmessung
	int StartZeit = clock(); 
	int RestZeit = 0;

// HIER STÜRZT ER AB 
	m_ClearLog.EnableWindow(true);			// ClearLog Button aktivieren
	int i = 0;
	int z = 0;	// Zähler für die Statusleiste für Modus 3

	// Countdown in ms übergeben
	LARGE_INTEGER endTime = { Countdown*1000 };

	switch (Modus)
	{

	case 0:

		// BufferSize ist fest.
		// DataIO wird beendet, wenn die Anzahl der Pakete, die gesendet werden sollen, abgearbeitet ist.

		// Restzeit-Textausgabe wird auf invisible gesetzt
		m_RestzeitControl.ShowWindow(false);

		// ProgressBar wird auf visible gesetzt
// HIER STÜRZT ER AB 
		this->m_ProgressBar.ShowWindow(true);	

		// Progressbar konfigurieren
		// SetRange32 erwartet 2 Integer, die die untere bzw obere Grenze der Progressbar darstellen
// HIER STÜRZT ER AB 
	m_ProgressBar.SetRange32(1,BufferAnzahl);

		m_TextUpdate += "-------------------------------------------------------------------------------------------------- \r\n";
		m_TextUpdate += "BufferSize: " + IntToCString(BufferSize) + " Bytes, Anzahl der Durchläufe: " + IntToCString(BufferAnzahl) + ".\r\n";
		m_TextUpdate += "-------------------------------------------------------------------------------------------------- \r\n";

		DoEvents();

		for (i = 1; i <= BufferAnzahl; i++)
		{
			m_TextUpdate += "\r\nDurchlauf " + IntToCString(i) + "...";

			// DataIO wird abgebrochen, wenn der Stop-Button gedrückt wurde
			// oder wenn 10 Fehler gefunden wurden und das Häkchen dafür gesetzt ist, dann abzubrechen
			if (StopDataIO == true || (StopAfterErrors && FoundErrors >= 10))
			{
				// StatusBar auf 100% setzen
				m_ProgressBar.SetPos(BufferAnzahl);
				// Schleife abbrechen
				break;
			}		
			// DataIO starten
			DataIO();

			DoEvents();

//			m_ProgressBar.SetPos(i);
		}

		break;			

// ......

PS: Vielleicht ist die Arbeit mit Timern auch einfacher für dich - OnStart() macht alle Vorbereitungsarbeiten und setzt einen Timer mit recht kurzem Intervall, in der zugehörigen OnTimer()-Methode führst du jeweils einen Schleifendurchlauf durch (und wenn die Abbruchbedingung zutrifft, killst du den Timer).

Was er sagt ist richtig und so wird es auch gemacht aber mann kann es auch einfacher machen quick and dirty ....
Du machst Dir einfach einen globalen Pointer Deiner Anwendung und in der OnInit() setzt Du diesen auf this. In Deinem Thread kannst Du diesen dann Ansprechen und natürlich eben so Deine Controls oder Du definierst Dir eine Struktur in der der this Zeiger enthalten ist und benutzt diese dann als Aufrufparameter in Deinem Thread ....

Böse, ganz ganz böse

m_Abort =false;

for(int i=0; i< XXX && !dlg.Abort(); i++){

}
//////////////////////////////////////////////////////////////////
// Abort: Abbruch funktion Abbruchbedingung
//////////////////////////////////////////////////////////////////
BOOL CDlgXXXX::Abort() {

    MSG msg;
    while (::PeekMessage(&msg, NULL, 
        NULL, NULL, PM_NOREMOVE)) {
        AfxGetThread()->PumpMessage();
    }
    return m_bAbort;
}

bei mir gehts so auch ohne thread

in einem anderen forum wird einem, wenn man sowas wie schleife abbrechen oder fortschrittsanzeige fragt, einen fast schon copy&paste tauglich ein pointer vorgekaut. mit dem kann man mit geringesten aufwand seine anwendung multithreading fähig machen kann.

PS: Und bei WinAPI-Objekten (d.h. der Dialog und die darauf enthaltenen Items) kommt noch dazu, daß nur der Eigentümer-Thread darauf zugreifen darf, sonst ist Ärger vorprogrammiert.