como quitar el decorado de symbolos en clases exportadas

[dewolo]

eso me confunde porque mi clase ni siquiera usa constructor, es decir no lo defini........... y por otro lado es una clase con propiedades y metodos que la idea es que sea modificada por una funcion externa. entonces vos creas un objeto y se lo pasas a esa funcion y esta lo modifica.

estas son algnas de las citas del tutorial del hack

//The list contains the virtual memory address of the functions Add, Sub, GetLastUsedFunc and the constructor.

//Since we obtained the block of memory, we have to call the constructor to initialize the block of memory.
//So, we get the relative virtual address of the constructor in the DLL.

//Since we have the address of the constructor, we have to explicitly call it to initialize the
//block of memory obtained by malloc.

//Yes, but how do we associate an object for the constructor?

//If you remember, when any member function is called, including the constructor,
//the address of the object gets quietly passed to the called function and this address is stored in the stack.
//On an Intel based machine, this address of the object is pushed onto the stack via the ECX register.
//So, if you create a class and call its member function, the ECX register contains the 'this' pointer.
//This screen shot should make things clearer.

//acerca del bloque reservado con malloc..
//since we already have the address of a block of memory (that will in the future be an object),
//we move this address into the ECX register by using the Visual C++ inline assembler syntax:
//__asm { MOV ECX, pCCalc }

//Since we have already obtained the address of the constructor, we just say:
//pCtor ();

//When your function pointer pCtor() returns from the DLL,
//it would have initialized the object of the class contained in the DLL.

entiendo para que necesita llamar al constructor en este caso, pero en mi caso no entiendo porque deberia llamarlo. si pudieras explicarme la razon de tener que agregar un constructor explicito en mi clase y llamarlo en el EXE   por que todavia no entiendo el motivo

en el EXE yo solo quiero crear un objeto en el winmain de esta forma:

winmain()
{
      Datos dat;

      //y pasarselo a esta funcion importada de la DLL
     pFuncionQueUsaUnParametroDeClaseDatos(dat);
}

la funcion exportada de la dll luseria algo asi

Código [Seleccionar] Expandir


EXPORT void FuncionQueUsaUnParametroDeClaseDatos( Datos &dat )
{
      /* modifica el objeto, lo inicializa y le asigna valores a sus miembros (propiedades) */

     dat.setValorA(5);//ejemplo
}


y la funcion  lo que haria seria modificar el objeto, osea darle valores y eso. entonces para esta caso aunque no sea como el del hack tambien necesitaria hacer lo del bloque de memoria con malloc y llamar al constructor ?

[Eternal Idol]

No ... pero si tenes propiedades a menos que uses un metodo para inicializarlas a sus valores por defecto seguramente vas a tener problemas ...

[dewolo]

fijate tu pm por favor 

[Eternal Idol]

Aca esta el metodo ideal que equivale a COM: "C++ Mature Approach: Using an Abstract Interface"

DLL con una funcion exportada para crear el objeto:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>

BOOL APIENTRY DllMain (HANDLE, DWORD, LPVOID)
{
    return TRUE;
}

class Datos
{
public:
Datos();
virtual void setVALOR(int v);
virtual int getVALOR();
virtual void Release();

private:
int VALOR;
};

Datos::Datos()
{
VALOR = 0;
}

void Datos::setVALOR(int v)
{
VALOR = v;
}

int Datos::getVALOR()
{
return VALOR;
}

void Datos::Release()
{
delete this;
}

extern "C" __declspec(dllexport)  Datos *newDatosObject()
{
return new Datos;
}

Ejecutable con clase abstracta, Datos es una caja negra y llamamos a la funcion para crear el objeto (que destruimos con el metodo Releaes indirectamente):

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
#include <cstdio>

class Datos
{
public:
virtual void setVALOR(int v) = 0;
virtual int getVALOR() = 0;
virtual void Release() = 0;
};

int main()
{
HMODULE hMod = LoadLibrary(TEXT("graphics.dll"));
if (hMod)
{
typedef Datos* (*newDatosObject_ptr)();
newDatosObject_ptr newDatosObject = (newDatosObject_ptr)GetProcAddress(hMod, "newDatosObject");
Datos *pDatos = newDatosObject();
if (pDatos)
{
int x = pDatos->getVALOR();
printf("%d\r\n", x);
pDatos->setVALOR(x + 34);
x = pDatos->getVALOR();
printf("%d\r\n", x);

pDatos->Release();
}
FreeLibrary(hMod);
}

return 0;
}

[dewolo]

osea la DLL tiene un solo export que equivale al objeto completo y en el EXE solo haces esto
"Datos *pDatos = newDatosObject();" y ya lo tenes 

[Eternal Idol]

Exactamente, por eso en el primer mensaje te puse si habia alguna razon para no hacer esto, es lo mejor por lejos