creation dll a partir d une classe

Version imprimable

Bonjour à tous,

depuis des années je programme dans differents langages et j'avais toujours repoussé l'apprentissage de c++ au lendemain.
Je viens de reecrire une classe python, que j'avais codé, en c++ tant bien que mal. Le but etant de faire une dll pour l'utiliser par une application externe (windev)

Je coince à la creation de ma DLL sous codeblocks, je m'explique:

j'ai crée ma classe "memfile" (il y a memfile.h et memfile.cpp)
Avec Codeblocks, je démarre un projet DLL où j'obtiens 2 fichiers : main.h et main.cpp
dans le dossier du projet, je mets les 2 fichiers de ma classe memfile.
Voici le main.h de la DLL :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 #ifndef __MAIN_H__ #define __MAIN_H__ #include <windows.h> #include "memfile.h" memfile m; /* To use this exported function of dll, include this header * in your project. */ #ifdef BUILD_DLL #define DLL_EXPORT __declspec(dllexport) #else #define DLL_EXPORT __declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif void DLL_EXPORT SomeFunction(const LPCSTR sometext); #ifdef __cplusplus } #endif
Le probleme vient à la compilation : j'obtiens toujours un fichu "undefined reference to `memfile::memfile()'
Ca fait des heures que je cherche.. ca viendrait d'un probleme de link....
Je me suis mis sous "debug" ou "release" ca change rien, c'est la galère!

merci à celui/celle qui peut m'eclairer

07/02/2012, 15h19
cob59

C'est probablement que le constructeur par défaut n'est pas défini dans memfile.cpp :

Citation:

MemFile::MemFile() {
... corps du constructeur ...
}

Au fait, à quoi sert cette variable globale "m" dans main.h ?
D'ailleurs, à quoi sert main.h ?

merci de me répondre, toute aide est bienvenue

dans memfile.cpp, j'ai bien un constructeur (vide) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include "memfile.h"
#include <sstream>
#include <stdio.h>
#include <iostream>
#include <math.h>
 
 
using namespace std;
 
char buf[5000];
char r_close[32] = {16,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,5,0,0,121,1,0,0,0,0,0,0,0,0,0};
char r_next[32] = {0,16,32,0,0,0,0,0,0,0,0,0,0,0,0,0,
                   0,0,14,0,0,6,4,1,160,15,0,0,0,0,0,0};
char r_read[32] = {0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                   0,0,12,0,0,7,4,1,160,15,0,0,0,0,0,0};
char r_delet[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,18,0,0,0,0,1,0,0,0,0,0,0,0,0};
char r_zero[32] = {10,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,17,0,0,0,0,1,0,0,0,0,0,0,0,0};
char r_update[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,11,0,0,1,0,1,0,0,0,0,0,0,0,0};
char r_write[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,9,0,0,1,0,0,0,0,0,0,0,0,0,0};
char r_born[32] = {16,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,17};
 
 
memfile::memfile() {}
 
void memfile::connex(string serveur,int port)
{
    WSADATA WSAData;                                        // SOCKET
    SOCKADDR_IN sin;
    WSAStartup(MAKEWORD(2,0), &WSAData);
    sin.sin_addr.s_addr = inet_addr(serveur.c_str()

La variable globale m (nom provisoire..) va me servir pour utiliser ma classe memfile.
main.h a été crée par codeblocks lors de la creation de mon projet DLL.

tout ca est nouveau pour moi

:cry:

07/02/2012, 15h31
Bousk

Bonjour,

si ta DLL exporte une classe et la possibilité de créer cette classe avec l'application qui l'utilisera, que fout une variable globale (mal déclarée) dedans ?
Ta DLL ne devrait que fournir la class et les fonctions correspondantes, pas d'instance de la classe.

L'erreur indique que le constructeur par défaut n'est pas déclaré. Oubli de prototype dans le header surement ?
07/02/2012, 15h39
Nico_tournai

Bonjour,

bien j'en sais rien msieur! me grondez pas! :oops:
J'etais bien content d'avoir crée ma classe.

le simple but est de l'utiliser via une dll, si tu as un exemple minimaliste à me proposer je suis preneur!
je voulais simplement utiliser la classe deja faite dans mon projet de dll.
Peut etre en "copiant" mon code de la classe dans la dll, ca irait..
07/02/2012, 15h42
Bousk

Si le but est d'exporter la classe, tu exposes la classe, et non une instance de la classe.

Pour plus d'informations pour exporter une classe en dll, ça marche de la même manière que pour une fonction simple.
http://msdn.microsoft.com/en-us/libr...(v=vs.80).aspx
http://www.codeproject.com/Articles/...ses-from-a-DLL
07/02/2012, 15h51
Nico_tournai

Bon je vais me debrouiller avec ce que tu me donnes, tu as oublié le lien vers une boite d'aspirine... ;)

Je vais voir si je m'en sors..

merci
07/02/2012, 15h56
cob59

Ah.
Et est-ce que memfile.cpp est bien inclus dans ton projet C::B ?
Il ne suffit pas d'ajouter tes fichiers de classe dans le répertoire des sources du projet, il faut aussi les "recenser" auprès de ton projet C::B : Project > Add files... puis tu ajoutes tes 2 fichiers. A mon avis tu peux aussi faire sauter main.h et main.cpp qui ne te serviront à rien.

-- edit --
Au fait, essaie plutôt de déclarer tes espèces de variables globales r_bidule en variables statiques :

Code:

static char r_truc[32] = {...};
07/02/2012, 16h07
Nico_tournai

:ccool:

effectivement ca compile maintenant
j'ai du ajouter dans le link une librairie car j'utilise des sockets.

qu'entends tu par sauter "main.h" et "main.cpp", dedans j'ai ce qu'il faut pour realiser la dll...
peut etre je dois mettre les DLL_EXPORT dans la classe memfile..?
j'aurais accés aux fonctions de ma classe directement?
07/02/2012, 16h34
Bousk

Dans le cas d'une classe il faut déclarer dllexport et import (via macro pour switcher les 2 automatiquement) dans le prototype de la classe uniquement (class MyAwesomeClass -> class DLLEXPORTMACRO MyAwesomeClass).
Comme montré dans le 2° lien que je t'ai indiqué.

Il entendait sûrement que si tu as déjà memfile.h/cpp au projet, l'utilité (ou plutôt l'inutilité) de main.h/cpp est quasi sûre puisque ton code est dans memfile, le main étant juste un fichier par défaut ajouté au projet avec un exemple d'export d'une fonction simple)

