Windows, Qt, const char* et const WCHAR*

Version imprimable

Salut à tous,

Je bosse actuellement sur l'UI windows de mupen64plus (pour ceux qui connaissent).

Je rencontre une difficulté avec les conversion de type...

Je vous explique, voici une fonction C tiré de l'UI console du projet:
Code:

1 2 3 4 5 6 7 void * osal_dynlib_getproc(m64p_dynlib_handle LibHandle, const char *pccProcedureName) { if (pccProcedureName == NULL) return NULL; return GetProcAddress(LibHandle, pccProcedureName); }
GetProcAddress renvoit donc un void*.

Quand on compile en Visual Studio (le projet windows est en Visual Studio), ça fonctionne. Pas de problèmes.

Moi je bosse sur l'interface graphique qui est en Qt4. J'utilise donc qmake et mingw32-make pour compiler.

Nous avons besoins, pour cette UI de faire grosso mode la même chose que pour l'interface console: Charger la lib mupen64plus.dll, qui contient le "core" de l'émulateur.

Voici la méthode:
Code:

1 2 3 4 5 6 7 void * LibraryLoader::resolve(const char * name) { if (!private_->pluginHandle) return 0; return GetProcAddress(private_->pluginHandle, name); }
Avec comme définition pour pluginHandle:

Code:

m64p_dynlib_handle pluginHandle;

Et là, ça crash avec ça comme message:

Code:

src\libraryloader_win32.cpp:34: error: invalid conversion from 'int (*)()' to 'void*'

En lisant la doc msdn: http://msdn.microsoft.com/en-us/libr...=VS.85%29.aspx
Il est précisé que GetProcAddress renvoit l'adresse de la fonction ou variable exporté.
Serait-ce une subtilisé du compilo?

Visual Studio renverrait bien l'adresse (ça expliquerai pourquoi l'UI console compile sans problème), et mingw32 renverrait un int? C'est possible ça?

Si l'un d'entre vous pourrait éclairer la lanterne? Parce que là je suis dans l'impasse.

Merci d'avance et bonne journée à tous!

02/08/2010, 20h34
NoIdea
Le message me semble plutot claire :
La conversion entre l'adresse de la fonction (qui doit être du type int ()) et un void* n'est pas acceptée. Visual Studio doit faire cette conversion implicitement mais g++ demande un cast.

De plus, il me semble que la norme ne garantit pas la conversion d'un pointeur de fonction vers un void* bien que g++ l'accepte.

Pourquoi ne pas définir ta fonction comme renvoyant un int(*)() ?

Bien sur, si tu souhaites que ton code compile sur Visual et mingw ou g++, tu peux aussi faire :
Code:

1 2 return (void*)GetProcAddress(private_->pluginHandle, name);
ou encore :

Code:

return static_cast<void*>(GetProcAddress(private_->pluginHandle, name));//Ou reinterpet cast (je ne sait jamais).
02/08/2010, 20h44
Narann

