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

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.

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.

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

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.

'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 !

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.

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++, ...

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 :).