"undefined reference to" with singleton

With the following code :

class DBConnection
{
// Methodes : private
    private:
        // Constructeur
        DBConnection();

        // Destructeur
        ~DBConnection();

// Methodes : public
    public:
        bool open();
        bool close();

// Methodes : public : static
    public:
        static DBConnection * getSingleton();

// Variables
    private:
        static DBConnection * singleton;

        QSqlDatabase    conn;

        QString         driver,
                        host,
                        userName,
                        password,
                        DBName;
};
 #endif // DBCONNECTION_HPP

#include "DBConnection.hpp"

// Initialisation du singleton dans l'espace global, car static
    DBConnection * DBConnection::singleton  = 0;

// Methodes : private
    DBConnection::DBConnection() {
        this->conn  = QSqlDatabase::addDatabase("QMYSQL");
            this->conn.setHostName("");
            this->conn.setUserName("");
            this->conn.setPassword("");
            this->conn.setDatabaseName("");
    }

    DBConnection::~DBConnection(){};

// Methodes : public
    bool DBConnection::open() {
        bool rep    = this->conn.isOpen()?true:this->conn.open();

        if(!rep)
            QMessageBox::critical(0, "Erreur critique !", "Imposs开发者_开发技巧ible d'ouvrir la base de données !");

        return rep;
    }

DBConnection * DBConnection::getSingleton() {
        if(singleton == 0)
            singleton   = new DBConnection;
        return singleton;
    }

#ifndef DAOMYSQLFACTORY_HPP
#define DAOMYSQLFACTORY_HPP

#include "InterfaceDAOFactory.hpp"
#include "DAO.hpp"

class DAOMySQLFactory : public InterfaceDAOFactory
{
// Methodes : private
    private:
        // Constructeur
        DAOMySQLFactory();

        // Destructeur
        ~DAOMySQLFactory();
// Methodes : public : heritées
    public:
        DAO * getDAOClient();

        DAO * getDAOSite();

        DAO * getDAOMachine();

// Methode : static
    public:
        static DAOMySQLFactory * getSingleton();

// Variables
    private:
        // Instance unique
        static DAOMySQLFactory * singletonMySQLFactory;
};

#endif // DAOMYSQLFACTORY_HPP

#include "DAOMySQLFactory.hpp"
#include "DBConnection.hpp"
#include "DAOMySQLClient.hpp"


DAOMySQLFactory * DAOMySQLFactory::singletonMySQLFactory = 0;

// Methodes : private
    // Constructeur
    DAOMySQLFactory::DAOMySQLFactory() {}
    // Destructeur
    DAOMySQLFactory::~DAOMySQLFactory() {}

// Methode : static
    DAOMySQLFactory * DAOMySQLFactory::getSingleton() {
        if(singletonMySQLFactory == 0)
            singletonMySQLFactory = new DAOMySQLFactory;
        return singletonMySQLFactory;
    }

// Methodes : public : heritee

    DAO * DAOMySQLFactory::getDAOClient() {
        return 0;
    }
...

#include <QApplication>

#include "WinMain.h"

//TEST
#include "DAOPersistenceFactory.hpp"
#include "DAO.hpp"
#include "DAOMySQLFactory.hpp"
#include "DBConnection.hpp"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

//TEST
    InterfaceDAOFactory * idao = DAOPersistenceFactory::getDAOFactory(DAOPersistenceFactory::MySQL);
    DAO * d = idao->getDAOClient();
    DBConnection::getSingleton();


    WinMain fen;
    fen.show();

    return app.exec();
}

#ifndef DAO_HPP
#define DAO_HPP

#include <QString>
#include <QStringList>
#include <QSqlQuery>

class DAO {
// Methodes : public
    public:
        DAO();
        virtual ~DAO();

// Methodes : public : abstraites
    public:
        virtual QStringList findAll() = 0;

// Variable
    protected:
        QSqlQuery   allQuery;
};

#endif // DAO_HPP

#include "DAO.hpp"

DAO::DAO() {}

DAO::~DAO(){}

#ifndef DAOMYSQLCLIENT_HPP
#define DAOMYSQLCLIENT_HPP

#include <QString>
#include <QStringList>
#include <QSqlQuery>

#include "DAO.hpp"
#include "DBConnection.hpp"

class DAOMySQLClient : public DAO
{

// Methodes : public
    public:
        DAOMySQLClient();
    //  DAOMySQLClient(DBConnection * connection);
//Variables
    private:
        DBConnection    * conn;

        QSqlQuery       byIdQuery,
                        byNameQuery;
};

#endif // DAOMYSQLCLIENT_HPP

#include <QMessageBox>
#include <QSqlError>
#include <QVariant>

#include "DAOMySQLClient.hpp"


// Methodes : public
    // Constructeur
    DAOMySQLClient::DAOMySQLClient() {}

    // Constructeur
//  DAOMySQLClient::DAOMySQLClient(DBConnection * connection) {
//      this->conn = connection;
//      this->conn->open();
//      initQueries();
//  }

...

Why i have a

undefined reference to 'DBConnection::getSingleton()'
collect2:ld returned 1 exit status 

in main() and DAOPersistenceFactory::getDAOFactory(DAOPersistenceFactory::MySQL); not whereas it seems to have the same implementation ?

I have the feeling that you forgot to add DBConnection.cpp to your .pro file. If you did, try re-running qmake. Also try to make clean.

I had lots of weird issues with out-of-date object files in the past. ;)