Hello! Tout déja merci pour cette réponse! Je vais regarder comment on fait un cast (d'ailleurs si tu avais grosso modo la ligne que ça pourrait donner...:oops:)

Citation:

De plus, il me semble que la norme ne garantit pas la conversion d'un pointeur de fonction vers un void* bien que g++ l'accepte.

Bon, dans les fait c'est un HMODULE, mais ça ne résout pas mon soucis.

Citation:

Pourquoi ne pas définir ta fonction comme renvoyant un int(*)() ?

Haha et c'est la que c'est drôle (ou pas...). La définition des procédure de chargement des dynlibs sont communes entre Unix et Windows... C'est juste que dans mon .pro (QT) j'ai (en gros):

Citation:

HEADERS += include/libraryloader.h
unix:SOURCES += src/libraryloader_unix.cpp
win32:SOURCES += src/libraryloader_win32.cpp

Ça marche sous Linux. Et sous Windows (Visual Studio) aussi. Mais pas avec mingw32-make...

EDIT: Je suis en train de prévisualisé mon message et je vois que tu a édité le tiens avec un exemple.

Je vais le tester et je te redis, merci beaucoup!
02/08/2010, 21h50
Narann

Bon:

Citation:

return static_cast<void*>(GetProcAddress(private_->pluginHandle, name));

Ne fonctionne pas.

Par contre, avec :

Citation:

return (void*)GetProcAddress(private_->pluginHandle, name);

Ça compile!

Le soucis c'est que ça se lance mais ça crash windows. Etant sous QT + MinGW, je suis incapable de débugger le truc. va falloir que j'y aille au printf...

Même si j'ai un problème, on peut dire que le sujet est résolu...

Merci beaucoup!

:ccool:

Salut,
Il me semble que GetProcAdress s'utilise avec la signature de la fonction que tu veux récupérer :

Code:

1
2
3
4
5
6
7
8
9
 
typedef int(*t_pfn_proc)() 
t_pfn_proc osal_dynlib_getproc(m64p_dynlib_handle LibHandle, const char *pccProcedureName)
{
    if (pccProcedureName == NULL)
        return NULL;
 
    return (t_pfn_proc)GetProcAddress(LibHandle, pccProcedureName);
}

Ou idéalement avec une version générique (et des std::string à la place de ces affreux char*) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<class T>
void osal_dynlib_getproc(m64p_dynlib_handle LibHandle, std::string const &name_, T&pf_)
{
    pf_ =(T)GetProcAddress(LibHandle, name_.c_str());
}
 
int main()
{
    int (*pf)();
    osal_dynlib_getproc(0,0,pf);
    if(pf){
    pf();
    }
    return 0;
}

J'avoue que le retour en void* me fait un peu tiquer.

06/08/2010, 18h15
Narann
Ok, merci, je vais regarder ça! :)

Citation:

J'avoue que le retour en void* me fait un peu tiquer.

Bon, en fait, c'est du multiplateforme.
Le type est défini dans un header du projet (après, peut être que le m64p_types.h n'est pas bon... Mais le projet fonctionne):
Code:

1 2 3 4 #ifdef WIN32 #define HINSTANCE* m64p_dynlib_handle; #ifdef UNIX #define void* m64p_dynlib_handle;
(dsl je suis au taf, je ne me rappel plus de la syntax exact).
Donc sous Windows, le pointeur est supposé être de type HINSTANCE. Je vais tenter ça aussi...
07/08/2010, 07h14
3DArchi
Citation:
Envoyé par Narann

Ok, merci, je vais regarder ça! :)

Bon, en fait, c'est du multiplateforme.
Le type est défini dans un header du projet (après, peut être que le m64p_types.h n'est pas bon... Mais le projet fonctionne):

Code:

1 2 3 4 #ifdef WIN32 #define HINSTANCE* m64p_dynlib_handle; #ifdef UNIX #define void* m64p_dynlib_handle;

(dsl je suis au taf, je ne me rappel plus de la syntax exact).
Donc sous Windows, le pointeur est supposé être de type HINSTANCE. Je vais tenter ça aussi...
Je pensais au type retour de ta fonction : void * LibraryLoader::resolve. Pourquoi ne pas retourner directement le pointeur de fonction bien typé ?
07/08/2010, 12h07
Narann

Citation:

Envoyé par 3DArchi

Pourquoi ne pas retourner directement le pointeur de fonction bien typé ?

Je suppose que c'est parce que la fonction resolve renvoit des fonctions qui elles même renvois différents types de valeur...

Enfin je suppose... :(
09/08/2010, 09h10
3DArchi

Salut,
Justement avec une approche générique, tu peux avoir un typage fort plus rapidement.
09/08/2010, 20h08
Narann

Merci pour cette réponse. :) Je n'ai pas tout compris.
Mais si vous avez le temps (ou un simple lien), je suis preneur.:roll:

Citation:

Envoyé par Narann

Merci pour cette réponse. :) Je n'ai pas tout compris.
Mais si vous avez le temps (ou un simple lien), je suis preneur.:roll:

C'était l'exemple que je proposais plus haut :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template<class T> void osal_dynlib_getproc(m64p_dynlib_handle LibHandle, std::string const &name_, T&pf_) { pf_ =(T)GetProcAddress(LibHandle, name_.c_str()); } int main() { int (*pf)(); osal_dynlib_getproc(0,0,pf); if(pf){ pf(); } return 0; }
La fonction est directement récupérée avec le bon type.