Pointeur sur référence ?

Version imprimable

15/01/2008, 12h12
koala01

Pointeur sur référence ?
Salut,

Je me pose une question existentielle concernant la (sans doute mauvaise) chose que seraient les "pointeurs sur référence"...

Il y a, parfaitement, moyen de déclarer une référence sur pointeur, ce qui permet au code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void fonction(int *& tab, int size) { /*...*/ } int main() { int* tab=new int[10]; /*...*/ fonction(tab,10); /*...*/ delete[] tab; return 0; }
de fonctionner...

Par contre, quand on essaye de déclarer un pointeur sur référence sous la forme de
Code:

1 2 3 4 void fonction(int&* tab) { /*...*/ }
le compilateur sort une erreur

Citation:

Envoyé par le compilateur

cannot declare pointer to int&

Du moins, c'est ce que me sort gcc, et il semblerait que VC++ réagisse de la même manière...

La question est donc:

M'y prends-je vraiment très mal pour déclarer un pointeur sur référence, ou est-ce purement et simplement interdit dans la norme :question:

La troisième solution étant de prendre un bon compilateur car rien ne l'interdit dans la norme :P :D
15/01/2008, 12h19
Médinoc

Il me semble qu'on ne peut tout simplement pas faire de pointeur sur référence, sans doute en partie car cela donnerait un moyen de modifier la référence...
Sans compter que le fait d'avoir un pointeur sur référence "tue" la notion de simplicité qui leur est attachée...

Mais je n'ai pas la norme sous les yeux.
15/01/2008, 12h20
Médinoc

D'un autre côté, tu peux toujours faire un pointeur sur structure contenant une référence...
15/01/2008, 12h24
koala01

C'est aussi ce que je subodorais... Mais, dans le doute, j'ai décidé de poser la question (c'est typiquement le genre de réflexion qui peut venir à une personne désœuvrée, non :question:)

Enfin, on va laisser le sujet ouvert jusqu'au passage de quelqu'un qui aura la norme sous les yeux... Des fois que... :D
15/01/2008, 12h26
koala01
Citation:

Envoyé par Médinoc

D'un autre côté, tu peux toujours faire un pointeur sur structure contenant une référence...

Oui, oui, ça, ce n'était même pas mis en doute... Mais on commence à sortir un peu du cadre de "pointeur sur référence" ;):roll::P

EDIT d'ailleurs, c'est bien simple, rien ne t'empeche de passer l'adresse d'une référence à une fonction demandant un pointeur...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void fonction( int* ptr) { } int main() { int i=5; int& ref=i; fonction(&ref); /*...*/ return 0; }
ne pose a priori aucun problème à la compilation :P

Salut Koala !
Justement, j'ai moi aussi pas mal de question sur ce sujet ! ;)

1) Une référence, n'est ce pas un pointeur déguisé ?
2) Quand tu écris
Code:

1 2 3 4 void fonction(int *& tab, int size) { /*...*/ }
N'y a t-il pas une simplification faire par le compilateur? Voyons ce code par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <iostream> #include <limits> using namespace std; int main() { int val = 4; int* p_val = &val; std::cout << *& p_val << std::endl; cout << "Appuyez sur entrée pour continuer..."; cin.ignore( numeric_limits<streamsize>::max(), '\n' ); }
Le *& est un élément neutre ici. Ce que je me demande, c'est comment le compilo interprète alors la fonction

Code:

void fonction(int *& tab, int size)

Peut-être je raconte des salades, j'essaye juste de comprendre ... :koi:

C'est relativement crade, mais la référence sur pointeur va alors réagir un peu comme un pointeur de pointeur... Le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include <iostream>
using namespace std;
void fonction(int *& tab, int size)
{
    delete[] tab;
    tab=new int[size];
    for(int i=0;i<size;i++)
    {
        tab[i]=i+1;
    }
}
int main()
{
    int* tab=new int[10];
    for(int i=0;i<10;i++)
    {
        tab[i]=i+1;
    }
    cout<<"avant :"<<endl;
    for(int i=0;i<10;i++)
    {
        cout<<tab[i]<<endl;
    }
    /*...*/
    fonction(tab,20);
    cout<<"apres :"<<endl;
    for(int i=0;i<20;i++)
    {
        cout<<tab[i]<<endl;
    }
    delete[] tab;
    return 0;
}

va sortir le résultat

Code:

[EDIT]Par contre, je ne suis pas sur du tout que la libération de mémoire demandée dans fonction ne libère toute la mémoire de tab :P

15/01/2008, 13h26
yan
Citation:

Envoyé par poukill

Le *& est un élément neutre ici. Ce que je me demande, c'est comment le compilo interprète alors la fonction

Code:

void fonction(int *& tab, int size)

Bonjour, non ce n'est pas neutre. Tu peut ainsi modifier le pointeur passé en paramètre. Par exemple si tu fait une allocation
Code:

1 2 3 4 void alouemem(int * tab, int size) { tab = new int[size]; }
Tu ne recuperera jamais ce qui est alloué car tab est une copie du pointeur passé en paramètre. Alors que
Code:

