Przenoszenie obiektów z jednego unordered_map do innego kontenera

Question

Moje pytanie dotyczy bezpieczeństwa. Szukałem cplusplus.com i cppreference.com i wydaje się, że brakuje im bezpieczeństwa iteratora podczas std :: move. W szczególności: czy można bezpiecznie wywoływać std :: unordered_map :: erase (iterator) z iteratorem, którego obiekt został przeniesiony? Przykładowy kod: (?)

#include <unordered_map> 
#include <string> 
#include <vector> 
#include <iostream> 
#include <memory> 

class A { 
public: 
    A() : name("default ctored"), value(-1) {} 
    A(const std::string& name, int value) : name(name), value(value) { } 
    std::string name; 
    int value; 
}; 
typedef std::shared_ptr<const A> ConstAPtr; 

int main(int argc, char **argv) { 
    // containers keyed by shared_ptr are keyed by the raw pointer address 
    std::unordered_map<ConstAPtr, int> valued_objects; 

    for (int i = 0; i < 10; ++i) { 
     // creates 5 objects named "name 0", and 5 named "name 1" 
     std::string name("name "); 
     name += std::to_string(i % 2); 

     valued_objects[std::make_shared<A>(std::move(name), i)] = i * 5; 
    } 

    // Later somewhere else we need to transform the map to be keyed differently 
    // while retaining the values for each object 

    typedef std::pair<ConstAPtr, int> ObjValue; 

    std::unordered_map<std::string, std::vector<ObjValue> > named_objects; 

    std::cout << "moving..." << std::endl; 

    // No increment since we're using .erase() and don't want to skip objects. 
    for (auto it = valued_objects.begin(); it != valued_objects.end();) { 
     std::cout << it->first->name << "\t" << it->first.value << "\t" << it->second << std::endl; 

     // Get named_vec. 
     std::vector<ObjValue>& v = named_objects[it->first->name]; 
     // move object :: IS THIS SAFE?? 
     v.push_back(std::move(*it)); 

     // And then... is this also safe??? 
     it = valued_objects.erase(it); 
    } 

    std::cout << "checking... " << named_objects.size() << std::endl; 
    for (auto it = named_objects.begin(); it != named_objects.end(); ++it) { 
     std::cout << it->first << " (" << it->second.size() << ")" << std::endl; 
     for (auto pair : it->second) { 
      std::cout << "\t" << pair.first->name << "\t" << pair.first->value << "\t" << pair.second << std::endl; 
     } 
    } 

    std::cout << "double check... " << valued_objects.size() << std::endl; 
    for (auto it : valued_objects) { 
     std::cout << it.first->name << " (" << it.second << ")" << std::endl; 
    } 

    return 0; 
} 

Pytam jest to, że uderza mnie, że przesunięcie pary z iteracyjnej w unordered_map za może zatem * re * przenieść zapisaną wartość klucza iteracyjnej i tym samym unieważnić jego hash; dlatego jakiekolwiek operacje na nim później mogą spowodować niezdefiniowane zachowanie. Chyba że tak nie jest?

Wydaje mi się, że warto zauważyć, że powyższe działanie przebiega zgodnie z zamierzeniami w GCC 4.8.2, dlatego staram się sprawdzić, czy pominięto dokumentację lub wyraźnie nie wspierałem zachowania.

Answer 1

// move object :: IS THIS SAFE?? 
v.push_back(std::move(*it)); 

Tak, jest bezpieczny, ponieważ tak naprawdę nie modyfikuje klucza. Nie może, ponieważ klucz jest stały. Typ *it to std::pair<const ConstAPtr, int>. Kiedy zostanie przeniesiony, pierwszy element (const ConstAPtr) nie zostanie faktycznie przeniesiony. Jest konwertowany na wartość r przez std::move i staje się const ConstAPtr&&. Ale to nie pasuje do konstruktora ruchu, który spodziewa się, że nie jest stały. Zamiast tego wywoływany jest konstruktor kopii.