Warum ist der Speicher noch zugänglich, nachdem std :: map :: clear () aufgerufen wurde?

Beobachten ich seltsame Verhalten von std::map::clear(). Diese Methode nennen soll element der Destruktor aufgerufen, aber Speicher ist immer noch zugänglich, nach dem Aufruf von clear().

Beispiel:

struct A
{
  ~A() { x = 0; }
  int x;
};

int main( void )
{
  std::map< int, A * > my_map;
  A *a = new A();
  a->x = 5;
  my_map.insert( std::make_pair< int, *A >( 0, a ) );

  //addresses will be the same, will print 5
  std::cout << a << " " << my_map[0] << " " << my_map[0]->x << std::endl;

  my_map.clear();

  //will be 0
  std::cout << a->x << std::endl;

  return 0;
}

Die Frage ist, warum ist variabel a noch zugänglich, nachdem der Destruktor aufgerufen wurde, die von map::clear()? Brauche ich zu schreiben delete a; nach dem Aufruf my_map.clear() oder ist es sicher, überschreiben Sie den Inhalt a?

Vielen Dank im Voraus für Eure Hilfe,
sneg

InformationsquelleAutor der Frage sneg | 2009-02-20

c++stdmap

std::map nicht gelingt, die Erinnerung verweist der pointer-Werte - es ist bis zu Ihnen, es selbst zu tun. Wenn Sie nicht möchten, verwenden smart-Pointer, Sie können schreiben, ein Allzweck-freie & clear-Funktion wie folgt:

template <typename M> void FreeClear( M & amap ) 
    for ( typename M::iterator it = amap.begin(); it != amap.end(); ++it ) {
        delete it->second;
    }
    amap.clear();
}

Und Verwendung:

std::map< int, A * > my_map;
//populate
FreeClear( my_map )

;

InformationsquelleAutor der Antwort

20

Wenn Sie speichern Zeiger auf einer Karte (oder eine Liste oder etwas in der Art) SIE sind verantwortlich für das löschen den Zeiger, da die Karte nicht kennen, wenn Sie erstellt wurden, mit neuen, oder nicht. Die Funktion "löschen" nur ruft Destruktoren wenn Sie keine Zeiger verwenden.

Oh, und noch eins: der Aufruf eines destruktors (oder sogar der Aufruf von delete) bedeutet nicht, dass der Speicher kann nicht mehr zugegriffen werden. Es bedeutet nur, dass Sie werden Zugriff auf Müll, wenn Sie tun.

InformationsquelleAutor der Antwort Marc
4

Weil map.clear() Destruktor aufgerufen, der die Daten in die Karte, in deinem Fall, der Zeiger auf a. Und diese tut nichts.

Möchten Sie vielleicht einige Art smart pointer in der Karte, für die Speicher belegt durch a werden automatisch zurückgefordert.

BTW, warum stellst du die Vorlage Argumente im Aufruf an make_pair? Das Vorlage-argument Abzug sollte ziemlich gut zu tun hier.

InformationsquelleAutor der Antwort jpalecek
1

Wenn Sie frei ein Stück von heap-Speicher, dessen Inhalt nicht unwiderruflich gelöscht wird. Sie sind lediglich für die Zuweisung wieder. Natürlich sollten Sie den Speicher nicht zugänglich, da die Auswirkungen der Zugriff auf nicht zugewiesenen Speicher nicht definiert sind.

Tatsächlich verhindern, dass Zugriff auf eine Speicherseite geschieht auf einem niedrigeren Niveau, und std-Bibliotheken nicht.

Beim reservieren von Speicher mit new, müssen Sie es löschen sich selbst, es sei denn, Sie verwenden ein smart pointer.

InformationsquelleAutor der Antwort John Smith
0

Jeder container speichert Ihr Objekt Geben und Aufruf der entsprechenden Konstruktoren: interner code jeder Knoten könnte wie folgt Aussehen:
```
__NodePtr
{
    *next;
    __Ty    Val;
}
```
Wenn Sie reservieren, es passiert durch den Bau der val basiert auf geben und dann zu verlinken. Etwas ähnliches wie:
```
_Ty _Val = _Ty();
_Myhead = _Buynode();
_Construct_n(_Count, _Val);
```
Wenn Sie es löschen, ruft die entsprechenden Destruktoren.

