Mi pregunta está relacionada con la exportación de una clase de C ++ con STL dentro. Por ejemplo:

class __declspec(dllexport) Hello
{
    std::string   name;

public:
    std::string&  getName();
    void          setName(const std::string& name);
}

Varios artículos parecen indicar que esto esmuy mal, lo cual es bastante comprensible. Todo debe ser compilado con la misma configuración del compilador y la versión CRT. De lo contrario, todo se estrellará y arderá.

Pregunta:

Lo que no entiendo es por qué solo los miembros de datos parecen tener un problema. Con el siguiente código, obtengo: "C4251: debe tener una interfaz dll para ser utilizada por los clientes de clase"; que aparentemente se arregla al exportar la instanciada std :: string:

struct __declspec(dllexport) SomeClass
{
    // Removes the warning?
    // http://www.unknownroad.com/rtfm/VisualStudio/warningC4251.html
    //   template class __declspec(dllexport) std::string;

    std::string name;  // Compiler balks at this
}

Y la versión fija es:

// Export the instantiations of allocator and basic_string
template class __declspec(dllexport) std::allocator<char>;
template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char> >;

struct __declspec(dllexport) SomeClass
{
    std::string name;  // No more balking!
}

(Esto le dará a LNK2005 "basic_string ya definido" cuando intente usar la DLL, lo que significa que no debe vincular el CRT en el cliente, por lo que termina usando la creación de instancias en la DLL).

Los tipos de retorno y los argumentos parecen no tener problemas con la STL y no reciben los mismos datos de tratamiento que los miembros obtienen del compilador.

// No exporting required?
struct __declspec(dllexport) SomeOtherClass
{
    std::string  doSomething1();                       // No problemo
    void         doSomething2(const std::string& s);   // No problemo
}

Información adicional (la pregunta está arriba)

En ambos:

class A {
    std::string foo() { return std::string(); }
    // std::string& foo(); gives the same result!
    // std::string* foo(); also gives the same result!
}

class B {
    std::string a;
}

Tampoco parecen exportar std :: basic_string o std :: allocator. Más bien, solo exportan los miembros / funciones de la clase.

Sin embargo, elfijo La versión mencionada en la pregunta exporta tanto basic_string como el asignador.