Générer une DLL

Version imprimable

1 pièce(s) jointe(s)

Générer une DLL

Bonjour,

Pouvez-vous me dire comment puis-je transformer ce script afin d'en générer un fichier *.DLL ?

Il s'agit d'une DLL avec pour données d'entrée : moyenne et sigma et en données de sortie : x1 et x2.

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
 
// vargauss.cpp*: définit les fonctions exportées pour l'application DLL.
//
 
#include "stdafx.h"
#include <windows.h>
#include <cstdlib>
#include <iomanip> 
#include <stdlib.h>
#include <ctime>
 
#include <cmath>
#include <stdio.h>
 
 
//#include <vector>
 
 
// *************************************
double randomUniform (double _iMin,double _iMax)
{
// return (_iMin + (rand () % (_iMax-_iMin+1)));
return ((_iMax-_iMin)*(rand()/(double)RAND_MAX)+_iMin);
}
// *************************************
void boxMuller(double &px1,double &px2, double _moyenne, double _sigma)
{
 
double U1=randomUniform(0,1);
double U2=randomUniform(0,1);
const double g_Pi = 3.14159265358979323846;
 
px1 = sqrt(-2 * log(U2)) * cos(2 * g_Pi * U1) * _sigma + _moyenne;
px2 = sqrt(-2 * log(U2)) * sin(2 * g_Pi * U1) * _sigma + _moyenne;
 
}
 
// ++++++++++++++++++++++++++++++++++++++++
int main(int argc)
{
	srand(time(NULL));
	double moyenne = 0;
	double sigma = 10/3;
	double x1, x2;
	boxMuller(x1,x2,moyenne,sigma) ;
 
	return 0; 
}

Avec Visual Express 2010, j'ai copier / coller la syntaxe d'une ébauche qui tourne en tant que programme sous c++.

Pièce jointe 223927

Merci

03/11/2016, 09h37
cpcdos

1 pièce(s) jointe(s)

Salut,

Dans les propriétés du projet Visual studio, tu peux choisir le Type de sortie, je pense que tu es en console ? Choisis "Bibliothèque de classes"
Pièce jointe 223940
J'ai Visual Studio 2015 pro, je sais plus si 2010 a la même tête :?

Et une biblo n'a pas de point d'entré, en gros ton int main(int argc) ne doit pas exister. Renomme le en int __main() par exemple

Ceci peut t'aider d'avantage https://msdn.microsoft.com/fr-fr/library/ms235636.aspx
03/11/2016, 11h25
Médinoc

Attention, la dropdown sur ta capture d'écran, c'est pour .Net.
Par contre, le lien est bon.
03/11/2016, 16h36
macErmite

Citation:

Envoyé par cpcdos

(...)

Ceci peut t'aider d'avantage https://msdn.microsoft.com/fr-fr/library/ms235636.aspx

Merci pour ce lien.

L'exemple de ce lien fait appel à une seule variable à retourner par le biais de return . Comment faire lorsque la dll doit renvoyer 2 variables ?
03/11/2016, 16h55
Bousk

Citation:

Envoyé par macErmite

Comment faire lorsque la dll doit renvoyer 2 variables ?

Si tu es en C++, que tu développes une DLL ou un programme, ou n'importe quoi, tu ne peux retourner qu'une seule valeur.
Que certains langages utilisent des structures pour masquer ce fait et donner l'illusion de retourner 2 valeurs n'y change rien.
03/11/2016, 17h32
Médinoc

Citation:

Envoyé par macErmite

Merci pour ce lien.

L'exemple de ce lien fait appel à une seule variable à retourner par le biais de return . Comment faire lorsque la dll doit renvoyer 2 variables ?

Elle prend au moins l'une des deux variables par référence ou par pointeur.
Si tu veux maintenir une interface "C" (pour être compatible avec d'autres langages que le C++, ou même compatible avec le C++ compilé par d'autres compilateurs) alors ce sera par pointeur.

Code pour 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// VarAleaGauss.cpp*: définit les fonctions exportées pour l'application DLL.
//
 
#include "stdafx.h"
 
