jak łatwo sprawdzić, czy std :: map i std :: unordered_map zawiera te same elementy

Question

piszę test jednostka testowa Google i chcę, aby sprawdzić, czy treść w unordered_map<std::string, std::string> jest taka sama jak std::map<std::string, std::string>

Nie sądzę, że std::equal będzie działać, ponieważ elementy w std::map są sortowane według kryterium. Kolejność nie jest ważna.

Answer 1

Nie sądzę, że istnieje lepszy sposób niż przechodzenie przez wszystkie elementy jednej mapy i sprawdzanie, czy są one obecne na drugiej mapie. Jeśli sprawdzisz również, czy ilość elementów jest taka sama, dowiesz się, czy mapy są całkowicie takie same.

Na przykład:

template<typename K, typename E> 
bool maps_equal(const std::map<K, E> &map, const std::unordered_map<K, E> &unordered_map) { 
    return 
     map.size() == unordered_map.size() && 
     std::all_of(map.cbegin(), map.cend(), [&](const std::pair<const K, E> &item) { 
      auto iter = unordered_map.find(item.first); 
      return iter != unordered_map.end() && iter->second == item.second; 
     }); 
} 

Answer 2

Można utworzyć unordered_map z map, a następnie porównać dwa unordered_map. I wzajemnie.

std::unordered_map<std::string, std::string> m1; 
std::map<std::string, std::string> m2; 
std::unordered_map<std::string, std::string> m3(m2.begin(), m2.end()); 
if (m1 == m3) {} 

Answer 3

zadam oczywiste pytanie, ale to naprawdę zmienia wszystko:

jest pojęcie równości w map zgodny z pojęciem równości w unordered_map?

przykładu niekompatybilnych definicje:

struct Point3D { std::int32_t x, y, z }; 

struct MapLess { 
    bool operator()(Point3D const& left, Point3D const& right) const { 
     return std::tie(left.x, left.y) < std::tie(right.x, right.y); 
    } 
}; 

bool operator==(Point3D const& left, Point3D const& right) { 
    return std::tie(left.x, left.z) 
     == std::tie(right.x, right.z); 
} 

W ten (contrived) wypadku możemy mieć

• map: (1, 2, 3) i (1, 3, 3)
• unordered_map: (1, 2, 3) i (1, 2, 4)

i naiwny look-up będą zgłaszać, że map jest zawarty w unordered_map, ponieważ ponieważ oba mają ten sam rozmiar doprowadziłoby do błędnego wniosku, że są one równe.

---

Rozwiązanie jeśli kanoniczny pojęcie równości istnieje jest sprawdzenie, po każdym look-up, że wynik look-up jest faktycznie taka sama jak oryginał.

template <typename M1, typename M2> 
bool equal(M1 const& left, M2 const& right) { 
    if (left.size() != right.size()) { return false; } 

    for (auto const& e: left) { 
     auto const it = right.find(e.first); 

     if (it == right.end()) { return false; } 
     if (it->first != e.first) { return false; } 
     if (it->second != e.second) { return false; } 
    } 

    return true; 
} 

Uwaga: to może być przepisany z std::all i pojedynczym logicznej wypowiedzi; to kwestia gustu, wolę ją rozbić.

Jeśli nie kanoniczny pojęcie równości istnieje, wtedy odwrotny look-up może zastąpić sprawdzenie równości:

template <typename M1, typename M2> 
bool equal(M1 const& left, M2 const& right) { 
    if (left.size() != right.size()) { return false; } 

    for (auto e = left.begin(), end = left.end(); e != end; ++e) { 
     auto const it = right.find(e->first); 

     if (it != right.end()) { return false; } 
     if (left.find(it->first) != e) { return false; } 
     if (it->second != e->second) { return false; } 
    } 

    return true; 
} 

To oczywiście nieco droższe.