Löschen Mitglied der Struktur auf Heap nach Std :: move()

Question

Ich bin derzeit Refactoring und ändern Sie den vorhandenen Code in C++ 11 und ich frage mich, ob Speicherleck haben. Mein Code hat eine Struktur mit einer std::vector darin sowie eine Methode zu shrink() diesen Vektor bis auf seine negativen Elemente.

struct mystruct_t { 

    int other_stuff; 

    std::vector <int> loc; 

    // Adds elements to loc vector 
    void add(int pos){ 
     loc.push_back(pos); 
    } 

    // Shrink the list 
    void shrink() { 
     std::vector<int> tmp; 
     for (unsigned int i = 0; i < loc.size(); ++i) { 
      if (loc[i] < 0) tmp.push_back (loc[i]); 
     } 
     loc = tmp; 
     std::vector<int>(loc).swap (loc); 
    } 

    mystruct_t(): otherstuff(0) {}; 
}; 

In einer anderen Funktion erstelle ich eine neue Instanz dieser Struktur wie folgt aus:

mystruct_t c = new mystruct_t; 
c->add(2); 
c->add(3); 
... 

Und später rufe ich die shrink() Methode dieser Struktur.

c->shrink() 

Jetzt bin ich nicht sicher, was mit dem „alten“ loc Vektor nach der Schrumpffunktion passiert? Wird es automatisch zerstört oder muss ich von Hand zerstört werden? Und wenn das später wäre, wie würde ich das tun?

Ich habe auch versucht, um es durch eine Änderung shrink() mehr C++ 11-Stil zu ändern:

void shrink(){   
    std::vector<int> tmp; 
    for (auto &currLoc : loc) { 
     if (currLoc < 0) tmp.push_back (currLoc); 
    } 
    loc = std::move(tmp); 
} 

Aber die Frage bleibt gleich, was mit dem „alten“ loc Vektor geschieht zusätzlich zu erhöhen dies scheint die Speicherbelegung. Ich bin neu in C++ 11 und nicht sicher, ob ich das Konzept völlig falsch verstehe?

Answer 1

Jetzt bin ich nicht sicher, was passiert mit dem "alten" Lok-Vektor nach der Schrumpffunktion?

Es gibt keine "alten" loc Vektor. Während der Lebensdauer eines Objekts mystruct_t hat es genau einen Mitgliedsvektor loc. Du bekommst nie ein neues Mitglied oder wirfst ein altes weg.

Wenn Sie kopieren zuweisen an das Mitglied (loc = tmp;), wird der Puffer - im Vektor enthalten - erneuert. Der Vektor besitzt den Puffer, und der Vektor sorgt dafür, dass er ordnungsgemäß zerstört wird. Gleiches gilt, wenn Sie in der C++ 11-Version den Befehl zuweisen.

Wird es automatisch

zerstört, wenn man auf den Speicher durch den Vektor zugeordnet, dann ja.

oder muss ich von Hand zerstört werden?

Sie müssen nur mit der Hand zerstören, was auch immer Sie von Hand erstellt haben. Sie haben new nicht angerufen, also rufen Sie nicht delete an.

---

zusätzlich scheint dies die Speichernutzung zu erhöhen.

Ihre C++ 11-Version fehlt der "Schrumpf zu passen" Teil des Originals (std::vector<int>(loc).swap (loc);).In C++ 11 Sie tun können:

loc = std::move(tmp); 
loc.shrink_to_fit(); 

In der Pre C++ 11-Version können loszuwerden, die Kopie Zuordnung erhalten und einfach die temporäre Konstruktion von tmp, und tauschen sie mit loc:

std::vector<int> tmp; 
// copy the objects you want 
std::vector<int>(tmp).swap(loc); 

Answer 2

Operation std::move nur Werte werfen, so dass es keine zusätzliche Speicherauslastung gibt.

Answer 3

Wenn Sie den std::move Compiler verwenden, wird head address des ersten Objekts entfernt, und nur Speicher zweiten Objekt neu zuweisen. So ist es sehr schnelle Operation, usw., nur die head der Daten zu ändern.