oui j'ai viré les main du projet.

j'ai un code maintenant dont je ne comprends pas encore tout, qui compile.

memfile.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
 
//#ifndef __MAIN_H__
//#define __MAIN_H__
 
#include <windows.h>
#ifndef MEMFILE_H
#define MEMFILE_H
#include <winsock2.h>
//#pragma comment(lib, "ws2_32.lib")
#include <string>
#include <map>
#include <vector>
 
 
#ifdef BUILD_DLL
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT __declspec(dllimport)
#endif
 
 
#ifdef __cplusplus
extern "C"
{
#endif
 
class DLL_EXPORT memfile
{
    public:
        memfile();
        void DLL_EXPORT connex(std::string serveur,int port=5001);
        virtual ~memfile();
 
        void open(std::string file,std::string idf);
        void close(std::string idf);
 
        int zero(std::string idf,int key,std::string opt="");
        int next(std::string idf,int key=1,std::string opt="");
        int read(std::string idf,int key=1,std::string opt="");
        int delet(std::string idf,int key=1,std::string opt="");
        int update(std::string idf,int key=1,std::string opt="");
        int write(std::string idf,std::string opt="");
 
 
        std::map<std::string,std::string> values;   // assoctiation variable->valeur
 
    protected:
 
 
    private:
        SOCKET sock;
        std::string stream;                         // chaine de transmission sur socket
        char session;                               // session memfile
        struct s_files {
            std::string fich;                       // chemin+nom du fichier
            std::string dico;                       // dictionnaire
            char id_n[2]; };                        // identifiant memfile
        std::map<std::string,s_files> files;        // association identifiant->structure
 
        struct s_vars {                             // dictionnaire decompose
            int nkey;
            std::string keys[10][10];
            std::string recs[80]; };
        std::map<std::string,s_vars> vars;          // association identifiant->dictionnaire decompose
 
 
        std::string convertHex(std::string s); // conversion hexa
        void readDic(std::string idf);
        void readRec(std::string idf,char* rec);
 
        std::string readStr(char* rec);
        std::string readFlt(char* rec);
        std::string readTab(char** rec, std::string d);
        int convData(std::string d,int p);
        int convKey(std::string idf,int k,int p=0);
        int convKeys(std::string idf,int p=0);
        int convRec(std::string idf,int p=0);
 
 
 
 
};
 
 
//void DLL_EXPORT SomeFunction(const LPCSTR sometext);
 
#ifdef __cplusplus
}
#endif
 
#endif // __MAIN_H__

Quand je veux utiliser la DLL via un autre "langage" (windev...), il me voit dans la DLL une fonction "_ZN7memfile6connexESsi"

En creant une dll de base dans codeblocks (sans passer par ma classe crée), il trouve bien la fonction crée par defaut de C::B.

quelqu'un comprend pourquoi?

Je devrais plutôt creer ma dll sans passer par une classe, tout mettre en global non?

08/02/2012, 11h03
Bousk

As-tu lu les liens indiquant la marche à suivre ?
Si oui, pourquoi utiliser la macro pour la fonction connex ? Il est stipulé que la macro doit être utilisé dans la déclaration de la classe uniquement, ce qui a pour effet d'exporter toute la classe et ses méthodes à la dll.

Par ailleurs, je ne connais pas windev et comment y intégrer ni utiliser une dll.