Beim speichern Referenzen (Pointer) es wird nicht jeder Konstruktor-Aufruf, noch es zu zerstören.

InformationsquelleAutor der Antwort FL4SOF
0

Nachdem er in den letzten 2 Monaten Essen, schlafen und atmen Karten, habe ich eine Empfehlung. Lassen Sie die Karte zuweisen, die eigenen Daten, Wann immer möglich. Es ist viel sauberer, für genau die Art von Gründen, Sie sind Hervorhebung hier.

Es gibt auch einige subtile Vorteile, wenn man z.B. kopieren von Daten aus einer Datei oder socket zu der Karte, die Daten, die Speicherung der Daten vorhanden ist, sobald der Knoten vorhanden ist, weil, wenn die Karte Aufrufe von malloc() reservieren, die Knoten, die er reserviert Speicher für beide der Schlüssel und die Daten. (AKA map[key].erste und map[key].Sekunde)

Dies ermöglicht die Verwendung der Zuweisungs-operator anstelle von memcpy () und benötigt 1 Anruf weniger malloc () -, die Sie stellen.
```
IC_CDR CDR, *pThisCDRLeafData;  //a large struct{}

    while(1 == fread(CDR, sizeof(CDR), 1, fp))  {
    if(feof(fp)) {
        printf("\nfread() failure in %s at line %i", __FILE__, __LINE__);
    }
    cdrMap[CDR.iGUID] = CDR; //no need for a malloc() and memcpy() here    
    pThisCDRLeafData  = &cdrMap[CDR.iGUID]; //pointer to tree node's data
```
Ein paar Vorsichtsmaßnahmen zu beachten sind, hingewiesen hier.
1. NICHT rufen malloc() oder new in der Zeile des Codes fügt hinzu, dass die Knoten im Baum als Ihrem Aufruf malloc() gibt einen Zeiger VOR der Karte-Aufruf von malloc() reserviert einen Platz zu halten, der Rückkehr aus Ihrem malloc().
2. im Debug-Modus, erwarten, dass ähnliche Probleme, wenn Sie versuchen, free() Ihr Gedächtnis. Diese beiden scheinen, wie compiler-Problemen zu mir, aber zumindest im MSVC 2012, Sie existieren und sind ein ernstes problem.
3. geben Sie einige Gedanken, wie und wo zu "verankern" Ihre Karten. SPRICH: wo Sie deklariert sind. Wenn Sie nicht wollen, gehen aus dem Geltungsbereich versehen. die main{} ist immer sicher.
```
INT _tmain(INT argc, char* argv[])    {
IC_CDR      CDR, *pThisCDRLeafData=NULL;
CDR_MAP     cdrMap;
CUST_MAP    custMap;
KCI_MAP     kciMap;
```
4. Ich hatte sehr viel Glück, und freue mich sehr kritisch Karte zuordnen einer Struktur, wie es der Knoten der Daten, und dass struct "Anker" eine Karte. Während anonyme Strukturen sind aufgegeben worden, die von C++ (eine schreckliche, schreckliche Entscheidung, die rückgängig gemacht werden MUSS), Karten der 1. struct-member funktionieren genauso wie die anonymen Strukturen. Sehr glatt und sauber mit Größe null-Effekte. Übergeben Sie einen Zeiger auf das Blatt im Besitz struct, oder eine Kopie der struct-by-value in eine Funktion aufrufen, funktionieren beide sehr gut. Sehr zu empfehlen.
5. Sie abfangen können, die Werte zurückgeben .legen Sie um festzustellen, ob es gefunden eine vorhandene Knoten auf, Schlüssel, oder erstellt eine neue. (siehe #12 für code) Über den subskript-notation wird nicht zulassen, dass diese. Könnte es besser sein, sich auf .legen und kleben mit ihm, vor allem, weil der [] - notation funktioniert nicht mit multimaps. (es würde keinen Sinn machen, so zu tun, wie es nicht "ein" - Taste, sondern eine Reihe von Tasten mit dem gleichen Werte in einer multimap)
6. Sie können und sollten auch Falle gibt .löschen und .empty() (JA, es ist ärgerlich, dass einige dieser Dinge sind Funktionen, und müssen Sie die () - und einige, wie .löschen Sie, was nicht)
7. erhalten Sie sowohl den Schlüssel als Wert und den data-Wert für jede map-Knoten verwenden .ersten und .zweiten, welches alle Karten per Konvention verwenden, um den Schlüssel zurückzugeben und die Daten bzw.
8. sparen Sie sich eine RIESIGE Menge Verwirrung und eingeben, und verwenden Sie typedefs für Ihre Karten, wie so.
```
typedef map<ULLNG, IC_CDR>      CDR_MAP;    
typedef map<ULLNG, pIC_CDR>     CALL_MAP;   
typedef struct {
    CALL_MAP    callMap;
    ULNG        Knt;         
    DBL         BurnRateSec; 
    DBL         DeciCents;   
    ULLNG       tThen;       
    DBL         OldKCIKey;   
} CUST_SUM, *pCUST_SUM;
typedef map<ULNG,CUST_SUM>  CUST_MAP, CUST_MAP;  
typedef map<DBL,pCUST_SUM>  KCI_MAP;
```
9. pass Verweise auf Karten mit dem typedef und & - operator, wie in
  
  ULNG DestroyCustomer_callMap(CUST_SUM Summary, CDR_MAP& cdrMap, KCI_MAP& kciMap)
10. verwenden Sie die "auto" - Variablen Datentyp für Iteratoren. Der compiler herausfinden, von dem Typ angegeben, der rest der for () - Schleife, welche Art von Karte typedef zu verwenden. Es ist so sauber, es ist fast Magie!
  
  for(auto itr = Summary.callMap.begin(); itr!= Summary.callMap.end(); ++itr) {
11. definieren, einige manifest-Konstanten, um die Rückkehr aus .löschen und .empty() mehr sinnvoll.
  
  if(ERASE_SUCCESSFUL == cdrMap.erase (itr->second->iGUID)) {
12. gegeben, dass "intelligente Zeiger" sind wirklich einfach, um eine Referenz zu zählen, denken Sie daran, Sie können immer Ihre eigene Referenz-Zählung, die eine vermutlich ein sauberer und deutlicher. Kombinieren Sie dies mit #5 und #10 oben, können Sie schreiben einige nette clean code wie dieser.
```
#define Pear(x,y) std::make_pair(x,y) // some macro magic

auto res = pSumStruct->callMap.insert(Pear(pCDR->iGUID,pCDR));
if ( ! res.second ) {
    pCDR->RefKnt=2;
} else {
    pCDR->RefKnt=1;
    pSumStruct->Knt += 1;
}
```
13. verwenden einen Zeiger auf hängen auf einer Karte Knoten, ordnet alles für sich selbst, SPRICH: keine Benutzer-Zeiger zeigt auf Benutzer malloc()ed") Objekte, die gut funktioniert, ist möglicherweise effizienter, und, und verwendet werden, mutieren die Daten eines Knotens, ohne Nebenwirkungen, in meiner Erfahrung.
14. auf dem gleichen Thema, wie ein pointer verwendet werden, sehr wirksam zur Erhaltung der Zustand eines Knotens, wie in pThisCDRLeafData oben. Mit der Verabschiedung dieser auf eine Funktion, die mutiert/Veränderungen, die bestimmten Knoten Daten ist sauberer als bei der übergabe einer Referenz auf die Karte und den Schlüssel brauchte, um wieder zu den Knoten pThisCDRLeafData verweist.
15. Iteratoren sind keine Zauberei. Sie sind teuer und langsam, wie Sie die Navigation in der Karte, um Werte. Für eine map-holding eine million Werte, die Sie Lesen können, einen Knoten basierend auf einem Schlüssel-bei etwa 20 Millionen pro Sekunde. Mit Iteratoren ist es wohl ~ 1000 mal so langsam.
Ich denke, dass etwa deckt es für jetzt. Wird aktualisiert, wenn eine dieser änderungen oder zusätzliche Einblicke zu teilen. Ich bin besonders genießen mit dem STL durch C-code. SPRICH: nicht die Klasse im Blick und überall. Sie einfach keinen Sinn im Kontext arbeite ich in, und es ist nicht ein Problem. Viel Glück.

InformationsquelleAutor der Antwort user2548100

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.