réference et adresse [Résolu]

[FoX_*D i E*]

Bonjour,
J'étudie en ce moment les cours de C++ (après avoir lu les cours de C)
http://cpp.developpez.com/cours/polyCpp/

et il y a d'écrit dans la partie "Références ou pointeurs ?"

Code :

1
2
3
4
5
6
7
 
employé dans une déclaration, comme dans
int &r = x;
il sert à indiquer un type référence : « r est une référence sur un int »
 
employé ailleurs que dans une déclaration il indique l'opération « obtention de l'adresse », comme dans l'expression suivante qui signifie « affecter l'adresse de x à p » :
p = &x;

No comprendo.
Alors soit réference et affectation d'adresse ce n'est pas la meme chose
soit les deux déclarations sont équivalentes à peu de chose près

ou soit j'ai vraiment pigé que dalle.

dans l'attente de vos réponses, je vous remercie d'avance

[koala01]

Salut,

En fait, tout dépend de ce qui se trouve avant l'esperluette.

• Si tu as un identifiant de type (int &, MaClasse &, ... ), c'est une référence, et il faut l'initialiser en lui donnant une variable existante du type attendu.
• Si tu as un opérateur d'affectation ( = ) comme dans int * ptr = & i , c'est l'opérateur "address of" qui permet de récupérer l'adresse à laquelle se trouve l'élément que tu veux faire pointer par ton pointeur.

Tu vois, c'est tout simple

[EDIT]J'ai oublié le cas de l'appel d'une fonction :

1. dans le prototype d'une fonction, tu te retrouves dans le premier cas,
2. Si tu l'utilise lors de l'appel d'une fonction, c'est l'opérateur address of

En réalité, la norme parle de "rvalue" et de "lvalue".

une lvalue se trouve d'office à gauche de l'opérateur d'affectation "=" (s'il y en a un)et représente généralement une variable que l'on déclare, par exemple:

Code :

1
2
3
int i ; // déclare une variable de type int nommé i
int * ptr = &i; // déclare une variable de type "pointeur sur int" nommée ptr et lui affecte l'adresse de i
int & ref = i; // déclare une variable de type "référence sur int" nommée ref qui est un alias de i

une rvalue est tout ce qui peut se trouver à droite de l'opérateur d'affectation, ou qui agit comme tel, par exemple :

Code :

1
2
3
int i = 3; // 3 est une rvalue
foo( & i); // &i représente l'adresse de i, passée à une fonction, c'est une rvalue
int result = bar(); // le résultat de bar peut etre affecté à résult : c'est une rvalue

Selon ces termes,

• chaque fois qu'une esperluette intervient dans une expression rvalue, c'est l'opérateur "address of"
• chaque fois que l'esperluette intervient dans une expression lvalue, c'est le symbole d'une référence

[FoX_*D i E*]

Ca m'eclairci les idées, mais pas entierement
Voila ma double question :

-Qu'est ce qu'une référence?

-Qu'est ce qu'une adresse?


pour moi, la double réponse serais "les 2 sont identiques, ce sont les emplacements du stockage d'une donnée"

je sens que vous allez me rire au nez...mais je ne suis qu'un jeune padawan

[koala01]

En fait, il y a une différence très nette entre une adresse, un pointeur et une référence...

Une adresse, c'est l'adresse mémoire que tout objet que tu vas créer va utiliser pour sa propre représentation.

Tu n'est pas sans savoir que les différentes informations qu'utilise ton ordinateur et tes applications sont stockées en mémoire.

Pour que le processeur puisse accéder à ces informations, il a besoin d'en connaitre l'adresse, tout comme le facteur a besoin de connaitre ton adresse pour te faire parvenir ton courrier.

A un instant T, il ne peut jamais y avoir qu'un et un seul objet à une adresse donnée, mais il est possible qu'un objet prenne plusieurs adresses, simplement parce qu'il est trop gros pour tenir intégralement sur une seule adresse (c'est comme si tu avais vingt enfants et que tu avais acheté tout un paté de maisons pour n'en faire qu'une seule grande maison... tout le courrier arrive à la meme adresse, sauf que cette adresse va "englober" plusieurs adresses "physiques").

Un pointeur, c'est une variable "comme une autre", à ceci pres qu'elle contient... l'adresse mémoire à laquelle on va trouver un objet du type indiqué.

L'utilisation de pointeurs pose énormément de problèmes, car :

1. Ils peuvent représenter une adresse qui ne correspond pas à un objet réel
2. il peuvent représenter une adresse qui signifie que l'ojbet n'existe pas
3. ils utilisent une syntaxe particulière pour leur manipulation
4. Il sont souvent synonymes d'allocation dynamique de la mémoire, et de tous les problèmes que l'on peut y associer comme le dépassement d'index, les tentatives de double libérations de la mémoire ou les fuites mémoires.
5. L'utilisateur ne sait que rarement s'il doit ou non s'occuper lui-même de l'allocation dynamique de mémoire et / ou de la libération de la mémoire

Comprenons nous quand meme : les pointeurs ont sans doute représenté une avancée majeure en programmation dans le sens où ils ont permis la transmission d'informations locales à une fonction vers une fonction "utilisatrice" de ces informations en en évitant la copie.

Mais bon, les pointeurs souffrent de maux qui leurs sont propres

C'est pourquoi C++ (et les autres langages par la suite) ont introduit la notion de référence.

La référence n'est qu'un alias de variable, un pseudonyme que l'on donne à une variable lorsqu'on la transmet à une fonction, par exemple.

Au cas où tu ne l'aurais pas remarqué, il y a quelqu'un derrière le clavier qui écrit koala01...

Ce quelqu'un, c'est moi .

Mais tout ce qu'écrit koala01, c'est moi qui l'écrit, tout ce qu'il peut arriver à koala01, c'est à moi que cela arrive.

Et il ne pourrait pas y avoir de koala01 si je n'existais pas réellement.

Le principe d'une référence est strictement pareil :

• Pour qu'une référence puisse exister, il faut qu'il existe un objet auquel elle puisse... faire référence
• Toutes les modifications que la référence pourrait subir seront répercutée sur l'objet "original", et inversement

Bon, pour etre tout à fait honnête (mais dépêches toi de l'oublier après l'avoir lu ) il est vrai que, si tu regarde au niveau du code assembleur généré, il n'y aura aucune différence entre un pointeur et une référence : la référence sera gérée exactement comme s'il s'agissait d'un pointeur.

Tu as donc parfaitement le choix d'utiliser soit une référence soit un pointeur lorsqu'il s'agit de transmettre des arguments dont tu veux éviter la copie à une fonction, mais...

comme la référence est plus sécurisante et plus simple à l'emploi (elle offre une garantie d'existence de l'objet référencé, elle autorise la même syntaxe que si on travaillait avec l'objet lui-même, elle n'est pas synonyme de gestion dynamique de la mémoire, et bien d'autres choses que tu apprendras en leur temps), il est très largement recommander d'utiliser les références "chaque fois que possible", et de n'utiliser les pointeurs que "lorsque tu n'as pas le choix", et les circonstances dans lesquelles l'utilisation d'un pointeur se justifient sont très limitées

[FoX_*D i E*]

Ca y est j'ai compris ^^

Je te remercie pour ta longue explication. Je vais transmettre ton post à mes anciens camarades de classe qui m'ont posé la meme question.

donc adresse c'est l'emplacement de stockage de ma variable dans la mémoire,
réference c'est un code qui suit à la trace la variable qu'il réfère et vice/versa

bonnes fêtes^^

[Bousk]

Bonjour,

Il faut voir une référence comme un allias sur une variable existante.
Une référence ne peut pas être nulle et doit être initialisée à la déclaration.