Discussion :

[koala01]

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 :

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

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 :

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

1
2
3
4
void fonction(int&* tab)
{
    /*...*/
}

le compilateur sort une erreur

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

La troisième solution étant de prendre un bon compilateur car rien ne l'interdit dans la norme

[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.

[Médinoc]

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

[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 )

Enfin, on va laisser le sujet ouvert jusqu'au passage de quelqu'un qui aura la norme sous les yeux... Des fois que...

[koala01]

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"

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 :

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

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

[poukill]

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 :

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

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 :

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

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 :

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

void fonction(int *& tab, int size)

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

[koala01]

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 :

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

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 :

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

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
avant :
1
2
3
4
5
6
7
8
9
10
apres :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

[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

[yan]

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

Code :

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

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 :

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

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 :

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

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

[yan]

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é

[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.

[koala01]

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 ?

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

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 )

[NiamorH]

Ok c'est donc par curiosité et non pas parce que tu en a besoin.

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 :

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

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 à :

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

?

[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...

[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 :

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

1
2
3
4
 
int i;
int& j = i;
assert(&i == &j);

[NiamorH]

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 :

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

"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.

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 :

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

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.

[koala01]

Ooopss...

Au temps pour moi ... 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

[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 ...

[koala01]

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

[Jean-Marc.Bourguet]

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.

[Médinoc]

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