Ich habe einen Thread, der folgendermassen aussieht:

static UINT threadfunktion(LPVOID pvoid)
{
CMonteCarloOberflcheDlg *m_dP12 = (CMonteCarloOberflcheDlg*)pvoid;
m_dP12->m_dP12 = main();

AfxEndThread(0);
return 0;
}

Die main()-Methode liefert einen double-Wert zurück, der der Member-Variablen m_dP12 übergeben wird. Soweit funktioniert alles i.O..

Wenn der Thread geschlossen werden soll (AfxEndThread(0)), kommt es aufgrund der main()-Methode zu einer Fehlermeldung:

"Expression: pHead->nBlockUse == nBlockUse".

Nach Ausschließen der möglichen Fehlerquellen, bin ich zum Schluss gekommen, dass die Fehlermeldung aufgrund eines "ofstream" innerhalb der main()-Methode auftritt:

ofstream OutFile(OutputFile,ios::app); //Daten anhängen!!!
OutFile<<Particle<<"\t"<<P12<<"\t"<<InletCounter<<"\t"<<OutletCounter<<"\t"<<Paverage<<"\t"<<Collision<<"\n";
OutFile.close();.

Wenn ich die Zeile:
OutFile<<Particle<<"\t"<<P12<<"\t"<<InletCounter<<"\t"<<OutletCounter<<"\t"<<Paverage<<"\t"<<Collision<<"\n";
im Programm auskommentiere, erscheint die Fehlermeldung nicht mehr.

Hat jemand Ahnung, wieso das zustande kommt und wie ich mein Problem lösen könnte?

Vielleicht kann euch dies weiterhelfen:

/* Error if freeing incorrect memory type */
_ASSERTE(pHead->nBlockUse == nBlockUse);

Vielen Dank im Voraus für die Hilfe!!

Die main()-Methode liefert einen double-Wert zurück, der der Member-Variablen m_dP12 übergeben wird. Soweit funktioniert alles i.O..

Das könnte ein Problem sein - üblicherweise ist main() der Haupteinstiegspunkt des Programms, und die Funktion sollte man nicht von irgendwo im Programm heraus aufrufen.

(PS: Von wo aus und mit welchem Parameter startest du denn die Thread-Funktion?)

Wenn ich die Zeile:
OutFile<<Particle<<"\t"<<P12<<"\t"<<InletCounter<<"\t"<<OutletCounter<<"\t"<<Paverage<<"\t"<<Collision<<"\n";
im Programm auskommentiere, erscheint die Fehlermeldung nicht mehr.

Dann kommentier doch mal einzelne Teile der Ausgabe aus, dann weißt du, welcher davon den Fehler verursacht.

OutFile<<"\n";

in der Ausgabe steht, kommt es zur Fehlermeldung.

Ansonsten wird in der Ausgabedatei OutputFile alles richtig gespeichert und anschließend die main()-Methode fehlerfrei verlassen.

Das Problemm tritt erst dann auf, der ?Speicher? des Threads gelöscht werden soll (AfxEndThread(0)).

(PS: Von wo aus und mit welchem Parameter startest du denn die Thread-Funktion?)

Ich starte die Thread-Funktion von einem Dlg-Dialogfeld aus und übergebe die Parameter des Dialogfeldes:

pMeinFaden =AfxBeginThread(threadfunktion,(LPVOID) this,THREAD_PRIORITY_NORMAL); .

Das ist der Quell-Code, wo die Fehlermeldung auftritt:

/*
             * Free up the _tiddata structure & its malloc-ed buffers.
             */

            if ( ptd ) {
                if(ptd->_errmsg)
                    _free_crt((void *)ptd->_errmsg);

                if(ptd->_namebuf0)
                    _free_crt((void *)ptd->_namebuf0);

                if(ptd->_namebuf1)
                    _free_crt((void *)ptd->_namebuf1);

                if(ptd->_asctimebuf)
                    _free_crt((void *)ptd->_asctimebuf);

                if(ptd->_gmtimebuf)
                    _free_crt((void *)ptd->_gmtimebuf);

                if(ptd->_cvtbuf)
                    _free_crt((void *)ptd->_cvtbuf);

                                if (ptd->_pxcptacttab != _XcptActTab)
                                        _free_crt((void *)ptd->_pxcptacttab);

                _free_crt((void *)ptd);
            }

            /*
             * Zero out the one pointer to the per-thread data block
             */

Die eigentliche Fehlermeldung wird genau bei dieser Zeile ausgelöst:

if(ptd->_cvtbuf)
                    _free_crt((void *)ptd->_cvtbuf);

Hat das etwas mit der OutputFile-Datei zu tun:

ofstream OutFile(OutputFile,ios::app); //Daten anhängen!!! 
OutFile<<Particle<<"\t"<<P12<<"\t"<<InletCounter<<"\t"<<OutletCounter<<"\t"<<Paverage<<"\t"<<Collision<<"\n"; 
OutFile.close();

Und zwar hat "elise" erwähnt:

du greifst auf einen speicherbereich zu, der nicht mehr existiert oder noch nie existiert hat.