Zuerst mal ein Stück Code:

bool CMyClass::SaveData(long id, void* myStruct, int sizeMyStruct)
{	
    CSingleLock lock(&m_Section, false);
    CByteArray *pArchive; // CBA-Pointer für Speicherzugriff auf Element in Map

    ...

    lock.Lock();
    m_Map.SetAt(id, new CByteArray); // neues CBA in Map anlegen
    m_Map.Lookup(id, pArchive);      // neues CBA dem Pointer zuweisen
    pArchive->SetSize(sizeMyStruct); // Größe für neues CBA setzen
    if(!memcpy(pArchive->GetData(),myStruct,sizeMyStruct)) // Inhalt aus Struktur ins CBA kopieren
        return false; // falls etwas schief läuft 
    lock.Unlock();

    ...

    return true;
}

Macht es nun Sinn, Zeilen 11+12 aus Performancegründen vom Locking auszunehmen und die Map wieder freizugeben? Oder wär das keine gute Idee?

Hinweis: Es kann nicht passieren, dass genau dieser Eintrag überschrieben wird, denn jedes Objekt, das in die Map in MyClass (= Singleton) schreiben will, hat seinen eigenen Key für die Map, allerdings könnten andere Objekte zu dem Zeitpunkt an andere Stellen der Map schreiben.

Und inwiefern arbeitet die Map? Ich weiß ja nicht, ob dann vielleicht gerade durch neue Einträge möglicherweise intern gerade die Pointer und Speicherbereiche vom BS umgeschaufelt werden. Oder kann sowas nicht passieren? In der MSDN steht zumindest, dass CMap nicht threadsicher ist, daher würde ich wohl fürs Einschließen von Zeilen 11+12 ins Locking plädieren.

Wie seht ihr das?

Davon abgesehen macht man das normal eher so:

bool CMyClass::SaveData(long id, void* myStruct, int sizeMyStruct)
{    
    std::auto_ptr<CByteArray> pArchive(new CByteArray);

    ...

    pArchive->SetSize(sizeMyStruct);
    memcpy(pArchive->GetData(),myStruct,sizeMyStruct);

    {
       CSingleLock lock(&m_Section, true);
       m_Map.SetAt(id, pArchive.release());
    }

    ...

    return true;
}

Der auto_ptr geht aber komischerweise nicht (der erzählt mir, auto_ptr wäre kein Member vom std, kann aber eigentlich nicht sein *schulterzuck*). Aber den brauch ich doch auch nicht wirklich oder? Weil erstens brauch ich mein pArchive noch mehrmals in meiner Funktion und zweitens wird der eh zum Ende der Methode wieder gelöscht oder nicht?

Der auto_ptr geht aber komischerweise nicht (der erzählt mir, auto_ptr wäre kein Member vom std, kann aber eigentlich nicht sein *schulterzuck*).

#include <memory>

Aber den brauch ich doch auch nicht wirklich oder?

Doch, denn auto_ptr wäre Exception-Save, dein manuelles delete nicht.

bis bald
akari

bool CMyClass::SaveData(long id, void* myStruct, int sizeMyStruct)
{    
    std::auto_ptr<CByteArray> archiveGuard(new CByteArray);
    CByteArray* pArchive(archiveGuard.get());

    ...

    pArchive->SetSize(sizeMyStruct);
    memcpy(pArchive->GetData(),myStruct,sizeMyStruct);

    {
       CSingleLock lock(&m_Section, true);
       m_Map.SetAt(id, pArchive);
       archiveGuard.release(); // ownership wurde an m_Map übertragen
    }

    ...
    pArchive->... // geht hier dann auch noch

    return true;
}

Genauer genommen war die erste Variante sogar falsch -- wenn aus SetAt eine Exception fliegt wäre pArchive auch nichtmehr freigegeben worden, und wäre auch nicht in m_Map drinnen -> Leak
Sorry, mein Fehler!

Baust du auf, reißt du nieder, hast du Arbeit immer wieder

Aber das wird wahrscheinlich nix am Problem ändern, werd mich dann auch mal um den auto_ptr kümmern