Retour de Chaînes à partir des Fonctions de la DLL

Pour une raison quelconque, de retourner une chaîne de caractères à partir d'une fonction de DLL se bloque mon programme sur l'exécution avec l'erreur Unhandled exception at 0x775dfbae in Cranberry Library Tester.exe: Microsoft C++ exception: std::out_of_range at memory location 0x001ef604...

J'ai vérifié ce n'est pas un problème avec la fonction elle-même en compilant le code de la DLL comme un .exe et de faire quelques tests simples dans la main fonction.

Fonctions avec d'autres types de retour (int, double, etc.) le travail parfaitement.

Pourquoi cela se produit?
Est-il un moyen de contourner ce problème?

Code Source de la DLL:

//Library.h
#include <string>

std::string GetGreeting();

//Library.cpp
#include "Library.h"

std::string GetGreeting()
{
    return "Hello, world!";
}

Code Source pour testeur:

//Tester.cpp
#include <iostream>
#include <Library.h>

int main()
{
    std::cout << GetGreeting()
}

EDIT: je suis en utilisant VS2010.

Conclusion

Une solution de contournement est de s'assurer que la bibliothèque et la source sont compilés à l'aide de la même compilateur avec le mêmes options, etc.

Est-il de code que vous pouvez nous montrer? Ou le code est-il pas le vôtre?
Mis à jour avec des exemples de code.
Cette compile pour moi dans Visual studio 2008. Quel compilateur que vous utilisez?
Si je comprends bien, si la DLL et EXE sont compilés avec le même compilateur(servicepack et les niveaux de correction) et même des versions de bibliothèques et exactement les mêmes options de compilation, il est possible pour les DLL et EXE pour partager un tas si cela peut fonctionner, toute autre combinaison peut vous donner des problèmes, comme vous le rencontrez
bdk est un excellent point sur les Crt découvrez: msdn.microsoft.com/en-US/library/ms235460(v=VS.80).aspx Bien que cela ne devrait pas être un problème si vous êtes en immeuble deux projets, avec la même version de VS2010 avec la même CRT.

OriginalL'auteur Maxpm | 2010-12-15

c++dll string visual-studio-2010

5

Depuis votre message d'erreur vous indique que vous êtes à l'aide de Microsoft C++ je vais vous proposer un MS de réponse spécifique.

Aussi longtemps que vous compilez le fichier EXE et les DLL avec le MÊME compilateur, et à la fois le lien de la MÊME version du moteur d'exécution de manière dynamique, alors vous allez être très bien. Par exemple, à l'aide de "DLL multithread" pour les deux.

Si vous link contre le moteur d'exécution de manière statique, ou un lien à l'encontre de différentes versions du moteur d'exécution puis vous êtes à la SOL pour les raisons @Billy ONeal points (de mémoire seront attribués dans un tas et libéré dans l'autre).

Je ne comprends pas pourquoi le tas pourrait être utilisé à tous? Il est passé par valeur et doit être retourné par la valeur sur la pile.
La chaîne est passée par valeur sur la pile, donc une nouvelle chaîne de l'objet doit être créé sur la pile en appelant son constructeur de copie. Que le constructeur peut utiliser des tas de stockage pour le texte, s'il stockées sur la pile, le redimensionnement de la chaîne, plus tard, serait problématique
Que le clarifie. Etrange, il travaille pour une lib statique dans VS2008.
Pour clarifier, la bibliothèque est compilé comme un DLL les mêmes paramètres? Il fonctionne pas si il est compilé comme une bibliothèque statique? Si cela fonctionne, faire les réglages doivent encore être le même?

OriginalL'auteur imaginaryboy
6

Cela se produit parce que vous êtes de l'allocation de mémoire dans une DLL (en utilisant std::string du constructeur), et de le libérer dans une autre DLL. Vous ne pouvez pas le faire parce que chaque DLL généralement définit son propre tas.

Est-ce à dire que je dois utiliser à 100%"normal" types (c'est à dire, char*)? Il n'y a vraiment aucun moyen de le faire?
si c'est le cas, vous pourriez être en mesure de passer un std::string comme un argument de sortie; par exemple: void GetGreeting(string& s) { s.assign("Hello World!"); } Cela peut ou peut ne pas fonctionner, selon la façon dont les allocateurs de piste entre la DLL et non-code de la DLL. Vous voulez essayer de mettre une beaucoup plus grande chaîne, juste pour être sûr.
Juste une pensée, serait à l'aide d'un allocateur personnalisé sur le std::les chaînes de caractères qui vit complètement sur un côté de la DLL limites de l'aide? Qui pourrait assurer l'allocation et la libération de mémoire tout se passe de la même tas
Cela devrait fonctionner -- bien sûr, alors il ne serait pas un std::string plus que. (Il serait un std::basic_string<char, std::char_traits<char>, MyAllocatorType>)
Cela ne fonctionnera pas pour les OP cas, le même compilateur / version doivent être utilisés.

OriginalL'auteur Billy ONeal
1

J'ai eu ce genre de problème qui a été résolu par:
- à l'aide de la bibliothèque d'exécution comme DLL de l'application et la DLL (que l'allocation est gérer dans un endroit unique)
- s'assurer que tous les paramètres du projet (compilateur, éditeur de liens) sont les mêmes sur les deux projet
OriginalL'auteur patriiice

