Come esporre l'elenco STL oltre il limite della DLL?

Question

Ho una DLL che deve accedere ai dati memorizzati nei contenitori STL nell'applicazione host. Poiché il C++ non ha ABI standard e voglio supportare diversi compilatori, l'interfaccia tra l'applicazione e la DLL deve fondamentalmente rimanere semplice-vecchia-dati.

Per i vettori questo è relativamente semplice. Si può semplicemente restituire il blocco di memoria del vettore, perché è garantito per essere contigious:

// To return vector<int> data 
virtual void GetVectorData(const int*& ptr, size_t& count) const 
{ 
    if (!vec.empty()) 
     ptr = &(vec.front()); 

    count = vec.size(); 
} 

Ora la DLL può avere sicuro accesso in sola lettura ai dati del vettore tramite l'interfaccia. La DLL può anche avvolgere questo per copiare il contenuto in un vettore anche per se stesso.

E per quanto riguarda le liste STL (e gli accessori)? C'è un altro modo semplice per consentire l'accesso tramite un limite DLL? O dovrò ricorrere a qualche tipo di interfaccia GetFirst()/GetNext()? Potrei aver bisogno di farlo per molte liste, quindi sarebbe bello avere una soluzione semplice come quella dei vettori.

Answer 1

Forse è possibile passare qualcosa come "maniglie" per elencare/deerare gli iteratori? Questi tipi di handle sarebbero opachi e dichiarati in un file di intestazione che spediresti agli utenti. Internamente, è necessario mappare i valori di handle per elencare/deerare gli iteratori. In sostanza, l'utente dovrebbe scrivere codice come:

ListHandle lhi = GetListDataBegin(); 
const ListHandle lhe = GetListDataEnd(); 

while (lhi != lhe) 
{ 
    int value = GetListItem(lhi); 
    ... 
    lhi = GetNextListItem(lhi); 
} 

Answer 2

l'interfaccia tra l'applicazione e DLL ha sostanzialmente rimanere plain-old-dati.

Non necessariamente. Devi essere sicuro che venga utilizzata la stessa versione del compilatore. Inoltre, le impostazioni di build che influiscono sul layout degli oggetti STL sono esattamente le stesse tra la DLL e l'applicazione.

Se dovessi rilasciare la dll in natura, hai ragione a preoccuparti di esporre STL oltre i confini delle dll. Se, tuttavia, tutto è sotto il tuo controllo e puramente interno (o se puoi forzare rigidamente le impostazioni/compilatore di compilazione di terze parti) dovresti stare bene.

Answer 3

È possibile passare oggetti STL tra le DLL e supportare diversi compilatori se siete attenti dove si crea un'istanza di ogni tipo STL. Sono necessari alcuni "macro DLLEXPORT" intelligenti: utilizzo il seguente set per supportare VC e gcc con successo.

#ifdef WIN32 
#ifdef MYDLLLIB_EXPORTS  // DLL export macros 
#define MYDLLLIB_API __declspec(dllexport) 
#define MYDLLLIB_TEMPLATE 
#else 
#define MYDLLLIB_API __declspec(dllimport) 
#define MYDLLLIB_TEMPLATE extern 
#endif 
#else      // Not windows --- probably *nix/bsd 
#define MYDLLLIB_API 
#ifdef MYDLLLIB_EXPORTS 
#define MYDLLLIB_TEMPLATE 
#else 
#define MYDLLLIB_TEMPLATE extern 
#endif 
#endif // WIN32 

Durante la compilazione della DLL, definire MYDLLLIB_EXPORTS. Nella DLL si può quindi istanziare ogni tipo STL che si desidera utilizzare, ad esempio, elenchi o vettori di stringhe

MYDLLLIB_TEMPLATE template class MYDLLLIB_API std::vector<std::string>; 
MYDLLLIB_TEMPLATE template class MYDLLLIB_API std::list<std::string>; 

consumatori di DLL (che non hanno MYDLLLIB_EXPORTS definiti) sarà poi vedere

extern template class __declspec(dllimport) std::vector<std::string>; 

e utilizzare il codice binario esportato dalla DLL anziché creare un'istantanea.