1 2 3 4 void alouemem(int * &tab, int size) { tab = new int[size]; }
modifiera bien le pointeur passé en paramètre puisque tab le reference
15/01/2008, 13h32
yan
Citation:

Envoyé par poukill

1) Une référence, n'est ce pas un pointeur déguisé ?

Pour moi,
Sûrement pour le code mais pas du tout dans son concept.
Une référence est plus sctrict qu'un pointeur :
- ne reference qu'un objet et jamais un ensemble
- référencera toujours le même objet
- Plus explicite qu'un pointeur dans son utilité
15/01/2008, 13h32
NiamorH

Un pointeur sur une référence, ce ne serait finalement rien d'autre qu'un pointeur sur l'objet original. Non ? Je comprends que tu te poses des questions existentielles (je m'en pose aussi souvent, et il arrive qu'elles atterrissent ici) mais y aurait-il une utilité que j'aurais manquée à ce concept ?

A partir du moment ou tu ressens le besoin d'avoir un pointeur sur une référence, il est toujours possible d'utiliser à la place un pointeur sur l'objet original permettant la même utilisation, vu que la référence n'est qu'un alias de l'objet, non modifiable.
15/01/2008, 13h43
koala01

Citation:

Envoyé par NiamorH

Un pointeur sur une référence, ce ne serait finalement rien d'autre qu'un pointeur sur l'objet original. Non ?

Ah, non, une référence est plus un alias d'un objet qu'un pointeur sur objet...

C'est d'ailleurs beaucoup plus stricte dans ce que cela accepte...
[QUOTE]
Je comprends que tu te poses des questions existentielles (je m'en pose aussi souvent, et il arrive qu'elles atterrissent ici) mais y aurait-il une utilité que j'aurais manquée à ce concept ?

Citation:

Si tu préfères, je reformule ma question en
mon compilateur me dit qu'il ne peut pas déclarer un pointeur sur référence. Est-ce dans la norme, ai-je un mauvais compilateur, ou est-ce que je m'y prend mal :question:

Citation:

A partir du moment ou tu ressens le besoin d'avoir un pointeur sur une référence, il est toujours possible d'utiliser à la place un pointeur sur l'objet original permettant la même utilisation, vu que la référence n'est qu'un alias de l'objet non modifiable.

Et, si tu veux tout savoir, c'est parce que j'ai un prof de C++ qui voulait nous initier aux référence, qui a essayé un char &* qui a foiré, et que donc, je voudrais pouvoir lui expliquer que la norme l'interdit si c'est le cas (en lui expliquant les différentes possibilités ;))
15/01/2008, 15h18
NiamorH
Ok c'est donc par curiosité et non pas parce que tu en a besoin.

Citation:

Envoyé par koala01

Ah, non, une référence est plus un alias d'un objet qu'un pointeur sur objet...

Oui c'est bien ce que j'ai dit, enfin il me semble. Mais ça n'empêche pas le fait que je vois pas la différence (dans le concept seulement vu que dans la pratique l'un des deux est interdit) entre un pointeur vers un objet et un pointeur vers une référence, justement parce qu'une référence est un alias de l'objet original...
Code:

1 2 3 4 5 int i; int& ri = i; int* pi = &i; // pointeur sur référence // int&* pri = &ri;
l'utilisation de pi et de pri serait identique en tout point donc je ne vois pas pourquoi tu réponds non à :

Citation:

Un pointeur sur une référence, ce ne serait finalement rien d'autre qu'un pointeur sur l'objet original. Non ?

?
15/01/2008, 15h34
koala01

Parce qu'on ne peut en aucun cas laisser dire que "une référence n'est finalement qu'un pointeur sur un élément", ce qui est le sens de la première phrase sur laquelle je réagissais...

Par la suite, tu as donné une autre version: "une référence est un alias d'objet", et je n'ai pas réagit sur cette phrase en particulier...

J'ai tout à fait conscience que, l'un dans l'autre, je n'utiliserai sans doute jamais de référence sur pointeur ni de pointeur sur référence, et, comme je l'ai dit, c'est une question purement existentielle...

Le but ici n'est pas de trouver un contexte dans lequel les choses ont un quelconque intérêt, mais de savoir s'il est autorisé ou non de le faire, pour au final, savoir si ce sont "simplement" les compilateurs qui ont mal implémenté la norme ou si, au contraire, ils la respectent pleinement sur ce point précis...
15/01/2008, 16h02
Jean-Marc.Bourguet
Une reference n'est pas un objet, c'est un autre nom pour un objet. Donc l'idee d'alias est tout a fait correcte.

Vu que ce n'est pas un objet, on ne peut pas prendre son adresse. Donc un pointeur vers une reference c'est pas possible. Quand on tente de prendre l'adresse d'une reference, on se retrouve avec l'adresse de l'objet dont elle est un autre nom.
Code:

1 2 3 4 int i; int& j = i; assert(&i == &j);
15/01/2008, 16h08
NiamorH
Citation:

J'ai tout à fait conscience que, l'un dans l'autre, je n'utiliserai sans doute jamais de référence sur pointeur ni de pointeur sur référence, et, comme je l'ai dit, c'est une question purement existentielle...

