Conversion EXE -> DLL en C++

Version imprimable

01/12/2014, 00h54
mappy

Conversion EXE -> DLL en C++

Bonjour,

J'ai converti un exe en dll. J'ai ajouté une classe qui expose les méthodes que je souhaite appeler depuis l'extérieur.

Par contre quand j'appelle les objets, ils semblent ne pas être initialisés et j'ai l'erreur : "Tentative de lecture ou d'écriture de mémoire protégée. Cela indique souvent qu'une autre mémoire est endommagée"

Je pense que le problème vient du fait que mon objet n'est pas initialisé. Le constructeur n'est pas appelé.

Pour info, je travaille habituellement en c#, rarement en c++

Faut il ajouter un DLLMAIN ?

Merci d'avance
01/12/2014, 10h26
Médinoc

Si tu ne fais pas des trucs sophistiqués (Thread-Local Storage) ou des trucs qui dépendent du HINSTANCE/HMODULE (fenêtres, boîtes de dialogue, etc.) tu n'as généralement pas besoin d'ajouter un DllMain().
01/12/2014, 14h10
mappy

Merci pour ta réponse Médinoc,

J'ai fait un wrapper pour communiquer c# <->C++.

D'après mes tests, la dll appelle le destructeur implicitement. J'ai donc une perte de contexte et une erreur de mémoire.

Je ne comprends pas pourquoi le destructeur du wrapper est appelé.
01/12/2014, 14h25
Médinoc

Peut pas vraiment en dire plus sans code.

Le header

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
 
#pragma once
#include "Readers.h"
#include <iostream> 
#include <fstream>
 
using namespace std;
 
class Caller
{
protected :
 __declspec(dllexport)
  bool Connect();
 
 
 
public :
 
 CReaders   m_cReaders;
 
static void WriteToLog(CString mess);
Caller();
~Caller();
 
private :
 
 
 
};

La classe

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
 
#include "stdafx.h"
#include "Caller.h"
 
 using namespace std;
bool Caller::Connect() 
{
   // cette méthode est appelée via un lien externe de la dll
 // l'instance n'existe plus
	if (  this->m_cReaders.Connect(2))
	{
       WriteToLog("Connection OK!!!!");
	}
 
 
return true;
 
}
 
 
 
Caller::Caller()
{
	 if (this->m_cReaders.CreateReaderList())
	{   
       WriteToLog("m_cReaders.CreateReaderList()OK!!!!");
 
 	}
 
	// Ici la connexion est ok puisque l'instance existe
    if (  this->m_cReaders.Connect(2))
	{
       WriteToLog("Connection OK!!!!");
	}
 
}
 
Caller::~Caller()
{
	//if (this->m_cReaders.Disconnect())
	//{
	//	WriteToLog("Déconnection OK");
	//}
}
 
void Caller::WriteToLog(CString mess)
{
	ofstream fichier("c:\\temp\\test.txt", ios::app);
 
	if(fichier) 
       {       
            fichier << mess << endl;
                fichier.close();  
        }
 
 
}

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
 
 
// NewDLL.cpp*: définit les fonctions d'initialisation pour la DLL.
//
 
#include "stdafx.h"
#include "NewDLL.h"
#include "Caller.h"
 
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
 
//
//TODO*: si cette DLL est liée dynamiquement aux DLL MFC,
//		toute fonction exportée de cette DLL qui appelle
//		MFC doit avoir la macro AFX_MANAGE_STATE ajoutée au
//		tout début de la fonction.
//
//		Par exemple*:
//
//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
//		{
//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
//			// corps de fonction normal ici
//		}
//
//		Il est très important que cette macro se trouve dans chaque
//		fonction, avant tout appel à MFC. Cela signifie qu'elle
//		doit être la première instruction dans la 
//		fonction, avant toute déclaration de variable objet
//		dans la mesure où leurs constructeurs peuvent générer des appels à la DLL
//		MFC.
//
//		Consultez les notes techniques MFC 33 et 58 pour plus de
//		détails.
//
 
// CNewDLLApp
 
BEGIN_MESSAGE_MAP(CNewDLLApp, CWinApp)
END_MESSAGE_MAP()
 
 
// construction CNewDLLApp
 
CNewDLLApp::CNewDLLApp()
{
	// TODO*: ajoutez ici du code de construction,
	// Placez toutes les initialisations significatives dans InitInstance
}
 
 
// Seul et unique objet CNewDLLApp
 
CNewDLLApp theApp;
 
 
// initialisation de CNewDLLApp
 
BOOL CNewDLLApp::InitInstance()
{
	CWinApp::InitInstance();
Caller c;
	return TRUE;
}

01/12/2014, 14h39
Médinoc

Ton code de InitInstance() construit l'objet localement et le détruit aussitôt lorsque la fonction retourne.
01/12/2014, 14h41
mappy

Et que conseilles tu pour que je puisse conserver l'instance ?
01/12/2014, 14h55
Médinoc

Ben, en faire une variable membre. Directement ou par pointeur.
C'est un peu le B.A.BA du C++, non?
01/12/2014, 15h07
mappy

En fait je travaille en C# et je n'ai pas le même niveau en C++ et je n'ai donc pas la notion de l'intialisation des variables en c++
01/12/2014, 15h41
mappy

J'ai viré InitInstance pour ajouter Caller c=new Caller() dans CNewDLLApp::CNewDLLApp() mais aucun changement
02/12/2014, 00h54
bacelar

Et qui va désallouer la mémoire ?

Comme je te l'ai déjà dit, tu seras bien plus à l'aise en C++/CLI.
02/12/2014, 09h34
mappy

Hello,

Le .net n'est qu'une plateforme de test. La finalité, c'est un exe fait en Delphi. le CLI est il toujours approprié ?

Même si MFC ne semble pas être la bonne solution, j'aimerais tout de même savoir pourquoi la dll charge correctement et appelle le destructeur...
02/12/2014, 15h22
bacelar

1- Au moment du chargement de la Dll, le chargeur de l'OS appelle une fonction auto-générée par le compilateur pour créer toutes les variables globales de la Dll.
2- Puis le chargeur de l'OS appelle la fonction DllMain que le développeur de la Dll est en charge de faire, si nécessaire.
3- Puis le chargeur de l'OS rend la main à l'exécutable pour qu'il appelle le code dans la Dll.

Je ne sais pas ce que vous "regardez" mais c'est très certainement en phase 1 et pas en phase 3. :weird: