Version imprimable
Bonjour,
J'aimerais avoir votre aide parce que je suis un peu perdu et je ne sais pas comment faire. En effet dans quel cas utiliser un pointeur ou une référence ?
Exemple dans le code suivant :
Nous utilisons les pointeurs. Mais serais-il possible d'utiliser les références ?...Code:
2
3
4
5
6
7
8
9
merci de votre aide
Non. Une référence est un alias qui ne peut être ré-attaché.
Peux tu donner un peu plus de détail. Ca ne m'aide pas beaucoup.
Salut,
En gros, un pointeur doit être utilisé, principalement, dans quatre circonstances:
- Quand tu veux pouvoir bénéficier du polymorphisme
- Quand une structure doit disposer de membre de son propre type (ou d'un type dérivé/parent).
- *éventuellement* quand un membre doit "survivre" à la classe qui le contient ou quand il doit pouvoir ne pas être initialisé... et que tu dois pouvoir tester s'il l'est ou non.
- Quand un argument passé en fonction peut ne pas exister (ce qui est tout à fait différent de "peut etre vide" :D)
En effet, il est impossible qu'un Noeud en contienne "physiquement" un autre... Tout ce qu'il peut contenir, c'est un rappel de l'adresse à laquelle il se trouve ;)
Dans tous les cas, il s'agira de t'assurer que la libération de la mémoire allouée au pointeur soit correctement libérée au bon moment: ni trop tôt, ni trop tard :P
Si tu veux éviter la copie d'un élément, et que tu n'est pas dans l'un de ces quatre cas bien particulier, c'est donc une référence qu'il te faudra utiliser ;)
Pour être précis: un pointeur est l'adresse à laquelle tu trouvera une variable du type donné, alors que la référence n'est qu'un alias (un autre nom) d'une instance donnée du type en question...
Je rajouterai une autre utilité
Dans un passage de paramètres à une fonction, une référence doit être utilisée lorsque cela n'a pas de sens que son équivalent pointeur soit NULL.
Dans ce cas, le fait que Filename soit NULL a un sens (pour ma fonction) donc je peux (et même je dois) utiliser un pointeurCode:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Le point crucial pour cette classe est bien celui qu'indique Luc hermitte: une référence est une sorte de pointeur constant dépointé. Il est donc impossible de changer vers quoi pointe la référence après sa création, ce qui élimine la possibilité d'implémenter le "parent" en tant que référence ET d'avoir une fonction setParent.Citation:
Envoyé par damien77
D'une manière générale, les références membres de classe sont à manipuler avec encore plus de précautions que les pointeurs membres. Certes, les pointeurs membres "nus" nécessitent en général la définition du destructeur, du constructeur de copie, et de l'opérateur d'affectation, ce qui n'est pas aussi simple d'utilisation que les boost::smart_ptr. Par contre, lorsqu'on a un membre référence, la sémantique de l'opérateur d'affectation va être très difficile à respecter (impossible de changer la référence après-coup), et il n'y a pas de constructeur par défaut automatiquement généré. Cela limite fortement les algorithmes génériques pouvant être appliqués à la classe, car ces deux opérations font très souvent partie des pré-requis des paramètres de classes génériques.
une reference indique une relation 1:1 avec une autre classe. c'est a dire que tu referencesune et une seule instance d'une autre classe ( tu la partage, tu ne la possedes pas ). De plus, tu ne peux pas changer l'objet que tu references.
les pointeurs sont souvent utilisés en relation 0:1 ou meme 0:n (comme une reference optionnelle, ou bien comme un tableau de 0 a n references). de plus cette reference vers une autre instance peut etre changée.
Si tu as une relation "forte" 1:1, alors tu devrais utiliser des references.
En résumé, reference =
-> pointeur faible (pas de partage de propriété)
-> non optionnel (tu dois des le debut pointer vers quelque chose)
-> impossible de "rebinder" sur autre chose
utiliser un pointeur (intelligent ou pas) si l'une de ces contraintes est relachée.
Tu peux verifier que pour les parametres de fonction c'est exactement le cas :
-> pointeur faile (tu ne possedes pas le parametre, c'est l'appelant qui le possede)
-> non optionnel (tu dois toujours passer un parametre ou bien le parametre par defaut)
-> non rebindable : tu ne peux plus, une fois dans la fonction, revenir en arriere pour passer j au lieu de i :)
Non, car tu pourrais très bien vérifier si la chaine est vide (ou non), et, en tout cas, la passer en tant que référence, idéalement constante ;)Citation:
Envoyé par ram_0000
Je suis d'accord avec le fait qu'un argument qui peut ne pas exister sera fourni sous la forme d'un pointeur, vallant NULL s'il n'existe effectivement pas, ce qui se rapproche du troisième cas cité (allez, je vais rajouter le cas des arguments ;) )
Mais on déconseille fortement de fournir un pointeur sur tout ce qui vient de la S(T)L:
std::string, conteneurs flux et, d'ailleurs l'ensemble de la S(T)L sont à fournir "par principe" et de préférence en tant que référence, constante s'il échoit ;)
Si le code fait une différence entre une string vide et pas de string du tout, alors là c'est bien un pointeur qu'il faudra utiliser, par contre...
Oui, mais tel que présenté ici, le code ne permet pas de déterminer s'il fait effectivement une telle distinction...Citation:
Envoyé par Médinoc
En plus, le code pourrait très bien s'appliquer, en l'occurrence, avec une chaine vide :D
D'accord donc pour résumer dans ce cas là.
La référence permet de manipuler l'objet original au moment de l'appel de la fonction mais par la suite nous avons une copie...Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
La node permet de manipuler et stocker l'adresse mémoire de notre objet.
Tu peux aussi très bien stocker un pointeur vers l'objet en passant par une référence dans la fonction.
Code:
2
3
4
5
6
7
Mais je trouve ça crade au possible.
Et ça nuit à la lisibilité du code. Un code pareil, je le rejette.
comme un Node peut ne pas avoir de parents, tu n'as pas trop le choix, tu ne peux pas utiliser de références.
C'est excessivement risqué, puisque ça permet de passer à la fonction setParent() un instance locale à une fonction de manière implicite - c'est à dire sans que le programmeur ait à reflechir à ce qu'il fait. Si il a l'obligation de rajouter l'opérateur &, il voit de suite qu'il passe en paramètre l'adresse d'un objet automatique, et il se pose la question de la légalité de ce qu'il écrit.Citation:
Envoyé par MatRem
Un semblant de règle :
- si l'objet doit avoir une durée de vie qui n'est pas automatique : utiliser un pointeur
- si la référence sur un objet peut être invalide : utiliser un pointeur (pour comparaison avec NULL)
- si la référence sur un objet peut varier pendant l'exécution du programme : utiliser un pointeur.
- dans le cas contraire : une référence peut probablement faire l'affaire.
Ou pas. Utiliser un bit particulier ou rajouter un booléen marche aussi, et est plus performant car tu n'es pas obligé d'allouer ton objet dynamiquement comme cela est nécessaire dans certains cas.Citation:
si la référence sur un objet peut être invalide : utiliser un pointeur (pour comparaison avec NULL)
ca ne change rien a l'allocation, une reference ne te permettra pas de changer une alloc dynamique en alloc statique par magie.
Tu fais un POD de la taille et de l'alignement de ton type, et tu rajoutes un booléen pour indiquer si il est initialisé ou pas.
Quand tu veux construire ton élément, tu fais un placement new sur l'adresse de ton POD et tu mets le booléen à vrai.
Dans le destructeur, si le booléen vaut vrai tu appelles le destructeur de ton type.
C'est comme ça qu'est implémenté boost.optional.
une reference n'est pas du tout pareille. la, tu es l'unique proprietaire de l'objet. une reference, tu n'es meme pas l'un des proprietaires.
dans l'exemple precedent, il faudra m'expliquer comment tu peux stocker ton parent a l'interieur de toi meme dans un pod...
Erreur : une référence sur un NULL est impossible donc si l'on passe un pointeur NULL à une méthode qui attend une référence ça bug a tous les coups !Citation:
Envoyé par loufoque
doccpu, tu n'as rien compris, relis.
Je ne fais que dire qu'on a pas besoin d'utiliser des pointeurs si on veut avoir une valeur optionnelle ou qui est initialisée dynamiquement.Citation:
une reference n'est pas du tout pareille. la, tu es l'unique proprietaire de l'objet. une reference, tu n'es meme pas l'un des proprietaires.
Si tu veux bel et bien une réference tu fais boost::optional<T&> (qui sera en effet implémenté par un pointeur)
je pense comprendre ce que tu veux dire. mais dans 99,999% des cas une reference est utilisée comme un lien faible vers un objet dont tu ne connais pas la duree de vie et dans ton implementation, c'est toi le proprietaire qui controle la durée de vie.
ces approches sont philosophiquement a l'opposé l'une de l'autre tel gandhi et GW bush.
en revanche, si tu as un membre initialisé ou pas alors inutile de passer par un pointeur effectivement.
a noter quand meme que ca me parait bien tordu pour eviter une alloc.
Pas forcément, cf mon précédent message.Citation:
je pense comprendre ce que tu veux dire. mais dans 99,999% des cas une reference est utilisée comme un lien faible vers un objet dont tu ne connais pas la duree de vie et dans ton implementation, c'est toi le proprietaire qui controle la durée de vie.
si c'est pour alourdir le code je ne comprend vraiment pas pourquoi.