IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

delete héritage structure


Sujet :

C++

  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut delete héritage structure
    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.

  2. #2
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut
    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;

  3. #3
    Provisoirement toléré
    Profil pro
    Inscrit en
    Février 2008
    Messages
    439
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2008
    Messages : 439
    Points : 495
    Points
    495
    Par défaut
    Citation Envoyé par demss Voir le message
    //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.

  4. #4
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    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 :
    est illégal, et peut tout faire, de la fuite mémoire au plantage.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  5. #5
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut
    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.

  6. #6
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    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.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  7. #7
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut
    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 : 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
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  8. #8
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  9. #9
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut
    Merci JolyLoic pour ta précieuse aide.

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

    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
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  10. #10
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Citation Envoyé par demss Voir le message
    Merci JolyLoic pour ta précieuse aide.

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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  11. #11
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 519
    Points
    41 519
    Par défaut
    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).
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  12. #12
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    108
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 108
    Points : 59
    Points
    59
    Par défaut
    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.

  13. #13
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 519
    Points
    41 519
    Par défaut
    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 ?
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

Discussions similaires

  1. [AC-2007] Formulaire pour structure modélisée par héritage
    Par f-leb dans le forum IHM
    Réponses: 3
    Dernier message: 12/06/2009, 09h48
  2. Réponses: 5
    Dernier message: 21/11/2008, 14h43
  3. Héritage de structure en C
    Par Fred.77 dans le forum C
    Réponses: 12
    Dernier message: 03/11/2007, 19h33
  4. delete d'une structure
    Par mathher dans le forum C++
    Réponses: 7
    Dernier message: 20/04/2006, 15h20
  5. surcharge operateur delete et héritage
    Par Hervé dans le forum C++
    Réponses: 5
    Dernier message: 29/03/2006, 13h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo