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

free(): double free detected in tcache 2

Pe scurt

Programul a eliberat de două ori aceeași memorie (delete pe un pointer deja eliberat), iar alocatorul a oprit programul. Cauza clasică: o clasă cu pointer și destructor, copiată fără constructor de copiere. Copiază memoria (regula celor trei) sau folosește vector / unique_ptr.

Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

Ce înseamnă

Fiecare bloc alocat cu new trebuie eliberat o singură dată. Când faci delete a doua oară pe aceeași adresă, alocatorul de memorie detectează (uneori) problema și oprește programul cu SIGABRT. Mesajul depinde de platformă: pe Linux cu glibc free(): double free detected in tcache 2, pe macOS pointer being freed was not allocated sau o oprire bruscă (Trace/BPT trap), în alte medii doar un cod de ieșire nenul.

Cel mai des apare la o clasă care alocă memorie în constructor și o eliberează în destructor, dar nu are constructor de copiere: copia implicită copiază doar pointerul, deci două obiecte indică aceeași memorie și ambele o șterg. Alte cauze: delete apelat de două ori pe același pointer sau pe doi pointeri care indică același obiect. Ieșirea de dinainte poate lipsi, pentru că cout nu apucă să o golească înainte de oprire.

De ce apare: cauzele frecvente

1Copie superficială a unei clase cu pointer

Greșit
C++
struct Cos {
    int* v;
    Cos() { v = new int[3]; }
    ~Cos() { delete[] v; }
};
Cos a;
Cos b = a;  // b.v == a.v
Corect
C++
struct Cos {
    vector<int> v = vector<int>(3);
};
Cos a;
Cos b = a;  // copie independentă

vector își copiază elementele și își eliberează singur memoria, deci fiecare obiect are bufferul lui.

2delete de două ori pe același pointer

Greșit
C++
int* p = new int(5);
delete p;
delete p;
Corect
C++
int* p = new int(5);
delete p;
p = nullptr;
delete p;  // delete pe nullptr nu face nimic

După eliberare, nullptr marchează pointerul ca gol; delete nullptr e permis și nu face nimic.

3Doi pointeri brut la același obiect

Greșit
C++
Produs* a = new Produs();
Produs* b = a;
delete a;
delete b;
Corect
C++
auto a = make_shared<Produs>();
auto b = a;  // memoria se eliberează o singură dată

shared_ptr numără proprietarii și eliberează obiectul când dispare ultimul.

Repară tu

Repară eroarea, direct în pagină

Clasa Cos alocă un tablou în constructor și îl eliberează în destructor. La copierea Cos b = a;, ambele obiecte ajung să elibereze aceeași memorie și programul se oprește cu double free. Adaugă un constructor de copiere care alocă un tablou nou și copiază valorile, ca programul să afișeze Copie: 1 și Original: 1.

Codul care dă eroarea
C++
#include <iostream>
using namespace std;

struct Cos {
    int* v;
    int n;
    Cos(int n) : n(n) {
        v = new int[n];
        for (int i = 0; i < n; i++) v[i] = i + 1;
    }
    ~Cos() { delete[] v; }
};

int main() {
    Cos a(3);
    {
        Cos b = a;
        cout << "Copie: " << b.v[0] << "\n";
    }
    cout << "Original: " << a.v[0] << "\n";
    return 0;
}
După reparație, programul afișează
Copie: 1
Original: 1
Indiciu

În constructorul de copiere, alocă v = new int[n] și copiază elementele din celălalt obiect.

Alte forme ale mesajului

  • free(): double free detected in tcache 2 Aborted (core dumped)
  • malloc: *** error for object 0x600000c04000: pointer being freed was not allocated
  • double free or corruption (fasttop)
  • Trace/BPT trap: 5
  • ERROR: AddressSanitizer: attempting double-free on 0x602000000010

Cum o eviți pe viitor

  • Preferă vector, string, unique_ptr și shared_ptr în locul lui new/delete direct.
  • Dacă o clasă are destructor care eliberează memorie, scrie și constructorul de copiere și operatorul de atribuire (regula celor trei) sau interzice-le cu = delete.
  • După delete p; scrie p = nullptr;.
  • Rulează programele de test cu -fsanitize=address: AddressSanitizer arată exact unde a fost prima eliberare.

Întrebări frecvente

De ce nu se afișează nimic, deși cout era înaintea erorii?

Textul trimis la cout stă într-un buffer și se scrie pe ecran mai târziu. Când alocatorul oprește brusc programul, bufferul nu mai apucă să fie golit. Cu cerr sau endl vezi ieșirea până în acel punct.

De ce programul merge uneori fără eroare?

Dubla eliberare e comportament nedefinit: alocatorul o detectează doar în anumite situații. Programul poate părea că merge, dar memoria e coruptă și poate cădea mai târziu, în alt loc.

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.