GNU GCC (g ++): Perché genera più dtor?

Ambiente di sviluppo: GNU GCC (g ++) 4.1.2

Mentre sto cercando di indagare su come aumentare la "copertura del codice, in particolare la copertura delle funzioni" nei test unitari, ho scoperto che alcuni dtor di classe sembrano essere generati più volte. Alcuni di voi hanno idea del perché, per favore?

Ho provato e osservato ciò che ho menzionato sopra utilizzando il seguente codice.

In "test.h"

class BaseClass
{
public:
    ~BaseClass();
    void someMethod();
};

class DerivedClass : public BaseClass
{
public:
    virtual ~DerivedClass();
    virtual void someMethod();
};

In "test.cpp"

#include <iostream>
#include "test.h"

BaseClass::~BaseClass()
{
    std::cout << "BaseClass dtor invoked" << std::endl;
}

void BaseClass::someMethod()
{
    std::cout << "Base class method" << std::endl;
}

DerivedClass::~DerivedClass()
{
    std::cout << "DerivedClass dtor invoked" << std::endl;
}

void DerivedClass::someMethod()
{
    std::cout << "Derived class method" << std::endl;
}

int main()
{
    BaseClass* b_ptr = new BaseClass;
    b_ptr->someMethod();
    delete b_ptr;
}

Quando ho creato il codice sopra (g ++ test.cpp -o test) e poi ho visto che tipo di simboli sono stati generati come segue,

nm: test di demangle

Ho potuto vedere il seguente output.

==== following is partial output ====
08048816 T DerivedClass::someMethod()
08048922 T DerivedClass::~DerivedClass()
080489aa T DerivedClass::~DerivedClass()
08048a32 T DerivedClass::~DerivedClass()
08048842 T BaseClass::someMethod()
0804886e T BaseClass::~BaseClass()
080488f6 T BaseClass::~BaseClass()

Le mie domande sono le seguenti.

1) Perché sono stati generati più dtor (BaseClass - 2, DerivedClass - 3)?

2) Quali sono le differenze tra questi medici? Come verranno utilizzati selettivamente quei medici multipli?

Ora ho la sensazione che per ottenere il 100% di copertura delle funzioni per il progetto C ++, avremmo bisogno di capirlo in modo da poter invocare tutti quei medici nei miei unit test.

Apprezzerei molto se qualcuno potesse darmi la risposta sopra.

Innanzitutto, gli scopi di queste funzioni sono descritti nell'ABI C ++ Itanium ; vedere le definizioni in "distruttore oggetto di base", "distruttore oggetto completo" e "eliminazione distruttore". La mappatura ai nomi alterati è fornita in 5.1.4.

Fondamentalmente:

• D2 è il "distruttore dell'oggetto di base". Distrugge l'oggetto stesso, così come i membri dati e le classi di base non virtuali.
• D1 è il "distruttore di oggetti completo". Inoltre distrugge le classi di base virtuali.
• D0 è il "distruttore di oggetti per l'eliminazione". Fa tutto ciò che fa il distruttore di oggetti completo, in più chiama operator deleteper liberare effettivamente la memoria.

Se non hai classi di base virtuali, D2 e ​​D1 sono identici; GCC, a livelli di ottimizzazione sufficienti, effettivamente alias i simboli con lo stesso codice per entrambi.

Di solito ci sono due varianti del costruttore ( non in carica / in carica ) e tre del distruttore ( non in carica / in carica / in carica che elimina ).

Il ctor e il dtor non in carica vengono utilizzati quando si gestisce un oggetto di una classe che eredita da un'altra classe utilizzando la virtualparola chiave, quando l'oggetto non è l'oggetto completo (quindi l'oggetto corrente non è "incaricato" di costruire o distruggere l'oggetto base virtuale). Questo ctor riceve un puntatore all'oggetto di base virtuale e lo memorizza.

L' incaricato ctor e dtors sono per tutti gli altri casi, cioè se non v'è alcuna eredità virtuale coinvolti; se la classe ha un distruttore virtuale, il puntatore del dtor di eliminazione in carica va nello slot vtable, mentre uno scope che conosce il tipo dinamico dell'oggetto (cioè per oggetti con durata di memorizzazione automatica o statica) utilizzerà il dtor in carica (perché questa memoria non dovrebbe essere liberata).

Esempio di codice:

struct foo {
    foo(int);
    virtual ~foo(void);
    int bar;
};

struct baz : virtual foo {
    baz(void);
    virtual ~baz(void);
};

struct quux : baz {
    quux(void);
    virtual ~quux(void);
};

foo::foo(int i) { bar = i; }
foo::~foo(void) { return; }

baz::baz(void) : foo(1) { return; }
baz::~baz(void) { return; }

quux::quux(void) : foo(2), baz() { return; }
quux::~quux(void) { return; }

baz b1;
std::auto_ptr<foo> b2(new baz);
quux q1;
std::auto_ptr<foo> q2(new quux);

Risultati:

• La voce dtor in ciascuno dei VTables per foo, baze quuxil punto in corrispondenza del rispettivo incaricato cancellazione dtor.
• b1e b2sono costruiti da baz() in carica , che chiama foo(1) in carica
• q1e q2sono costruiti da quux() un responsabile , che si foo(2) carica e baz() non è in carica con un puntatore fooall'oggetto che ha costruito in precedenza
• q2viene distrutto da ~auto_ptr() in-carica , che chiama il dtor virtuale ~quux() eliminazione di carica , che chiama ~baz() non incaricato , ~foo() in carica e operator delete.
• q1viene distrutto da ~quux() in-carica , che chiama ~baz() non-in-carica e ~foo() incaricato
• b2viene distrutto da ~auto_ptr() in-carica , che chiama il dtor virtuale ~baz() eliminazione di carica , che chiama ~foo() in carica eoperator delete
• b1viene distrutto da ~baz() in-carica , che chiama ~foo() in carica

Chiunque provenga da quuxutilizzerà il suo ctor e dtor non incaricato e si assumerà la responsabilità della creazione foodell'oggetto.

In linea di principio, la variante gratuita non è mai necessaria per una classe che non ha basi virtuali; in tal caso, la variante in carica viene quindi talvolta chiamata unificata e / o i simboli sia per incaricato che per non incaricato sono alias per una singola implementazione.