Partage
  • Partager sur Facebook
  • Partager sur Twitter

Références

et pointeurs

    9 juin 2007 à 12:37:48

    Bonjour, je suis en train d'apprendre le c++ et j'aimerais savoir quelle est la différence entre les pointeurs et les références A PART L'ECRITURE qui est simplifiée :)
    • Partager sur Facebook
    • Partager sur Twitter
      9 juin 2007 à 14:37:21

      Il n'y en a qu'une:
      une référence c'est un pointeur constant que l'on peut manipuler avec plus de facilité qu'un pointeur.
      • Partager sur Facebook
      • Partager sur Twitter
        9 juin 2007 à 16:42:39

        Euh... À part l'écriture il n'y a absolument aucune différence... Mais alors vraiment aucune. En général, on utilise les références comme arguments de fonctions ou valeur de retour, donc le fait d'ajouter l'esperluette & permet de ne pas avoir à rajouter des * ou & à plusieurs endroits. Donc à part au niveau écriture, il n'y a absolument aucune différence, par derrière c'est gérer exactement de la même façon, à tel point que les instructions assembleur sont identiques.
        • Partager sur Facebook
        • Partager sur Twitter
        Anonyme
          9 juin 2007 à 17:45:36

          Une référence est un alias sur un objet.
          C'est donc l'objet lui même.
          Quand on manipule l'alias ,on manipule l'objet.
          Et vice-versa.

          Un pointeur est une autre variable différente de l'objet dont la valeur est l'adresse de l'objet.

          Enfin un pointeur peut être aloué/réaloué.
          Pas une référence (elle doit forcément être mise sur un objet valide).

          Il y'a donc une diférence.

          Plus d'info :
          http://c.developpez.com/faq/cpp/?page=references#DEFINITION_reference

          • Partager sur Facebook
          • Partager sur Twitter
            9 juin 2007 à 18:47:36

            Et une référence ne peut pas être initialisée à NULL, alors qu'un pointeur peut l'être ;).

            "Euh... À part l'écriture il n'y a absolument aucune différence..."
            Donc non, il y a quand même des différences ;)

            Par exemple, une erreur fréquente consiste à renvoyer une référence d'une fonction sur un objet alloué sur la pile :

            MaClasse & maFunction ()
            {
            MaClasse monObjet;
            return monObjet;
            }

            Ici on renvoit une référence vers un objet alloué sur la pile, or le destructeur de MaClasse sera appelée juste après le return, donc la référence va être l'alias d'un objet qui n'existe plus...

            Alors qu'avec un pointeur :

            MaClasse * maFonction ()
            {
            MaClasse monObjet = new monObjet;
            return monObjet;
            }

            La la fonction renverra un pointeur et comme monObjet a été allouée sur le tas, la valeur de retour pointera vers un objet valide.
            • Partager sur Facebook
            • Partager sur Twitter
              9 juin 2007 à 19:16:46

              'taing t'es un malin toi ! Tu vérifies avant de dire des conneries ?!

              Citation : bakura10

              MaClasse * maFonction ()
              {
              MaClasse monObjet = new monObjet;
              return monObjet;
              }



              Pour commencer, new demande un constructeur, donc ce serait "new MaClasse()" et ensuite, new retourne un pointeur sur la classe de l'objet créé, et tu l'assignes à un objet statiquement créé ! Aucun de tes deux codes ne marchera !
              • Partager sur Facebook
              • Partager sur Twitter
                9 juin 2007 à 19:28:12

                Réagis pas comme ça, tu sais très bien que ce n'était que des erreurs d'étourderies...

                Et oui l'avantage en plus du confort d'écriture c'est qu'on a un objet valide en argument, alors que les pointeurs peuvent être nuls ou invalides.
                • Partager sur Facebook
                • Partager sur Twitter
                  10 juin 2007 à 0:17:12

                  Sorti de l'aliasing (désolé il est tard pour une traduction valable), il n'y a effectivement guère de différence dans le "code machine" produit.

                  Une grosse différence relativement à la sémantique de valeur. Les références constantes (abus de langage pour désigner des références sur des objets dont on promet ne pas modifier l'état) permettent d'accepter des temporaires non nommés. Autrement dit le résultat de fonctions qui renvoient des données par valeur (typiquement un opérateur d'addition, ...). Oublier cela quand on part sur des pointeurs qui sont plus propres à la sémantique d'entité.

                  Après les principales différences vont être sur les differentes sémantique que l'on veut bien accorder à l'un et à l'autre.

                  Des aspects syntaxiques font qu'il est (légèrement) plus complexe d'avoir une référence vers une donnée invalide (déjà détruite, d'adresse nulle, ...). Au contraire des pointeurs qui conviennent parfaitement pour des choses optionnelles.

                  D'autres différences peuvent être retrouvées dans les archives de developpez, de fclc++, ...
                  • Partager sur Facebook
                  • Partager sur Twitter
                  C++: Blog|FAQ C++ dvpz|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS| Bons livres sur le C++| PS: Je ne réponds pas aux questions techniques par MP.
                    10 juin 2007 à 11:29:38

                    psycho13 > Pas besoin de t'énerver ;). Je réagissais au fait que tu dis qu'à part l'écriture il n'y à aucune différence, ce qui est faux.

                    "Pour commencer, new demande un constructeur, donc ce serait "new MaClasse()" et ensuite, new retourne un pointeur sur la classe de l'objet créé, et tu l'assignes à un objet statiquement créé ! Aucun de tes deux codes ne marchera !"

                    En effet, j'avais oublié une petite étoile, c'est bien évidemment MaClasse * monObjet, c'est une erreur d'inatention, je te rassure, j'utilise suffisament les pointeurs pour le savoir :). C'est impardonable là, je te l'accorde ;)

                    Par contre, avant de m'agresser, vérifie aussi ce que tu dis :)

                    "Pour commencer, new demande un constructeur, donc ce serait "new MaClasse()""

                    Et les constructeurs par défaut, tu connais ? :) Si par exemple ta classe est comme ceci :

                    class MaClasse
                    {
                    public:
                    MaClasse () {};
                    ~MaClasse () {};
                    }

                    tu peux sans problème écrire ça : MaClasse * objet = new MaClasse; vu que le constructeur ne prend aucun argument, ça ne pose pas de soucis.

                    A bon entendeur, salut :).
                    • Partager sur Facebook
                    • Partager sur Twitter

                    Références

                    × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                    × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                    • Editeur
                    • Markdown