Discussion :

[rockeye]

Apparemment, il n'est pas possible de créer un conteneur de références.

Sous visual, ce code ne compile pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class Foo
{
};
 
int main()
{
	std::vector<Foo&> fooVector;
	return 0;
}

J'ai l'erreur : error C2528: 'pointer' : pointer to reference is illegal

Si on part du fait qu'une référence est un alias d'objet, je ne comprends pas pourquoi ca pose problème ?

Est ce que quelqu'un à l'explication ?

[loufoque]

Parce que ça n'a pas de sens.
Un conteneur stocke des objets, des valeurs.

À noter que la version actuelle des conteneurs nécessite que le type contenu soit CopyConstructible et Assignable.

[mikado_O]

Salut,

Google est ton ami :

Visual C++ Concepts: Building a C/C++ Program
Compiler Error C2528

Error Message
'name' : pointer to reference is illegal

You cannot declare a pointer to a reference. Dereference the variable before declaring a pointer to it.

En clair tu ne peux pas déclarer un pointeur de référence. Moi je ferais de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class Foo
{
};
 
int main()
{
	std::vector<Foo *> fooVector;
	return 0;
}

Tu as donc un un tableau redimensionnable dont chaque case pointe vers un objet de type Foo. Pour ajouter, tu push_back l'adresse de ton objet de type Foo :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
int main()
{
	std::vector<Foo *> fooVector;
        Foo objetFoo;
 
        fooVector.push_back(&objetFoo);
 
	return 0;
}

[rockeye]

@loufoque : ok, mais une référence en mémoire est bien représentée par une valeur ?

On écrit bien vector<Foo*> qui stocke des pointeurs, donc une valeur sur 32/64 bits. Pourquoi pas une référence ? Je suppose qu'il y a une correspondance dans la mémoire ?


@mikado : pas besoin de google, Visual me dis ca tout seul !
Et effectivement passer par des pointeurs est la solution "classique", que j'ai toujours fait jusqu'à présent. Mais je voudrais connaitre la RAISON. La solution est bien sur, comme tu l'as mis vector<Foo*> ou carrement vector<Foo>.

[befalimpertinent]

écrire vector<Foo*> est dangeureux. Utilises plutôt des smart pointers dans ce cas ou une structure adaptée pour passer d'un élément à l'autre (sans vector)

[befalimpertinent]

et pour répondre à la question initiale: tu oublies qu'une référence doit être obligatoirement initialisé et ne peut être NULL.

[mikado_O]

@mikado : pas besoin de google, Visual me dis ca tout seul !

Je n'utilise pas Visual Studio, je préfère travailler sous UNIX directement avec des makefiles ^^ . Merci pour l'info.

La référence permet de faire référence à des objets qui existent déjà.

Le concept de référence ne doit en aucun cas être confondu avec celui d'adresse même si les deux notions utilisent le caractère &.

Faire un conteneur de référence ne me parait pas logique dans le sens où justement ce n'est pas vraiment une adresse mais un "pointeur sur un objet précis". Or on ne va pas faire un conteneur sur un objet précis. (Ce n'est que mon avis, je ne me suis jamais posé cette question :p)

[koala01]

@loufoque : ok, mais une référence en mémoire est bien représentée par une valeur ?

On écrit bien vector<Foo*> qui stocke des pointeurs, donc une valeur sur 32/64 bits. Pourquoi pas une référence ? Je suppose qu'il y a une correspondance dans la mémoire ?

Il faut bien te rendre compte qu'une référence n'a pas d'existance en tant que telle...

Ce n'est jamais qu'un alias d'un objet existant.

Comme une référence va, en très gros, dire "salut, je mappelle (le nom) et je représente (la variable d'origine)", on ne peut pas prendre le risque que la variable d'origine... n'existe pas

Et, comme une référence n'a pas d'existance en soi, il est donc impossible... d'en prendre l'adresse

D'ailleurs, si tu voulais t'amuser à une petit exercice de "bon parler", je te proposerais bien de me donner la signification des expressions suivantes:

1. int i =3;
2. int & ref =i;
3. int * ptr = &i;
4. int &* pr = &ref;
5. int *& rp = ptr;

(en sachant que toutes ne sont pas forcément juste)...

Et tu te rendrais rapidement compte, en remplaçant le terme "référence sur" par "alias de" de quels expressions sont mauvaises

[rockeye]

OK, je commence à comprendre le concept.

Merci à tous pour vos réponses.

[r0d]

Juste pour enfoncer le clou: une erreur que l'on retrouve beaucoup dans les discussions en c++ est de dire qu'un pointeur et une référence c'est la même chose. C'est bien évidemment faux, un pointeur est un objet qui contient une adresse (ce qui permet de définir des opérations sur les pointeurs, cf l'arithmétique de pointeurs), alors qu'une référence est la valeur de l'adresse elle-même.

[rockeye]

On est d'accord, c'est comme cela que je l'avais compris.

Si j'ai bien compris, le problème n'est pas "hardware" :

On pourrait dans l'absolu stocker une référence dans un vect (c'est la valeur d'une adresse, donc un nombre, et un nombre c'est un int ou long, donc stockable dans un vector),

MAIS, le verrou est "logiciel" (enfin, venant du compilo) parce qu'une référence ne peut pas être nulle, notamment. Et en stockant la valeur de l'adresse d'un objet, on prend le risque que cet objet disparaisse, et que la référence stockée pointe sur quelque chose d'invalide, ce qui contredit le concept de référence.

J'ai tout juste ?

[r0d]

On est d'accord, c'est comme cela que je l'avais compris.

Si j'ai bien compris, le problème n'est pas "hardware" :

On pourrait dans l'absolu stocker une référence dans un vect (c'est la valeur d'une adresse, donc un nombre, et un nombre c'est un int ou long, donc stockable dans un vector),

Effectivement. D'ailleurs on peut le faire. Tu stocke des int dans ton conteneur, et tu les utilise comme des pointeurs. Mais bon, voilà le cahos!

MAIS, le verrou est "logiciel" (enfin, venant du compilo) parce qu'une référence ne peut pas être nulle, notamment. Et en stockant la valeur de l'adresse d'un objet, on prend le risque que cet objet disparaisse, et que la référence stockée pointe sur quelque chose d'invalide, ce qui contredit le concept de référence.

J'ai tout juste ?

Oui je crois. Enfin... je ne suis pas sûr de bien tout comprendre. On peut stocker des pointeurs dans un conteneurs et ces pointeurs peuvent pointer sur quelque chose d'invalide aussi. C'est la raison pour laquelle il est déconseillé de faire des conteneurs de pointeurs (bien qu'en réalité, ça peut être le meilleur choix dans certains cas bien précis - et assez rares en fait je crois.).