delete héritage structure

Version imprimable

J'ai une question?

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

15/03/2008, 03h47
demss
désolé j'ai oublié de convertir. pour cette partie.

Je créer une structure. et 2 pointeurs.
Code:

1 2 3 4 5 Structure_Derived* DER; Structure_Origine* ORI; DER = new Structure_Derived; ORI = (Structure_Origine*)DER;
15/03/2008, 05h26
corrector

Citation:

Envoyé par demss

//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.
15/03/2008, 10h16
JolyLoic
Code:

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:

delete ORI;

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

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:

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:

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:

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.

16/03/2008, 22h07
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.

Merci JolyLoic pour ta réponce.

Mais je pense pas que la structure D3DXMESHCONTAINER de DirectX ai un destructeur virtuel. Allor ca crée tu un problème?

LPD3DXMESHCONTAINER est un pointeur = à D3DXMESHCONTAINER*

voici le vrai code:

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
HRESULT CAllocateHierarchy::DestroyMeshContainer(LPD3DXMESHCONTAINER pMeshContainerBase)
{
    UINT iMaterial;
 
    D3DXMESHCONTAINER_DERIVED *pMeshContainer = (D3DXMESHCONTAINER_DERIVED*)pMeshContainerBase;
 
    SAFE_DELETE_ARRAY( pMeshContainer->Name );
    SAFE_DELETE_ARRAY( pMeshContainer->pAdjacency );
    SAFE_DELETE_ARRAY( pMeshContainer->pMaterials );
    SAFE_DELETE_ARRAY( pMeshContainer->pBoneOffsetMatrices );
 
    // release all the allocated textures
    if (pMeshContainer->ppTextures != NULL)
    {
        for (iMaterial = 0; iMaterial < pMeshContainer->NumMaterials; iMaterial++)
        {
            SAFE_RELEASE( pMeshContainer->ppTextures[iMaterial] );
        }
    }
 
    SAFE_DELETE_ARRAY( pMeshContainer->ppTextures );
    SAFE_DELETE_ARRAY( pMeshContainer->ppBoneMatrixPtrs );
    SAFE_RELEASE( pMeshContainer->pBoneCombinationBuf );
    SAFE_RELEASE( pMeshContainer->MeshData.pMesh );
    SAFE_RELEASE( pMeshContainer->pSkinInfo );
    SAFE_RELEASE( pMeshContainer->pOrigMesh );
    SAFE_DELETE( pMeshContainer );
    return S_OK;
}

dans le même exemple du SDK il y a une autre structure D3DXFRAME
qui est dérivé D3DXFRAME_DERIVED.

ca création est un new D3DXFRAME_DERIVED.

Code:

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

c'est c'est 2 destructions de structure différente qui me mélange.
SAFE_DELETE( pMeshContainer ); et SAFE_DELETE( pFrameToFree );

dans un cas il caste en sa dérivé et dans l'autre cas non.

le quelle des 2 est correctes.

Merci.

17/03/2008, 00h22
JolyLoic
Si j'ai bien compris, on a donc :
D3DXMESHCONTAINER dérivé en D3DXMESHCONTAINER_DERIVED
D3DXFRAME dérivé en D3DXFRAME_DERIVED

et du code équivalent à :
Code:

1 2 3 4 5 6 D3DXMESHCONTAINER *o1 = new D3DXMESHCONTAINER_DERIVED(); D3DXFRAME *o2 = new D3DXFRAME_DERIVED(); delete static_cast<D3DXMESHCONTAINER_DERIVED*>(o1); //1 delete o2; //2
S'il y a des destructeurs virtuels dans les classes de base, les lignes 1 et 2 sont correctes.

Sinon, 1 est correct, mais 2 est un comportement indéfini.

Merci JolyLoic pour ta précieuse aide.

Dans la classe de base il y a pas de destructeur virtuel.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class CAllocateHierarchy: public ID3DXAllocateHierarchy
{
public:
    STDMETHOD(CreateFrame)(THIS_ LPCTSTR Name, LPD3DXFRAME *ppNewFrame);
    STDMETHOD(CreateMeshContainer)(THIS_ LPCTSTR Name, LPD3DXMESHDATA pMeshData,
                            LPD3DXMATERIAL pMaterials, LPD3DXEFFECTINSTANCE pEffectInstances, DWORD NumMaterials, 
                            DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo, 
                            LPD3DXMESHCONTAINER *ppNewMeshContainer);
    STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree);
    STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER pMeshContainerBase);
    CAllocateHierarchy(CMyD3DApplication *pApp) :m_pApp(pApp) {}
 
public:
    CMyD3DApplication* m_pApp;
};

Alors pour être sure que le deuxième est OK. Je dois changer le code pour.

Code:

1
2
3
4
5
6
7
8
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.

17/03/2008, 07h01
JolyLoic

Citation:

Envoyé par demss

Merci JolyLoic pour ta précieuse aide.

Dans la classe de base il y a pas de destructeur virtuel.

Code:

class CAllocateHierarchy: public ID3DXAllocateHierarchy

Pas si sur... Ta classe de base hérite de la classe ID3DXAllocateHierarchy, qui visiblement est prévue pour être utilisée comme classe de base (c'est je crois une interface au sens COM du terme). Il y a donc lieu de parier que ID3DXAllocateHierarchy possède un destructeur virtuel (j'ai tenté de vérifier, mais sans les .h sous la main, sachant que cette classe est décrite à base de macros diverses, difficile), et que par conséquent, le destructeur de CAllocateHierarchy est implicitement virtuel lui aussi.
17/03/2008, 09h26
Médinoc

Si jamais ID3DXAllocateHierarchy est une interface COM, alors il ne faut surtout pas la détruire avec delete.
Mais je doute qu'elle en soit une, car la classe dérivée ne redéfinit pas les méthodes de l'interface IUnknown...

Edit: Pourtant, d'après l'ancienne aide, c'en est une, et elle dérive bel et bien de IUnknown. Il ne faudrait donc pas la détruire avec delete, mais en appelant sa méthode Release() (qui contient un delete this). Toutefois, l'aide la plus récente n'en fait aucune mention, et je n'ai pas le SDK sous la main pour vérifier...
Edit2: Une autre page de l'aide la plus récente indique qu'il s'agit d'interface COM, donc c'est Release() qu'il faut utiliser (ou sans doute SAFE_RELEASE).

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:

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:

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.

17/03/2008, 22h31
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 ?