#include <windows.h>
#include <tchar.h>
#include <iostream>       // std::cout
#include <string>         // std::string
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <iomanip> 
#include <stdlib.h>
#include <ctime>
 
#include <cmath>
#include <limits>
 
#include <stdio.h>
#include <conio.h>
#include <vector>
 
using namespace std;
double randomUniform (double _iMin,double _iMax)
{
// return (_iMin + (rand () % (_iMax-_iMin+1)));
return ((_iMax-_iMin)*(rand()/(double)RAND_MAX)+_iMin);
}
// *************************************
void boxMuller(double &px1,double &px2, double _moyenne, double _sigma)
{
 
double U1=randomUniform(0,1);
double U2=randomUniform(0,1);
const double g_Pi = 3.14159265358979323846;
 
px1 = sqrt(-2 * log(U2)) * cos(2 * g_Pi * U1) * _sigma + _moyenne;
px2 = sqrt(-2 * log(U2)) * sin(2 * g_Pi * U1) * _sigma + _moyenne;
 
// cout << "--->  x1 :" << *px1  << " x2 :" << *px2 << endl ;
 
}
 
extern "C" __declspec(dllexport) double *VarAleaGaussTirage(double moyenne, double sigma)
{
	int const taille = 2 ;
	double data[taille];
 
	double px1, px2;
	srand(time(NULL));
 
	boxMuller(px1,px2,moyenne,sigma) ;
	data[1] = px1;
	data[2] = px2;
 
	return data;
}

VC++ ne trouve pas d'erreur lors de la compilation et la génération des fichiers lib et dll.

Puis j'essaie de tester cette dll dans un programme :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// stdafx.h*: fichier Include pour les fichiers Include système standard,
// ou les fichiers Include spécifiques aux projets qui sont utilisés fréquemment,
// et sont rarement modifiés
//
 
#pragma once
 
#include "targetver.h"
 
#include <stdio.h>
#include <tchar.h>
 
#pragma comment (lib, "VarAleaGauss.lib")
extern "C" __declspec(dllimport) double *VarAleaGaussTirage(double moyenne, double sigma);
 
 
// TODO: faites référence ici aux en-têtes supplémentaires nécessaires au programme

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
 
// DLL_test.cpp*: définit le point d'entrée pour l'application console.
//
 
 
#include "stdafx.h"
 
#include <windows.h>
#include <tchar.h>
#include <iostream>       // std::cout
#include <string>         // std::string
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <iomanip> 
#include <stdlib.h>
#include <ctime>
 
#include <cmath>
#include <limits>
 
#include <stdio.h>
#include <conio.h>
#include <vector>
 
using namespace std;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
		int const cycle = 10000;
	double moyenne = 0;
	double sigma = 10/3;
 
	int const taille = 2 ;
	vector<double> resultat(taille);
 
	srand(time(NULL));
 
/*TIRAGE DE VALEUR ALEATOIRE*/
 
	resultat = VarAleaGaussTirage(moyenne, sigma);
 
	cout << "x1 : " << resultat[1] << "   x2 : " << resultat[2] << endl ;
 
	system("PAUSE");
 
	return 0;
}

Et bien-sûr cela ne fonctionne pas ... Je ne trouve pas de tuto complet pour generer/exploiter des dll ...

Pouvez-vous m'apporter vos remarques pour débloquer cette situation.

Merci

Modification du fichier 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// VarAleaGauss.cpp*: définit les fonctions exportées pour l'application DLL.
//
 
#include "stdafx.h"
 
#include <windows.h>
#include <tchar.h>
#include <iostream>       // std::cout
#include <string>         // std::string
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <iomanip> 
#include <stdlib.h>
#include <ctime>
 
#include <cmath>
#include <limits>
 
#include <stdio.h>
#include <conio.h>
#include <vector>
 
