Discussion :

[mappy]

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

[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().

[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é.

[Médinoc]

Peut pas vraiment en dire plus sans code.

[mappy]

Le header

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();  
        }
 
 
}

[mappy]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[Médinoc]

Ton code de InitInstance() construit l'objet localement et le détruit aussitôt lorsque la fonction retourne.

[mappy]

Et que conseilles tu pour que je puisse conserver l'instance ?

[Médinoc]

Ben, en faire une variable membre. Directement ou par pointeur.
C'est un peu le B.A.BA du C++, non?

[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++

[mappy]

J'ai viré InitInstance pour ajouter Caller c=new Caller() dans CNewDLLApp::CNewDLLApp() mais aucun changement

[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.

[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...

[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.