Mise à jour:

J'ai compilé votre échantillon dans les deux VS2008 et VS2010 et j'ai pu réussir à le compiler et de l'exécuter sans problème. J'ai compilé la bibliothèque, à la fois comme une statique et une dynamique de la bibliothèque.

Original:

Ce qui suit se rapporte à ma discussion avec bdk et imaginaryboy. Je n'ai pas le supprimer comme il peut être de quelque intérêt pour quelqu'un.

Ok cette question vraiment me dérange, parce qu'il semble être passé par valeur et non par référence. Il ne semble pas être les objets créés dans le tas il semble être entièrement à pile.

J'ai fait un test rapide pour vérifier comment les objets sont transmis dans Visual Studio (compilé en mode release, sans lien à l'optimisation du temps et de l'optimisation des handicapés).

Le Code:

class Foo {
    int i, j;
public:
    Foo() {}
    Foo(int i, int j) : i(i), j(j) { }
};

Foo builder(int i, int j)
{
    Foo built(i, j);
    return built;
}


int main()
{
    int i = sizeof(Foo);
    int j = sizeof(int);
    Foo buildMe;
    buildMe = builder(i, j);
    //std::string test = GetGreeting();
    //std::cout << test;
    return 0;
}

Le Démontage:

int main()
{
00AD1030  push        ebp  
00AD1031  mov         ebp,esp 
00AD1033  sub         esp,18h 
int i = sizeof(Foo);
00AD1036  mov         dword ptr [i],8 
int j = sizeof(int);
00AD103D  mov         dword ptr [j],4 
Foo buildMe;
buildMe = builder(i, j);
00AD1044  mov         eax,dword ptr [j]               ;param j
00AD1047  push        eax  
00AD1048  mov         ecx,dword ptr [i]               ;param i
00AD104B  push        ecx  
00AD104C  lea         edx,[ebp-18h]                   ;buildMe
00AD104F  push        edx  
00AD1050  call        builder (0AD1000h) 
00AD1055  add         esp,0Ch 
00AD1058  mov         ecx,dword ptr [eax]             ;builder i
00AD105A  mov         edx,dword ptr [eax+4]           ;builder j
00AD105D  mov         dword ptr [buildMe],ecx 
00AD1060  mov         dword ptr [ebp-8],edx 
return 0;
00AD1063  xor         eax,eax 
}
00AD1065  mov         esp,ebp 
00AD1067  pop         ebp  
00AD1068  ret  
Foo builder(int i, int j)
{
01041000  push        ebp  
01041001  mov         ebp,esp 
01041003  sub         esp,8 
Foo built(i, j);
01041006  mov         eax,dword ptr [i]     
01041009  mov         dword ptr [built],eax ;ebp-8 built i
0104100C  mov         ecx,dword ptr [j] 
0104100F  mov         dword ptr [ebp-4],ecx ;ebp-4 built j
return built;
01041012  mov         edx,dword ptr [ebp+8] ;buildMe
01041015  mov         eax,dword ptr [built] 
01041018  mov         dword ptr [edx],eax   ;buildMe (i)
0104101A  mov         ecx,dword ptr [ebp-4] 
0104101D  mov         dword ptr [edx+4],ecx ;buildMe (j)
01041020  mov         eax,dword ptr [ebp+8] 
}

La Pile:

0x003DF964  08 00 00 00  ....
0x003DF968  04 00 00 00  ....
0x003DF96C  98 f9 3d 00  ˜ù=.
0x003DF970  55 10 ad 00  U..
0x003DF974  80 f9 3d 00  €ù=.
0x003DF978  08 00 00 00  ....   ;builder i param
0x003DF97C  04 00 00 00  ....   ;builder j param
0x003DF980  08 00 00 00  ....   ;builder return j 
0x003DF984  04 00 00 00  ....   ;builder return i 
0x003DF988  04 00 00 00  ....   ;j
0x003DF98C  08 00 00 00  ....   ;buildMe i param
0x003DF990  04 00 00 00  ....   ;buildMe j param
0x003DF994  08 00 00 00  ....   ;i
0x003DF998  dc f9 3d 00  Üù=.   ;esp

