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 :

Conversion d'un void *objet


Sujet :

C++

  1. #1
    Nouveau membre du Club
    Inscrit en
    Juin 2002
    Messages
    38
    Détails du profil
    Informations forums :
    Inscription : Juin 2002
    Messages : 38
    Points : 29
    Points
    29
    Par défaut Conversion d'un void *objet
    Bonjour,

    Pour un appel callback dans un trackbar d'opencv, ça fait 3 jours que j'essaie de convertir un objet void *adresse en un objet Myclass myobjet_dst, étant entendu que le *adresse pointe vers un objet de type Myclass myobjet_src.

    J'ai essayé
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    void ontrack(int param, void *adresse)		
    {
     
             Myclass *myobjet_dst = static_cast<Myclass*>(adresse);
    ...}

    ou encore

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    void ontrack(int param, void *adresse)		
    {
            Myclass& myobjet_dst = (Myclass&)(adresse)
    ...}

    et j'en passe.
    Faut-il créer un constructeur particulier pour Myclass, qui prendrait une adresse en paramètre d'entrée ?

    Je sèche sur ce problème.

    Merci par avance pour votre aide.

  2. #2
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Myclass *myobjet_dst = reinterpret_cast<Myclass*>(adresse);
    static_cast est pour les objets ayant une relation d'héritage entre eux, ou pour les types ayant défini des conversions implicites de la source à la cible.
    reinterpret_cast est pour "forcer" le cast d'un type à un autre (avec certaines règles, cependant, cf. la doc), déconseillé si on ne sait pas ce qu'on fait.
    Je ne parlerai pas du troisième qui n'a aucune utilité bien fondée
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  3. #3
    Nouveau membre du Club
    Inscrit en
    Juin 2002
    Messages
    38
    Détails du profil
    Informations forums :
    Inscription : Juin 2002
    Messages : 38
    Points : 29
    Points
    29
    Par défaut
    merci beaucoup pour ton aide et ta réponse plus que rapide.

  4. #4
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    static_cast est bien le cast officiel pour gérer les conversion depuis void* (probablement parce qu'il n'y a pas de garantie que sizeof(void*) == sizeof(T*)). Corrigé avec le C++11 on dirait.

    Le reinterpret_cast a vraiment corrigé le problème ? Je serai plutôt parti sur la piste d'un problème à l'appel.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  5. #5
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     Myclass& myobjet_dst = *((Myclass*)(adresse))
    Homer J. Simpson


  6. #6
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    Ne JA-MAIS faire de casts à la C en C++. Surtout quand des classes sont impliquées. Les chances pour que cela parte en cacahuète sont trop importantes. Un code qui marche peut planter après un refactoring. Donc oublis!

    Au mieux ici si tu veux une référence.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    void ontrack(int param, void *adresse)		
    {
        assert(addresse);
        Myclass & myobjet_dst = *static_cast<Myclass*>(adresse);
    }
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  7. #7
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Ne JA-MAIS faire de casts à la C en C++
    Regarder tous les codes type Unreal Engine 4 et autre qui ne veulent pas du RTTI, on cast à la C. Drivers on cast à la C, performance on cast à la C.
    Faut pas être cartésien comme ça. Faut savoir ce que l'on fait c'est tout.

    Et puis ca permet de donner du galon au développeur en comprenant les avantages et inconvénient de chacun.
    Homer J. Simpson


  8. #8
    Membre expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 739
    Points : 3 627
    Points
    3 627
    Par défaut
    Citation Envoyé par Astraya Voir le message
    autre qui ne veulent pas du RTTI, on cast à la C.
    Ceux qui ne veulent pas de RTTI n'utilise pas dynamic_cast. Il en reste toujours 3. De manière générale, dynamique_cast est une mauvaise idée.

    Citation Envoyé par Astraya Voir le message
    Drivers on cast à la C.
    Tu veux dire que dans les drivers écrit en C on utilise des casts C ? Faudrait en trouver un écrit en C++ pour vérifier.

    Citation Envoyé par Astraya Voir le message
    performance on cast à la C.
    Rien à voir, les casts sont compile-time.
    (Au delà de ça, je doute qu' un cast soit une bonne chose pour les performances.)

    Citation Envoyé par Astraya Voir le message
    Faut pas être cartésien comme ça. Faut savoir ce que l'on fait c'est tout.
    Question innocente: que fait un cast C en c++ ? En sachant que c'est entre autres un mélange de static_cast, reinterpret_cast et const_cast.

    Citation Envoyé par Astraya Voir le message
    Et puis ca permet de donner du galon au développeur en comprenant les avantages et inconvénient de chacun.
    Autant qu'utiliser malloc à la place de new. Perso, je vois très bien les avantages des casts C++: plus safe, plus explicite,
    Mais aucuns pour les casts C. À moins qu'accéder aux classes héritées de façon privée soit un avantage ?

  9. #9
    Expert éminent
    Avatar de Pyramidev
    Homme Profil pro
    Développeur
    Inscrit en
    Avril 2016
    Messages
    1 460
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : Avril 2016
    Messages : 1 460
    Points : 6 064
    Points
    6 064
    Par défaut
    Citation Envoyé par crazyfroggy Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    void ontrack(int param, void *adresse)		
    {
     
             Myclass *myobjet_dst = static_cast<Myclass*>(adresse);
    }
    Pourtant, dans la doc de static_cast, on peut lire :
    10) A prvalue of type pointer to void (possibly cv-qualified) can be converted to pointer to any type. If the value of the original pointer satisfies the alignment requirement of the target type, then the resulting pointer value is unchanged, otherwise it is unspecified. Conversion of any pointer to pointer to void and back to pointer to the original (or more cv-qualified) type preserves its original value.
    [...]
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    // 10. void* to any type
    void* voidp = &e;
    std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
    Chez moi, le code suivant compile :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    struct Foo {};
    void bar(void* adresse)		
    {
    	Foo* ptr = static_cast<Foo*>(adresse);
    }
    Citation Envoyé par Astraya Voir le message
    Regarder tous les codes type Unreal Engine 4 et autre qui ne veulent pas du RTTI, on cast à la C. Drivers on cast à la C, performance on cast à la C.
    En C++, le cast avec la syntaxe du C n'est pas plus performant !
    C'est seulement :
    • soit une combinaison implicite de const_cast, de static_cast et de reinterpret_cast,
    • soit une conversion que ne permettent pas les xxxxx_cast ci-dessus.

    Documentation :
    When the C-style cast expression is encountered, the compiler attempts to interpret it as the following cast expressions, in this order:
    a) const_cast<new_type>(expression);
    b) static_cast<new_type>(expression), with extensions: pointer or reference to a derived class is additionally allowed to be cast to pointer or reference to unambiguous base class (and vice versa) even if the base class is inaccessible (that is, this cast ignores the private inheritance specifier). Same applies to casting pointer to member to pointer to member of unambigous non-virtual base;
    c) static_cast (with extensions) followed by const_cast;
    d) reinterpret_cast<new_type>(expression);
    e) reinterpret_cast followed by const_cast.
    The first choice that satisfies the requirements of the respective cast operator is selected, even if it cannot be compiled (see example). If the cast can be interpreted in more than one way as static_cast followed by a const_cast, it cannot be compiled.
    In addition, C-style cast notation is allowed to cast from, to, and between pointers to incomplete class type. If both expression and new_type are pointers to incomplete class types, it's unspecified whether static_cast or reinterpret_cast gets selected.
    Edit : Grillé par jo_link_noir.

  10. #10
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Et bas je comprends pourquoi je ne venait plus sur le forum :p
    Donc pour vous malloc n'a rien a faire dans un programme C++....
    Tout comme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    (uint8*)::malloc(sizeof(CBuffer))
    Un void* perd la notion de const/volatile dont un C cast ne pause aucun problème.
    De plus niveau portabilité on en reparle :

    boost/smart_ptr/shared_ptr.hpp
    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
    #if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
        ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
        ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
     
    // g++ 2.9x doesn't allow static_cast<X const *>(void *)
    // apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
     
    template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
    {
        void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
        return const_cast<D *>(static_cast<D const *>(q));
    }
     
    #else
     
    template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
    {
        return static_cast<D *>(p._internal_get_deleter(BOOST_SP_TYPEID(D)));
    }
    #endif
    NB : RTTI et performance je pensais au dynamic_cast et pas au reinterpret_cast effectivement.
    Homer J. Simpson


  11. #11
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    Là on est sur des compilateurs qui prédatent le standard de 1998. On s'en fout un peu de la compatibilité avec ces bêtes.

    Un ligne importante dans les casts C: ils dégénèrent avec des déclarations anticipées. C'est de fait une excellente raison pour les bannir. Hors RTTI, static_cast et reinterpret_cast feront le même boulot et sans ambiguïté. Et dans le cas du RTTI ... n'en parlons même pas, ils ne peuvent pas se substituer à dynamic_cast. Ils en sont incapables.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  12. #12
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    http://en.cppreference.com/w/cpp/language/explicit_cast

    Les cast C fonctionne très bien avec les forward déclarations.
    In addition, C-style cast notation is allowed to cast from, to, and between pointers to incomplete class type. If both expression and new_type are pointers to incomplete class types, it's unspecified whether static_cast or reinterpret_cast gets selected.
    Homer J. Simpson


  13. #13
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    Pour toi "unspecified" veut dire "marche bien" ? :/

    Ta définition est pour le moins singulière: http://www.linguee.fr/anglais-franca...specified.html

    J'achète "marche à moitié". Mais "bien", certainement pas.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  14. #14
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    Citation Envoyé par Luc Hermitte Voir le message
    Pour toi "unspecified" veut dire "marche bien" ? :/
    Non juste que lorsque tu fais un cast à la C, apparemment, le compilateur le remplace par soit un static_cast soit un reinterpret_cast.

    Mais si les 2 sont des types incomplets, alors le compilateur fait ce qu'il veut: ce n'est pas spécifié.
    Dans un autre sens, si les 2 sont des types incomplets, le compilateur ne peut pas faire de magie

  15. #15
    Expert éminent sénior
    Avatar de Luc Hermitte
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2003
    Messages
    5 275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2003
    Messages : 5 275
    Points : 10 985
    Points
    10 985
    Par défaut
    Et là, plutôt que de la magie, c'est une erreur de compilation que j'attends.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média. Et de toutes façons, ma BAL sur dvpz est pleine...

  16. #16
    Membre expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 739
    Points : 3 627
    Points
    3 627
    Par défaut
    Citation Envoyé par Astraya Voir le message
    Et bas je comprends pourquoi je ne venait plus sur le forum :p
    Je te comprends, les gens sont aigris .

    Citation Envoyé par Astraya Voir le message
    Donc pour vous malloc n'a rien a faire dans un programme C++....
    Oui. malloc n'apporte pas les garanties qu'offre new, notamment celle d'allouer un type et non un espace mémoire: il est aisé de ne pas faire correspondre sizeof(T) avec le cast qui précède. Cela parait con, mais c'est une erreur difficile à diagnostiquer.
    De plus, l'utilisation de malloc oblige d'utiliser l'opérateur new pour la construction (emplacement new). L'oublier, c'est prendre un risque.
    Après, rien n'empêche d'utiliser ::operator new pour faire comme malloc: allouer un espace mémoire. Mais c'est un besoin très particulier où la mémoire n'est pas utilisé immédiatement. Les conteneurs de la SL le font à travers des allocateurs.
    Pour terminer ::operator new peut prendre des paramètres, le standard propose une version sans exception par exemple. Il est aussi possible d'interdire l'utilisation de new sur certains objets.

    Citation Envoyé par Astraya Voir le message
    Tout comme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    (uint8*)::malloc(sizeof(CBuffer))
    Clairement. Cela reprend ce que je disais juste au-dessus: le cast et la taille du type demandé peuvent ne pas correspondre. Reste que si c'est légitime, rien ne l'indique non plus.
    Je trouve beaucoup plus judicieux d'utiliser new uint8_t[sizeof(CBuffer)].

    Citation Envoyé par Astraya Voir le message
    Un void* perd la notion de const/volatile dont un C cast ne pause aucun problème.
    void ne perd pas le qualificatif, mais le type. Passer d'un void const * en T * est un problème.

    Un autre reproche du C-cast: il accepte sans broncher quasiment tous les changements qui peuvent intervenir en amont. Même quand ceux-ci invalident la suite comme l'ajout de const qui sont supprimés par le cast.

  17. #17
    Membre chevronné Avatar de Astraya
    Homme Profil pro
    Consommateur de café
    Inscrit en
    Mai 2007
    Messages
    1 042
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Consommateur de café
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Mai 2007
    Messages : 1 042
    Points : 2 232
    Points
    2 232
    Par défaut
    Mais ce qui m'agace par dessus tout c'est d'entendre des "jamais utiliser ca" de la part d'un développeur. Pour moi c'est du même niveau que "toujours utiliser ca" ( Le concept de la "balle en argent" mais à l'envers ).
    Alors le "jamais" ne devrais "jamais" (:p) avoir lieu, surtout pas dans un milieu comme le développement. Ça pu la programmation de SSII ce genre de discours.

    Quand je vois un void* et que je vois un (T*) derrière c'est tout à fait legit.

    Voila c'est tout c'était mon coup de gueule contre les jamais c'est pas bien blablabla...
    Homer J. Simpson


  18. #18
    Membre expert
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2011
    Messages
    739
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2011
    Messages : 739
    Points : 3 627
    Points
    3 627
    Par défaut
    En attendant, tu n'as n'as toujours pas donné un seul argument contre les casts C++ (sauf un problème de compatibilité avec les compilateurs d'il y a 20 ans qu'on se fout pas mal).
    Ni un seul argument en faveur du cast C.

  19. #19
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Perso j'ai un super argument en faveur du C-cast : écrire reinterpret_cast est d'une lourdeur, c'est long, chiant, y compris avec la complétion, je suis programmeur et flemmard, j'opte pour la facilité. Je me moque que ce soit "pas lisible pour bobdu42", je comprends le code que j'écris, ainsi que tous mes collègues qui travaillent avec, et bobdu42 ne lira jamais ce code, c'est tout ce qui importe.
    Favoriser reinterpret ou static ou le C-style, y'en a aucun qui a plus de sens qu'un autre. C'est tout juste de la religion à ce niveau. Et si tu forces un cast via un C-style cast qui est impossible, et qu'un static t'aurait signalé, tu ne peux t'en prendre qu'à toi-même. Et ouais c'est une merde à débuguer et retrouver ce genre de problème, ça tombe bien c'est notre boulot.
    Les interfaces en C ça existe, et passer n'importe quoi en void* n'est pas extraordinaire ni quelconque magie noire. En tous cas dans mon monde.
    D'ailleurs en pratique dans la pluaprt des cas on passera juste un trivial POD qui contiendra les pointeurs vers les classes nécessaires.

    dynamic, on s'en moque. Le RTTI est désactivé le plus souvent parce que c'est un gouffre à perf.

    De même qu'utiliser new[] quand on veut allouer un espace et non des objets au lieu de malloc n'apporte rien. Alors pourquoi faire un new uint8[...] ? Parce que new est du C++ et malloc du C ? Ridicule.

    Dans tous les cas vous avez sévèrement dérivé du sujet d'origine
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  20. #20
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    Citation Envoyé par Bousk Voir le message
    écrire reinterpret_cast est d'une lourdeur, c'est long, chiant, y compris avec la complétion,
    Il me semble que c'est justement fait pour : une écriture lourde, pour les 4 casts C++, pour que les développeurs ne les utilisent pas

    Tu es un "bon client"

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Conversion de XML en objet (JAXB en Java) ?
    Par elgaied dans le forum Qt
    Réponses: 0
    Dernier message: 11/02/2013, 16h10
  2. Cast void* - Objet C++
    Par LaMainSurLeKatana dans le forum C++
    Réponses: 5
    Dernier message: 24/08/2010, 14h09
  3. Conversion de string en Objet (zone de texte)
    Par Secco dans le forum VBA Access
    Réponses: 3
    Dernier message: 07/05/2008, 21h17
  4. Question bateau sur la conversion si possible d'objets
    Par kenny49 dans le forum Langage
    Réponses: 1
    Dernier message: 08/08/2007, 20h20
  5. Socket (SMTP) vers objet MimeMessage : conversion ?
    Par Loicb dans le forum Entrée/Sortie
    Réponses: 2
    Dernier message: 06/12/2004, 19h21

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