[C++] Problema DLL e factory

[shodan]

Da quel che ho capito stai facendo proprio il contrario di quello che dovresti fare. E' la DLL che deve contenere il codice che devi condividere, non l'applicativo; per cui sarà la DLL ad avere il codice di Factory e di tutte le classi che ti servono per l'applicazione, non il contrario.
Il codice sotto è un esempio. L'unica cosa che conoscerà la tua applicazione saranno le varie interfacce raccolte in uno o più file .h più una unica funzione di caricamento della Factory vera e propria.

#pragma once
// #include "BeamDsChess.h"
// #include <map>

class CBeamDSChess; // classe interfaccia.
class Factory1
{
public:
    virtual CBeamDSChess * CreateDS( int idOfObjectToCreate )=0;
};

extern "C" {
void __declspec(dllexport)  Factory1* FactoryDS();
}

////////////////////////////////////////////////////////////////////////////////
// Factory1.cpp
////////////////////////////////////////////////////////////////////////////////

typedef CBeamDSChess* (*BASE_CREATE_FN)();

class CBeamDSChess_type1 : public CBeamDSChess
{
   public:
      static CBeamDSChess* instance() { return new CBeamDSChess_type1; }
      /* funzioni virtuali di CBeamDSChess */
      /* virtual */ void release()  { delete this; }
};

class CBeamDSChess_type2 : public CBeamDSChess
{
   public:
      static CBeamDSChess* instance() { return new CBeamDSChess_type2; }
      /* funzioni virtuali di CBeamDSChess */
      /* virtual */ void release()  { delete this; }
};

class CBeamDSChess_type3 : public CBeamDSChess
{
   public:
      static CBeamDSChess* instance() { return new CBeamDSChess_type3; }
      /* funzioni virtuali di CBeamDSChess */
      /* virtual */ void release()  { delete this; }
};

class Factory1Impl : public Factory1
{
   public:
      Factory1Impl(void) {}
      ~Factory1Impl(void) {}
      static bool InizializedMap;
      static Factory1Impl* instance_ptr ;
      static Factory1Impl* get_instance() {
         if (instance_ptr == NULL) {
            instance_ptr = new Factory1();
         }
         return instance_ptr;
      }
      /* virtual */ CBeamDSChess * CreateDS( int idOfObjectToCreate );
      std::map<int, BASE_CREATE_FN>  m_pMapRegister;
};
Factory1Impl* Factory1Impl::instance_ptr;
bool Factory1Impl::InizializedMap(false);

//-----------------------------------------------------------------------------

CBeamDSChess* Factory1Impl*::CreateDS( int idOfObjectToCreate ) {
   /* Nessuna eccezione deve uscire dalla funzione */ 
   try {
      BASE_CREATE_FN fz = m_pMapRegister[idOfObjectToCreate];
         return fz();
      } catch ( const std::exception& ) { }
      return 0; 
}

extern "C" {
   void __declspec(dllexport)  Factory1* FactoryDS() {
      /* Nessuna eccezione deve uscire dalla funzione */ 
      try {
         Factory1Impl::get_instance();
	if ( InizializedMap == false) {

m_pMapRegister.insert(std::make_pair(tipo1,&CBeamDSChess_type1::instance));
m_pMapRegister.insert(std::make_pair(tipo2,&CBeamDSChess_type2::instance));
m_pMapRegister.insert(std::make_pair(tipo3,&CBeamDSChess_type3::instance));

           InizializedMap = true;
	}   
        return Factory1Impl::instance_ptr;
      } catch (const std::exception& ) { }
      return 0; 
     }
}  // ~extern "C"


////////////////////////////////////////////////////////////////////////////////
// Applicativo che usa le classi della DLL
////////////////////////////////////////////////////////////////////////////////
// Creo factory
Factory1* chessFactory = FactoryDS(); // istanza singleton della factory.
if ( NULL == chessFactory ) throw std::bad_alloc("No Factory1");

// Creo i pezzi.
CBeamDSChess* type1 = chessFactory->CreateDS(tipo1);
if ( NULL == type1 ) throw std::bad_alloc("No Factory1");

CBeamDSChess* type2 = chessFactory->CreateDS(tipo2);
if ( NULL == type2 ) throw std::bad_alloc("No Factory1");

CBeamDSChess* type3 = chessFactory->CreateDS(tipo3);
if ( NULL == type3 ) throw std::bad_alloc("No Factory1");

// uso i pezzi
type1->qualcosa();
type2->qualcosa();
type3->qualcosa();

// rilascio la memoria usando l'apposito metodo. ASSOLUTAMENTE NO DELETE!!!
type1->release();
type2->release();
type3->release();