folgendes Problem.
Ich initialisiere mit new ein Array

LPOLESTR lpMicGuid = new WCHAR[39];

und arbeite damit.
Nach dem ich es nicht mehr brauche will ich es mit delete löschen
und bekomme vom compiler gesagt:
Windows has triggered a breakpoint in DvVoipClient.exe.

This may be due to a corruption of the heap, and indicates a bug in DvVoipClient.exe or any of the DLLs it has loaded.

The output window may have more diagnostic information

Wenn ich aber kein Delete aus führe wird mir im Debug Modus ein
Speicherleck an dieser stelle angezeigt.

Wie befreie ich denn den reservierten Speicher nun??

Gruß
Crazy

Hier der gesamte Code

LPOLESTR lpMicGuid = new WCHAR[39];
lpMicGuid = A2OLE(pVal);
GUID guid;
CLSIDFromString(lpMicGuid, &guid);
m_lpGuidMic = (LPGUID)malloc(sizeof(GUID));
memcpy(m_lpGuidMic, &guid, sizeof(guid));
if(lpMicGuid != NULL)
{
     delete lpMicGuid;
     lpMicGuid = NULL;
}

Warum verwendest du eigentlich abwechselnd new und malloc? Kann man zwar machen, aber du könntest deinen malloc-Aufruf genausogut durch new ersetzen und somit einheitlich bleiben...

LPOLESTR lpMicGuid = new WCHAR[39];
lpMicGuid = A2OLE(pVal);

Und hier ist der mit new geholte Speicher schon nicht mehr erreichbar, weil der Zeiger nun auf den Rückgabewert von A2OLE zeigt.

// LPOLESTR lpMicGuid = new WCHAR[39];
// lpMicGuid = A2OLE(pVal); // falsch, überschreibt den Zeiger "lpMicGuid", der somit nichtmehr auf den neu angeforderten Bereich zeigt,
                            // sondern auf einen Temporären Bereich der vom Makro A2OLE irgendwie herbeigezabuert wird
// besser & einfacher:
std::wstring micGuidString = A2OLE(pVal);

// wieso so kompliziert?
// GUID guid;
// CLSIDFromString(lpMicGuid, &guid);
// m_lpGuidMic = (LPGUID)malloc(sizeof(GUID)); // wieso malloc?
// memcpy(m_lpGuidMic, &guid, sizeof(guid));
m_lpGuidMic = new GUID; // muss dann natürlich auch mit delete wieder freigegeben werden
CLSIDFromString(micGuidString.c_str(), m_lpGuidMic);

// fertig.

// brauchen wir jetzt nimmer, std::wstring räumt sich selbst auf
// if(lpMicGuid != NULL)
// {
//      delete lpMicGuid;
//      lpMicGuid = NULL;
// }

Und... wieso muss m_lpGuidMic überhaupt ein Zeiger sein? Ein einfaches Nicht-Zeiger-Member ("GUID m_micGuid;") würde reichen. Oder ggf. ein boost::scoped_ptr<GUID> oder std::auto_ptr<GUID>.

@_matze: Hast du schon recht. Die Abwechslung zwischen new und malloc kommt vom Copy and Paste:D:D.
lalala

ich habe eine Thread, dem ich über eine Struktur einen Zeiger auf eine Klasse übergebe.
Z.B. so

MyClass myClass = new MyClass();
TPARAM tParam;
tParam.CMyClass = myClass;
hThread = CreateThread(NULL, 0, &MyThread, &tParam, 0, &dwThreadId);

Und hier der Thread
DWORD WINAPI CMyClass::MyThread(PVOID pParam)
{
TPARAM* tParam = (TPARAM*)pParam;
CMyClass* myClass = pParam->myClass;
}

Wie bereinige ich hier am Ende am besten meinen Speicher?

oder

delete pParam->myClass;

Dann kann ich aber nach Abarbeitung des Threads nicht mehr mit der Instanz der Klasse weiterarbeiten.

Du hattest auch nicht erwähnt, dass du das musst.
Stell doch erst mal die Anforderungen auf, anstatt die Helfer vor die Wand laufen zu lassen.

@_matze: Das hab ich auch gedacht, aber irgendwo bleibt noch ein Speicherleck, in dem der Inhalt ist, welcher in dem Thread generiert wird.
Daher habe ich angenommen dass innerhalb des Threads noch etwas nicht korrekt freigegeben wird.