Pourquoi il s'applique:

Même si le code est dans un autre DLL de la chaîne retournée est copié en valeur dans les appelants pile. Il est caché param qui passe l'objet de GetGreetings(). Je ne vois pas du tas se créé. Je ne vois pas le tas ayant rien à voir avec le problème.

int main()
{
01021020  push        ebp  
01021021  mov         ebp,esp 
01021023  push        0FFFFFFFFh 
01021025  push        offset __ehhandler$_main (10218A9h) 
0102102A  mov         eax,dword ptr fs:[00000000h] 
01021030  push        eax  
01021031  sub         esp,24h 
01021034  mov         eax,dword ptr [___security_cookie (1023004h)] 
01021039  xor         eax,ebp 
0102103B  mov         dword ptr [ebp-10h],eax 
0102103E  push        eax  
0102103F  lea         eax,[ebp-0Ch] 
01021042  mov         dword ptr fs:[00000000h],eax 
std::string test = GetGreeting();
01021048  lea         eax,[ebp-2Ch]   ;mov test string to eax
0102104B  push        eax   
0102104C  call        GetGreeting (1021000h) 
01021051  add         esp,4 
01021054  mov         dword ptr [ebp-4],0 
std::cout << test;
0102105B  lea         ecx,[ebp-2Ch]   
0102105E  push        ecx  
0102105F  mov         edx,dword ptr [__imp_std::cout (1022038h)] 
01021065  push        edx  
01021066  call        dword ptr [__imp_std::operator<<<char,std::char_traits<char>,std::allocator<char> > (102203Ch)] 
0102106C  add         esp,8 
return 0;
0102106F  mov         dword ptr [ebp-30h],0 
01021076  mov         dword ptr [ebp-4],0FFFFFFFFh 
0102107D  lea         ecx,[ebp-2Ch] 
01021080  call        dword ptr [__imp_std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> > (1022044h)] 
01021086  mov         eax,dword ptr [ebp-30h] 
}
std::string GetGreeting()
{
01021000  push        ecx  ;ret + 4
01021001  push        esi  ;ret + 4 + 4 = 0C
01021002  mov         esi,dword ptr [esp+0Ch] ; this is test string 
std::string greet("Hello, world!");
01021006  push        offset string "Hello, world!" (1022124h) 
0102100B  mov         ecx,esi 
0102100D  mov         dword ptr [esp+8],0 
01021015  call        dword ptr [__imp_std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> > (1022040h)] 
return greet;
0102101B  mov         eax,esi ;put back test
0102101D  pop         esi  
//return "Hello, world!";
}

OriginalL'auteur

1

Comme snmacdonald j'ai été incapable de reproduire la panne, dans des circonstances normales. Autres déjà mentionnés:
Propriétés de Configuration -> Génération de Code -> Bibliothèque d'Exécution doit être exactement la même

Si je change, je les reçois votre crash. J'ai à la fois la DLL et EXE mis à la DLL multithread.

OriginalL'auteur Adam
1

Vous pouvez retourner un std::string à partir d'une classe aussi longtemps que vous inline la fonction qui crée la chaîne. C'est le cas, par exemple, par la bibliothèque Qt dans leur QString::toStdString méthode:
```
inline std::string QString::toStdString() const
{ const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); }
```
La fonction en ligne est compilé avec le programme qui utilise la dll, et non pas lorsque la dll est compilé. Cela évite tous les problèmes rencontrés par incompatibles runtimes ou des commutateurs du compilateur.

Donc, en fait, vous ne devriez retourner types standard de votre fichier dll (comme const char * et int ci-dessus) et d'ajouter des fonctions en ligne pour les convertir en std::string().

Passant dans un string & paramètre peut aussi être dangereux, car ils sont souvent mis en œuvre en tant que copie sur écriture.

OriginalL'auteur Mark Beckwith
1

Comme user295190 et Adam a dit que ça marcherait bien si avec exactement les mêmes paramètres de compilation.

Par exemple, dans Qt QString::toStdString() doit retourner une std::string et vous pouvez l'utiliser dans votre EXE à partir d'QtCore.dll.

Il plante si DLL et EXE a différents paramètres de compilation et la liaison des paramètres. Par exemple, DLL liées aux MD et EXE lié à MT de bibliothèque CRT.

Ce n'est pas vraiment ajouter quelque chose aux autres réponses...

OriginalL'auteur ijab

Vous devez vous connecter pour publier un commentaire.