...
Eroare C++ · Excepții și erori la rulare

libc++abi: terminating due to uncaught exception of type std::__1::bad_weak_ptr: bad_weak_ptr

Pe scurt

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ă

Greșit
C++
Comanda c(7);
auto r = c.referinta();   // shared_from_this()
Corect
C++
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

Greșit
C++
Comanda(int i) : id(i) {
    registru.push_back(shared_from_this());
}
Corect
C++
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

Greșit
C++
shared_ptr<Client> c(slab);   // slab a expirat
Corect
C++
if (auto c = slab.lock()) {
    // folosesti c
}

lock() întoarce un pointer gol în loc să arunce, iar if verifică rezultatul.

Repară tu

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.

Codul care dă eroarea
C++
#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;
}
După reparație, programul afișează
Comanda 7, proprietari: 2
Indiciu

auto c = make_shared<Comanda>(7); apoi c->referinta().

Alte forme ale mesajului

  • terminate called after throwing an instance of 'std::bad_weak_ptr' what(): bad_weak_ptr
  • libc++abi: terminating due to uncaught exception of type std::bad_weak_ptr: bad_weak_ptr
  • bad_weak_ptr was thrown in -fno-exceptions mode

Cum o eviți pe viitor

  • Creează obiectele care folosesc enable_shared_from_this doar cu make_shared (eventual cu constructor privat și o funcție-fabrică).
  • Nu apela shared_from_this() în constructor sau destructor.
  • Pentru weak_ptr, folosește lock() și verifică rezultatul, în loc de constructorul shared_ptr(weak).
  • Moștenește enable_shared_from_this public.

Î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

← Toate erorile C++

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.