Discussion :

[demss]

J'ai une question?

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
 
// J'utilise Visual C++ .Net 2003.
// Exemple: J'ai une structure dérivée.
 
struct Structure_Derived: public Structure_Origine
{
      int nombre;
}
 
// Je créer une structure. et 2 pointeurs.
 
Structure_Derived* DER;
Structure_Origine* ORI;
 
DER = new Structure_Derived;
ORI = DER;
 
 
// ces 2 façons de détruire la Structure sont-t-elle égale?
// y a-t-il des fuites de mémoire avec une des 2 façons?
 
// facon 1.
delete DER;
 
// facon 2.
delete ORI;

Merci.

[demss]

désolé j'ai oublié de convertir. pour cette partie.

Je créer une structure. et 2 pointeurs.

Code :

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

1
2
3
4
5
Structure_Derived* DER;
Structure_Origine* ORI;
 
DER = new Structure_Derived;
ORI = (Structure_Origine*)DER;

[corrector]

//désolé j'ai oublié de convertir. pour cette partie.

Surtout, ce que tu as oublié, c'est la définition de Structure_Origine.

Bref, un programme complet (et compilable), c'est l'idéal dans les cas simples comme celui-ci.

[JolyLoic]

Code :

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

1
2
ORI = (Structure_Origine*)DER;
ORI = DER;

Ces deux code sont strictement équivalents dans la cas que tu nous montre. Un pointeur sur un classe dérivée est silencieusement castable en pointeur sur classe de base.

Pour la destruction, à condition que Structure_Origine possède un destructeur virtuel, les deux codes sont identiques. Si ce n'est pas le cas, le code :

Code :

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

delete ORI;

est illégal, et peut tout faire, de la fuite mémoire au plantage.

[demss]

Merci JolyLoic pour ta réponce.

ta raison j'avais pas besoin de convertir moi même.

Je me demandais si il détruisait juste la partie Structure_Origine avec "delete ORI;" et la partie dérivé aurai été une fuite de mémoire.



Si j'ai bien comprit:
avec "delete ORI;" il détruit pas la même chose que "delete DER;".
si la structure Structure_Origine a pas de destructeur virtuel.


Si ma Structure_Origine =

Code :

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

1
2
3
4
5
6
7
 
struct Structure_Origine
{
     int jaja;
     float lala;
     ~ Structure_Origine();
};

les 2 delete son équivalent.


et Si ma Structure_Origine =

Code :

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

1
2
3
4
5
6
 
struct Structure_Origine
{
     int jaja;
     float lala;
};

avec "delete ORI;" il y a pas de fuite de mémoire.
et avec "delete DER;" il y a fuite de mémoire.



Ma vrai structure origine est la structure D3DXMESHCONTAINER dans DirectX.
et dans un exemple du SDK cette structure est dérivé D3DXMESHCONTAINER_DERIVED.

ca création est un new D3DXMESHCONTAINER_DERIVED.

pour ca destruction elle est retrouner par un pointeur de sa struct origine.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
destroy(D3DXMESHCONTAINER* meshc)
{
 
// elle est convertie en sa dérivé.
D3DXMESHCONTAINER_DERIVED* Meshderi = (D3DXMESHCONTAINER_DERIVED*) meshc;
 
// elle est délité comme ca.
delete Meshderi;
}

allor il y a fuite de mémoire ici.
si il aurai mit a la place "delete meshc;". tout aurait été OK.


Dite moi si j'ai bien comprit.

Merci.

[JolyLoic]

Formellement, il ne s'agit pas simplement d'une fuite de mémoire, mais d'une comportement indéterminé, qui peut donc avoir des conséquences plus grave. En pratique, avec des simples structures, il y a des chances que ce comportement indéterminé se transmute en simple fuite de mémoire.

Dans le code que tu montres, il y a justement l'effet opposé. Pour éviter ce comportement indéterminé, le code va explicitement caster vers le type dérivé avant de détruire. Dans le code en question, c'est s'il avait dait un simple "delete meshc;" que le comportement indéterminé aurait eu lieu.

[demss]

Merci pour vos réponce.

