Errore linker: desidera il distruttore di classe base virtuale C++

Question

Ho un errore di collegamento in cui il linker si lamenta che il distruttore della mia classe concreta chiama il distruttore astratto della superclasse, il cui codice manca.

Questo sta utilizzando GCC 4.2 su Mac OS X da XCode.

Ho visto g++ undefined reference to typeinfo ma non è esattamente la stessa cosa.

Ecco il messaggio di errore di linker:

Undefined symbols: 
    "ConnectionPool::~ConnectionPool()", referenced from: 
     AlwaysConnectedConnectionZPool::~AlwaysConnectedConnectionZPool()in RKConnector.o 
ld: symbol(s) not found 
collect2: ld returned 1 exit status 

Ecco l'abstract dichiarazione di classe di base:

class ConnectionPool { 
public: 
    static ConnectionPool* newPool(std::string h, short p, std::string u, std::string pw, std::string b); 
    virtual ~ConnectionPool() =0; 
    virtual int keepAlive() =0; 
    virtual int disconnect() =0; 
    virtual sql::Connection * getConnection(char *compression_scheme = NULL) =0; 
    virtual void releaseConnection(sql::Connection * theConnection) =0; 
}; 

Ecco la dichiarazione della classe concreta:

class AlwaysConnectedConnectionZPool: public ConnectionPool { 
protected: 
    <snip data members> 
public: 
    AlwaysConnectedConnectionZPool(std::string h, short p, std::string u, std::string pw, std::string b); 
    virtual ~AlwaysConnectedConnectionZPool(); 
    virtual int keepAlive(); // will make sure the connection doesn't time out. Call regularly 
    virtual int disconnect(); // disconnects/destroys all connections. 
    virtual sql::Connection * getConnection(char *compression_scheme = NULL); 
    virtual void releaseConnection(sql::Connection * theConnection); 
}; 

Inutile dire , tutti quei membri sono implementati. Qui è il distruttore:

AlwaysConnectedConnectionZPool::~AlwaysConnectedConnectionZPool() 
{ 
    printf("AlwaysConnectedConnectionZPool destructor call"); // nothing to destruct in fact 
} 

e forse anche la routine di fabbrica:

ConnectionPool* ConnectionPool::newPool(std::string h, short p, std::string u, std::string pw, std::string b) 
{ 
    return new AlwaysConnectedConnectionZPool(h, p, u, pw, b); 
} 

posso risolvere questo problema artificialmente facendo la mia classe di base astratta concreta. Ma preferirei fare qualcosa di meglio. Qualche idea?

Grazie

Answer 1

Anche se si dichiara un distruttore come una funzione virtuale pura, è necessario fornire un'implementazione per esso. Sebbene non sia possibile istanziare direttamente una classe astratta, essa viene sempre istanziata quando istanziate una delle sue classi derivate (concrete). E così ad un certo punto tali casi saranno distrutti, richiedendo così un distruttore. L'attuazione del distruttore virtuale puro può essere (e di solito è) una funzione vuota:

ConnectionPool::~ConnectionPool() { 
} 

Answer 2

Anche in una classe astratta, non volete il vostro distruttore di essere puro virtuale. Questo perché verrà chiamato quando viene chiamato un distruttore di sottoclasse concreta.

Utilizziamo il seguente schema.

foo.h

class AbstractBaseClass { 
public: 
    virtual ~AbstractBaseClass(); 
    virtual void method1() = 0; 
    virtual void method2() = 0; 
protected: 
    AbstractBaseClass() { 
    } 
}; 

foo.cpp

AbstractBaseClass::~AbstractBaseClass() { 
} 

Vai a questa FAQ for details.