libc++abi: terminating due to uncaught exception of type std::__1::bad_weak_ptr: bad_weak_ptr
Ai apelat shared_from_this() pe un obiect care nu e deținut de niciun shared_ptr (creat pe stivă sau cu new simplu), sau chiar din constructor. Creează obiectul cu make_shared și apelează shared_from_this() doar după construire.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
O clasă care moștenește std::enable_shared_from_this<T> poate obține, din interiorul unei metode, un shared_ptr spre ea însăși cu shared_from_this(). Funcția merge doar dacă obiectul este deja gestionat de un shared_ptr: ea găsește blocul de control creat atunci și împarte proprietatea.
Dacă obiectul a fost creat pe stivă (Comanda c(7);), cu new simplu sau dacă apelul are loc în constructor (când shared_ptr-ul încă nu există), nu are ce să găsească. Din C++17, aruncă std::bad_weak_ptr. Aceeași excepție apare la shared_ptr<T> p(weak); construit dintr-un weak_ptr expirat.
În editorul nostru mesajul e bad_weak_ptr was thrown in -fno-exceptions mode; pe Linux cu GCC, terminate called after throwing an instance of 'std::bad_weak_ptr'.
De ce apare: cauzele frecvente
1Obiect creat pe stivă
Comanda c(7);
auto r = c.referinta(); // shared_from_this()auto c = make_shared<Comanda>(7);
auto r = c->referinta();make_shared creează blocul de control pe care shared_from_this() îl caută.
2Apel din constructor
Comanda(int i) : id(i) {
registru.push_back(shared_from_this());
}static shared_ptr<Comanda> creeaza(int i) {
auto c = make_shared<Comanda>(i);
registru.push_back(c);
return c;
}În constructor, shared_ptr-ul încă nu există; o funcție-fabrică îl creează întâi și abia apoi îl înregistrează.
3shared_ptr construit dintr-un weak_ptr expirat
shared_ptr<Client> c(slab); // slab a expiratif (auto c = slab.lock()) {
// folosesti c
}lock() întoarce un pointer gol în loc să arunce, iar if verifică rezultatul.
Repară eroarea, direct în pagină
Clasa Comanda întoarce un shared_ptr spre ea însăși cu shared_from_this(), dar obiectul e creat pe stivă și programul se oprește cu std::bad_weak_ptr. Creează comanda cu make_shared, ca programul să afișeze Comanda 7, proprietari: 2.
#include <iostream>
#include <memory>
using namespace std;
struct Comanda : enable_shared_from_this<Comanda> {
int id;
Comanda(int i) : id(i) {}
shared_ptr<Comanda> referinta() { return shared_from_this(); }
};
int main() {
Comanda c(7);
shared_ptr<Comanda> r = c.referinta();
cout << "Comanda " << r->id << ", proprietari: " << r.use_count() << "\n";
return 0;
}Comanda 7, proprietari: 2
Indiciu
auto c = make_shared<Comanda>(7); apoi c->referinta().
Reparația
#include <iostream>
#include <memory>
using namespace std;
struct Comanda : enable_shared_from_this<Comanda> {
int id;
Comanda(int i) : id(i) {}
shared_ptr<Comanda> referinta() { return shared_from_this(); }
};
int main() {
auto c = make_shared<Comanda>(7);
shared_ptr<Comanda> r = c->referinta();
cout << "Comanda " << r->id << ", proprietari: " << r.use_count() << "\n";
return 0;
}De ce merge
Pe stivă, obiectul c nu avea niciun shared_ptr, deci shared_from_this() nu avea un bloc de control cu care să împartă proprietatea și a aruncat bad_weak_ptr.
make_shared<Comanda>(7) creează obiectul împreună cu blocul de control. shared_from_this() îl găsește și întoarce un al doilea shared_ptr spre același obiect, de aceea use_count() este 2.
Alte forme ale mesajului
terminate called after throwing an instance of 'std::bad_weak_ptr' what(): bad_weak_ptrlibc++abi: terminating due to uncaught exception of type std::bad_weak_ptr: bad_weak_ptrbad_weak_ptr was thrown in -fno-exceptions mode
Cum o eviți pe viitor
- Creează obiectele care folosesc
enable_shared_from_thisdoar cumake_shared(eventual cu constructor privat și o funcție-fabrică). - Nu apela
shared_from_this()în constructor sau destructor. - Pentru
weak_ptr, foloseștelock()și verifică rezultatul, în loc de constructorulshared_ptr(weak). - Moștenește
enable_shared_from_thispublic.
Întrebări frecvente
De ce nu primesc un pointer gol în loc de excepție?
Din C++17 standardul cere excepția, ca să afli imediat greșeala. Dacă vrei varianta fără excepție, C++17 oferă weak_from_this(), care întoarce un weak_ptr (eventual gol) pe care îl verifici cu lock().
Moștenirea trebuie să fie publică?
Da: struct Comanda : enable_shared_from_this<Comanda> (la struct, implicit publică) sau class Comanda : public enable_shared_from_this<Comanda>. Cu moștenire privată, shared_ptr nu vede baza, iar shared_from_this() aruncă tot bad_weak_ptr.
Erori înrudite
Segmentation fault (core dumped) Programul a accesat memorie la care nu avea voie și sistemul l-a oprit. Cauzele tipice: pointer nullptr sau neinițializat folosit cu * sau ->, index în afara unui vector cu [], recursivitate fără caz de bază (stack overflow) sau obiect deja șters. Caută ultima linie executată și verifică pointerii și indicii. 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. libc++abi: terminating due to uncaught exception of type std::__1::bad_function_call: std::bad_function_call Ai apelat un std::function gol, căruia nu i s-a atribuit nicio funcție sau lambda. Verifică înainte de apel cu if (f) sau dă-i o valoare implicită la declarare. Î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.
