¿Cómo exportar una clase de C++ desde un dll?

Question

Tengo una clase que tiene dos funciones sobrecargadas. ¿Cómo lo exporto desde un dll y también cómo usarlo en otras clases de C++? Mi clase es el siguiente:

#define DECLDIREXP __declspec(dllexport) 

#define DECLDIRIMP __declspec(dllimport) 


class DECLDIREXP xyz 

{ 

public: 
      void printing(); 
      void printing(int a); 
}; 

using namespace std; 

void xyz::printing() 
{ 
     cout<<"hello i donot take any argument"; 
} 


void xyz::printing(int a) 
{ 
     cout<<"hello i take "<< a <<"as argument"; 
} 

Answer 1

Un enfoque común es tener una sola macro (vamos a llamarlo EXPORT) que, o bien se expande a dllimport o dllexport dependiendo de si algún tipo de "generar el archivo DLL en este momento" definir es establece, de esta manera:

#ifdef MAKEDLL 
# define EXPORT __declspec(dllexport) 
#else 
# define EXPORT __declspec(dllimport) 
#endif 

class EXPORT xyz { 
    // ... 
}; 

La idea es que cuando la construcción de su DLL, se agrega MAKEDLL a las definiciones del preprocesador. De esa forma, todo el código será exportado. Los clientes que enlazan con su DLL (y por lo tanto incluyen este archivo de encabezado) no necesitan hacer nada. Al no definir MAKEDLL, importarán automáticamente todo el código.

La ventaja de este enfoque es que la carga de obtener las macros correctas se traslada de muchos (los clientes) a solo el autor de la DLL.

La desventaja de esto es que cuando se utiliza el código anterior tal como está, ya no es posible compilar el código directamente en algún módulo cliente ya que no es posible definir la macro EXPORT en nada. Para lograr eso, necesitaría tener otra verificación que, si es verdadera, define EXPORTAR a nada.

Sobre un tema ligeramente diferente: en muchos casos, no es posible (¡ni se desea!) Exportar una clase completa como esa. En su lugar, es posible que desee exportar los símbolos que necesita. Por ejemplo, en su caso, es posible que desee exportar los dos métodos públicos. De esa manera, no se exportará todos los miembros privados/protegidas:

class xyz 
{ 
public: 
    EXPORT void printing(); 
    EXPORT void printing(int a); 
}; 

Answer 2

Al compilar la biblioteca debe definir una macro (definición de la línea de comandos del preprocesador), vamos a llamarlo MY_DLL_EXPORT.

Luego, en el código de su biblioteca de hacer algo como esto:

#ifdef MY_DLL_EXPORT 
# define DLL_API __declspec(dllexport) 
#else 
# define DLL_API __declspec(dllimport) 
#endif 


class DLL_API some_class { /*...*/ } 

Answer 3

Como recuerdo, normalmente, no se exporta una clase sino una función fábrica que crea una nueva instancia de la clase y devuelve un puntero. La declaración de clase reside en el archivo de encabezado para el tiempo de compilación.

puedo estar equivocado sobre el ejemplo (que fue hace mucho tiempo), pero aquí la forma en que aproximadamente debe verse como:

Archivo de cabecera (.h):

class MyClass { ... }; 

extern "C" DLL_API MyClass* createMyClass(); 

archivo de origen (.cpp):

DLL_API MyClass* createMyClass() { 
    return new MyClass(); 
} 

Definir MY_DLL_EXPORT durante la compilación, ver ejemplo la respuesta de foraidt.

Answer 4

Una otra opción:

Utilice la por defecto definido macro locales al proyecto.

Se puede ver las macros por defecto definido locales para el proyecto en el cuadro a continuación:

Propiedades -> C/C++ -> preprocesador -> Definición preprocesador.

Ejemplo:

Supongamos que el nombre del proyecto es: MyDLL

defecto de las macros local a ese proyecto: MYDLL_EXPORTS

#ifdef MYDLL_EXPORTS 
    /*Enabled as "export" while compiling the dll project*/ 
    #define DLLEXPORT __declspec(dllexport) 
#else 
    /*Enabled as "import" in the Client side for using already created dll file*/ 
    #define DLLEXPORT __declspec(dllimport) 
#endif 


    class DLLEXPORT Class_Name { 
      //.... 
    }