using namespace std;
double randomUniform (double _iMin,double _iMax)
{
// return (_iMin + (rand () % (_iMax-_iMin+1)));
srand(time(NULL));
return ((_iMax-_iMin)*(rand()/(double)RAND_MAX)+_iMin);
}
// *************************************
void boxMuller(double &px1,double &px2, double _moyenne, double _sigma)
{
 
double U1=randomUniform(0,1);
double U2=randomUniform(0,1);
const double g_Pi = 3.14159265358979323846;
 
px1 = sqrt(-2 * log(U2)) * cos(2 * g_Pi * U1) * _sigma + _moyenne;
px2 = sqrt(-2 * log(U2)) * sin(2 * g_Pi * U1) * _sigma + _moyenne;
 
// cout << "--->  x1 :" << *px1  << " x2 :" << *px2 << endl ;
 
}
 
extern "C" __declspec(dllexport) double *VarAleaGaussTirage(double moyenne, double sigma)
{
	int const taille = 2 ;
	double *data = new double[taille];
 
	double px1, px2;
 
	boxMuller(px1,px2,moyenne,sigma) ;
	data[1] = px1;
	data[2] = px2;
 
	return data;
}

Modification du fichier "client" :

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
 
// DLL_test.cpp*: définit le point d'entrée pour l'application console.
//
 
 
#include "stdafx.h"
 
#include <windows.h>
#include <tchar.h>
#include <iostream>       // std::cout
#include <string>         // std::string
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <iomanip> 
#include <stdlib.h>
#include <ctime>
 
#include <cmath>
#include <limits>
 
#include <stdio.h>
#include <conio.h>
#include <vector>
 
using namespace std;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
	int cycle = 10;
	double moyenne = 0;
	double sigma = 10/3;
 
	int const taille = 2 ;
	double *resultat = new double[taille] ;
 
/*TIRAGE DE VALEUR ALEATOIRE*/
 
	for(int i=0;i<cycle;i++)
	{
	resultat = VarAleaGaussTirage(moyenne, sigma);
	cout << "x1 : " << resultat[1] << "   x2 : " << resultat[2] << endl ;
	}
 
	system("PAUSE");
 
	return 0;
}

Il n'y a plus d'erreurs, cependant la boucle affiche 10x les mêmes valeurs ...

Citation:

la boucle affiche 10x les mêmes valeurs

Réfléchis à ce que fait srand(time(NULL)). Puis réfléchis à ce qui se passe si tu l'appelles plusieurs fois dans la même seconde.
Au passage, il faut faire gaffe si tu appelles srand() dans une DLL: dépendant des options de compilation et d'édition de liens, la graine aléatoire est ou non partagée entre l'exe et les dll... (par défaut sous Visual, elle l'est, donc tu pourrais juste appeler srand() au début de ton main())

De plus:
Les indices des tableaux commencent à zéro en C, pas à 1. Pour un tableau de deux cases, tab[2] est en dehors du tableau.
Ton code fait des "fuites de mémoire" en boucle, car il n'arrête pas d'"oublier" la valeur du pointeur résultat sans le désallouer au préalable...
Pour désallouer un tableau alloué dans une DLL, il est conseillé d'exporter une fonction qui le désalloue (ici, une fonction qui fait un delete[] resultat) pour éviter les conflits de version.
En fait, pourquoi passer par un tableau? Tu pourrais directement exporter la fonction boxMuller(), ou si tu veux une interface C, une fonction où les références sont remplacées par des pointeurs:
Code:

1 2 3 4 5 6 7 8 9 extern "C" __declspec(dllexport) void VarAleaGaussTirage(double moyenne, double sigma, double *pResultat1, double *pResultat2) { double px1, px2; boxMuller(px1,px2,moyenne,sigma) ; if(pResultat1 != nullptr) *pResultat1 = px1; if(pResultat2 != nullptr) *pResultat2 = px2; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int _tmain(int argc, _TCHAR* argv[]) { int cycle = 10; double moyenne = 0; double sigma = 10.0/3.0; //Attention, il faut une division flottante si tu veux un vrai résultat double /*TIRAGE DE VALEUR ALEATOIRE*/ for(int i=0;i<cycle;i++) { double resultat1, resultat2; VarAleaGaussTirage(moyenne, sigma, &resultat1, &resultat2); cout << "x1 : " << resultat[1] << " x2 : " << resultat[2] << endl ; } system("PAUSE"); return 0; }