error: call to implicitly-deleted default constructor of 'std::hash<Punct>'
Folosești un tip propriu ca cheie într-un unordered_map sau unordered_set, dar biblioteca nu știe să-i calculeze hash-ul (std::hash<Punct> nu există). Dă containerului o funcție de hash proprie ca al treilea parametru de șablon sau folosește map/set, care au nevoie doar de operator<.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
unordered_map și unordered_set pun elementele în „găleți” după un număr calculat din cheie, hash-ul. Pentru tipurile standard (int, string, double...) există std::hash<T>. Pentru o structură scrisă de tine, std::hash<Punct> nu e definit, așa că biblioteca nu îl poate crea: de aici mesajul despre constructorul implicit șters al lui std::hash<Punct>.
Eroarea apare în header-ele bibliotecii, cu note lungi; linia ta este cea cu main.cpp, de obicei declarația unordered_map<Punct, int>. Soluțiile: scrii o structură cu operator() care întoarce un size_t și o dai ca al treilea argument (unordered_map<Punct, int, HashPunct>), sau specializezi std::hash<Punct>. Pe lângă hash, cheia are nevoie și de operator==. Dacă ordinea nu contează și datele sunt puține, map<Punct, int> cu operator< este alternativa simplă. pair<int,int> ca și cheie are aceeași problemă.
De ce apare: cauzele frecvente
1Structură proprie ca cheie
struct Punct {
int x, y;
bool operator==(const Punct& o) const { return x == o.x && y == o.y; }
};
unordered_map<Punct, int> vizite;struct HashPunct {
size_t operator()(const Punct& p) const {
return hash<int>()(p.x) * 31 + hash<int>()(p.y);
}
};
unordered_map<Punct, int, HashPunct> vizite;HashPunct combină hash-urile câmpurilor într-un singur număr, iar containerul îl folosește în locul lui std::hash<Punct>.
2pair ca cheie de unordered_map
unordered_map<pair<int, int>, string> harta;map<pair<int, int>, string> harta;std::hash nu e definit pentru pair. map folosește <, care există pentru pair.
3Lipsește și operator==
struct Cheie { string a; int b; };
unordered_set<Cheie, HashCheie> s;struct Cheie {
string a; int b;
bool operator==(const Cheie& o) const { return a == o.a && b == o.b; }
};
unordered_set<Cheie, HashCheie> s;Hash-ul alege găleata, iar == decide dacă două chei sunt aceeași. Fără el, eroarea se mută la invalid operands to binary expression.
Repară eroarea, direct în pagină
Ca Punct să poată fi cheie într-un unordered_map, biblioteca are nevoie de std::hash<Punct>. Programul verifică hash-ul a două puncte egale și nu compilează: error: call to implicitly-deleted default constructor of 'hash<Punct>'. Adaugă o specializare std::hash<Punct>, ca programul să afișeze acelasi hash.
#include <functional>
#include <iostream>
using namespace std;
struct Punct {
int x, y;
bool operator==(const Punct& o) const { return x == o.x && y == o.y; }
};
int main() {
hash<Punct> h;
Punct a{1, 2}, b{1, 2};
cout << (h(a) == h(b) ? "acelasi hash" : "hash diferit") << "\n";
return 0;
}acelasi hash
Indiciu
În namespace std, scrie template <> struct hash<Punct> cu un operator() const care întoarce size_t.
Reparația
#include <functional>
#include <iostream>
using namespace std;
struct Punct {
int x, y;
bool operator==(const Punct& o) const { return x == o.x && y == o.y; }
};
namespace std {
template <>
struct hash<Punct> {
size_t operator()(const Punct& p) const {
return hash<int>()(p.x) * 31 + hash<int>()(p.y);
}
};
}
int main() {
hash<Punct> h;
Punct a{1, 2}, b{1, 2};
cout << (h(a) == h(b) ? "acelasi hash" : "hash diferit") << "\n";
return 0;
}De ce merge
std::hash este definit doar pentru tipurile standard. Pentru Punct nu exista, așa că hash<Punct> h; nu putea fi creat; exact asta se întâmplă și în interiorul unui unordered_map<Punct, int>.
Specializarea template <> struct hash<Punct> din namespace std îi dă bibliotecii funcția lipsă: combină hash-urile coordonatelor. Două puncte egale au același hash, iar de acum unordered_map<Punct, int> funcționează direct, fără al treilea parametru.
Alte forme ale mesajului
error: use of deleted function 'std::hash<Punct>::hash()'error: static assertion failed due to requirement 'integral_constant<bool, false>::value': the specified hash does not meet the Hash requirementserror: call to implicitly-deleted default constructor of 'hasher' (aka 'std::hash<Punct>')error: call to implicitly-deleted default constructor of 'std::hash<std::pair<int, int>>'note: default constructor of 'hash<Punct>' is implicitly deleted because base class '__hash_impl<Punct>' has a deleted default constructor
Cum o eviți pe viitor
- Pentru chei proprii în containerele
unordered_*, scrie de la început atâtoperator==, cât și o structură de hash. - Dacă nu ai nevoie de viteza tabelei hash, folosește
map/setcuoperator<: e mai simplu și ordonat. - Pentru chei compuse din câteva numere, poți combina valorile într-un singur
long longsaustringși folosi un container standard.
Întrebări frecvente
Cum combin bine hash-urile mai multor câmpuri?
O formulă simplă este h1 * 31 + h2 (sau h1 ^ (h2 << 1)). Pentru exerciții e suficient; important este ca obiectele egale să aibă același hash.
De ce map<Punct, int> nu are nevoie de hash?
map este un arbore ordonat: compară cheile cu <, nu le calculează hash-ul. De aceea îi trebuie doar operator< pentru Punct.
Erori înrudite
error: invalid operands to binary expression ('const Produs' and 'const Produs') sort, set, map sau priority_queue trebuie să compare două obiecte ale clasei tale cu <, dar clasa nu are operator<. Dă-i un criteriu: o lambda la sort (sort(v.begin(), v.end(), [](const Produs& a, const Produs& b){ return a.pret < b.pret; })) sau definește operator< în clasă. error: call to implicitly-deleted copy constructor of 'unique_ptr<Cos>' Încerci să copiezi un obiect care nu poate fi copiat, cel mai des un unique_ptr (sau o clasă care conține unul). unique_ptr are un singur proprietar: mută-l cu std::move(p), transmite-l prin referință sau folosește shared_ptr dacă ai nevoie de mai mulți proprietari. error: no member named 'cost' in 'Produs' Folosești după punct (sau după ->) un membru sau o metodă pe care clasa nu o are: nume scris greșit, metodă care nu există (v.push în loc de v.push_back) sau membru declarat în altă clasă. Verifică numele exact din definiția clasei. Învață C++ de la zero, cu exerciții la fiecare lecție
Curs C++: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