Le but ici n'est pas de trouver un contexte dans lequel les choses ont un quelconque intérêt, mais de savoir s'il est autorisé ou non de le faire, pour au final, savoir si ce sont "simplement" les compilateurs qui ont mal implémenté la norme ou si, au contraire, ils la respectent pleinement sur ce point précis...

Pas de soucis, j'ai bien compris que tu ne recherchais pas l'intérêt. Je te reproche pas du tout ça.

Par contre je ne sais pas lequel de nous deux pinaille, mais :

Citation:

Envoyé par Niamorh

Un pointeur sur une référence, ce ne serait finalement rien d'autre qu'un pointeur sur l'objet original. Non ?

Citation:

Envoyé par koala01

"une référence n'est finalement qu'un pointeur sur un élément"

Je n'ai JAMAIS dit qu'une bête référence n'est qu'un pointeur sur un objet, c'est toi qui me le fait dire!
Je te dis qu'un pointeur sur référence (ce qui n'existe pas d'ailleurs) serait ni plus ni moins qu'un pointeur sur l'objet original et je le maintiens. N'est tu pas d'accord avec ça ? Je compare deux pointeurs là... pas une réf et un pointeur.
Citation:
Envoyé par Jean-Marc.Bourguet

Quand on tente de prendre l'adresse d'une reference, on se retrouve avec l'adresse de l'objet dont elle est un autre nom.

Code:

1 2 3 4 int i; int& j = i; assert(&i == &j);
Vu qu'un pointeur s'initialise avec une adresse, cela vient appuyer mon idée.
15/01/2008, 16h22
koala01

Ooopss...

Au temps pour moi :aie:... j'avais "zappé" les trois premiers mots de la phrase dans la phrase :p...

J'avais lu "une référence n'est qu'un pointeur" au lieu de "un pointeur sur référence"...

Je te présente toutes mes excuses :roll:
15/01/2008, 16h28
dj.motte

Salut,

Il me semble que le pointeur sur référence est tout à fait possible par contre la référence sur pointeur n'a aucun sens, le pointeur n'étant qu'une direction.

Mais bon ...
15/01/2008, 16h39
koala01

Citation:

Envoyé par dj.motte

Salut,

Il me semble que le pointeur sur référence est tout à fait possible par contre la référence sur pointeur n'a aucun sens, le pointeur n'étant qu'une direction.

Mais bon ...

Hé bien non... c'est justement le contraire, visiblement:
int *& lavar est une référence sur pointeur et fonctionne sans problème alors que int&* lavar est un pointeur sur référence et est en tout cas refusé par deux compilateurs au moins ;)
15/01/2008, 16h41
Jean-Marc.Bourguet

Citation:

Envoyé par koala01

Hé bien non... c'est justement le contraire, visiblement:
int *& lavar est une référence sur pointeur et fonctionne sans problème alors que int&* lavar est un pointeur sur référence et est en tout cas refusé par deux compilateurs au moins ;)

A juste titre. Si vous voulez des references, il faudra attendre ce soir.
15/01/2008, 16h45
Médinoc

Sur un sujet voisin, Visual m'interdit aussi les tableaux de références...
15/01/2008, 16h48
koala01

Citation:

Envoyé par Jean-Marc.Bourguet

A juste titre. Si vous voulez des references, il faudra attendre ce soir.

J'attend donc ce soir avec impatience...

Car, finalement, c'est le but premier de ma question, et la raison pour laquelle j'ai lancé ce topic :D :P
15/01/2008, 17h08
Jean-Marc.Bourguet

Citation:

Envoyé par Médinoc

Sur un sujet voisin, Visual m'interdit aussi les tableaux de références...

Pour la meme raison, c'est pas les references ne sont pas des objets.
15/01/2008, 17h14
Jean-Marc.Bourguet

Citation:

Envoyé par koala01

J'attend donc ce soir avec impatience...

Je suis bon. 8.3.2.

Citation:

...A reference can be though as a name of an object....

...It is unspecified whenever or not a reference requires storage...

...There shall be no references to reference, no array of references, no pointer to references...
15/01/2008, 17h42
koala01

Jean Marc, encore une fois, quand il s'agit de faire référence à la norme, tu te place là :D Un grand merci :D

Je cloture officiellement le thread, parce que j'ai ma réponse... mais on peut continuer à discuter :D
15/01/2008, 17h54
Jean-Marc.Bourguet

Citation:

Envoyé par koala01

Jean Marc, encore une fois, quand il s'agit de faire référence à la norme, tu te place là :D Un grand merci :D

Pas trop difficile de trouver la section intitulee "reference".

Le gros probleme n'est pas tant de trouver quelque chose de pertinent, c'est d'etre sur qu'il n'y a rien d'autre ailleurs qui vient modifier la maniere dont il faut interpreter ce qu'on a trouve (et ca j'ai pas cherche ici, comme souvent je me suis fie a ma connaissance du langage et je me suis arrete quand j'ai trouve quelque chose qui confirme ce que je pensais avant. Eclaircir un point sur lequel j'ai des doutes est beaucoup plus difficile).