D'après ce que je peux voir, il est impossible de savoir si la structure D3DXFRAME_DERIVED est bien délité.


J'ai trouver ca dans d3dx9anim.h dans le dossier include du SDK DirectX 9.0.
pour la classe de basse ou l'interface COM de base.

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
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
 
 
#undef INTERFACE
#define INTERFACE ID3DXAllocateHierarchy
 
//----------------------------------------------------------------------------
// This interface is implemented by the application to allocate/free frame and
// mesh container objects. Methods on this are called during loading and
// destroying frame hierarchies
//----------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
// ID3DXAllocateHierarchy ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
DECLARE_INTERFACE(ID3DXAllocateHierarchy)
{
    // ID3DXAllocateHierarchy
 
	//------------------------------------------------------------------------
	// CreateFrame:
	// ------------
	// Requests allocation of a frame object.
	//
	// Parameters:
	//  Name
	//		Name of the frame to be created
	//	ppNewFrame
	//		Returns returns the created frame object
	//
	//------------------------------------------------------------------------
    STDMETHOD(CreateFrame)(THIS_ LPCSTR Name, 
                            LPD3DXFRAME *ppNewFrame) PURE;
 
	//------------------------------------------------------------------------
	// CreateMeshContainer:
	// --------------------
	// Requests allocation of a mesh container object.
	//
	// Parameters:
	//  Name
	//		Name of the mesh
	//	pMesh
	//		Pointer to the mesh object if basic polygon data found
	//	pPMesh
	//		Pointer to the progressive mesh object if progressive mesh data found
	//	pPatchMesh
	//		Pointer to the patch mesh object if patch data found
	//	pMaterials
	//		Array of materials used in the mesh
	//	pEffectInstances
	//		Array of effect instances used in the mesh
	//	NumMaterials
	//		Num elements in the pMaterials array
	//	pAdjacency
	//		Adjacency array for the mesh
	//	pSkinInfo
	//		Pointer to the skininfo object if the mesh is skinned
	//	pBoneNames
	//		Array of names, one for each bone in the skinned mesh. 
	//		The numberof bones can be found from the pSkinMesh object
	//	pBoneOffsetMatrices
	//		Array of matrices, one for each bone in the skinned mesh.
	//
	//------------------------------------------------------------------------
    STDMETHOD(CreateMeshContainer)(THIS_ LPCSTR Name, LPD3DXMESHDATA pMeshData, 
                            LPD3DXMATERIAL pMaterials, LPD3DXEFFECTINSTANCE pEffectInstances, DWORD NumMaterials, 
                            DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo, 
                            LPD3DXMESHCONTAINER *ppNewMeshContainer) PURE;
 
	//------------------------------------------------------------------------
	// DestroyFrame:
	// -------------
	// Requests de-allocation of a frame object.
	//
	// Parameters:
	//  pFrameToFree
	//		Pointer to the frame to be de-allocated
	//
	//------------------------------------------------------------------------
    STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree) PURE; 
 
	//------------------------------------------------------------------------
	// DestroyMeshContainer:
	// ---------------------
	// Requests de-allocation of a mesh container object.
	//
	// Parameters:
	//  pMeshContainerToFree
	//		Pointer to the mesh container object to be de-allocated
	//
	//------------------------------------------------------------------------
    STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree) PURE; 
};

J'aimerai savoir si je change le code pour ça si ça assure un bon delete à 100 pour 100 pour la Structure dérivé.

Code :

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

1
2
3
4
5
6
7
8
9
 
HRESULT CAllocateHierarchy::DestroyFrame(LPD3DXFRAME pFrameToFree) 
{
    D3DXFRAME_DERIVED *pFrameToFree_derived = (D3DXFRAME_DERIVED*)pFrameToFree;
 
    SAFE_DELETE_ARRAY( pFrameToFree_derived->Name );
    SAFE_DELETE( pFrameToFree_derived);
    return S_OK; 
}

Merci.

[Médinoc]

Wow, ça, c'est pas commun: Une interface qui ne dérive pas de IUnknown. Donc, dans cette version de DirectX, ce ne serait pas une interface COM ?