Qu'est ce qui motive une telle restriction dans la norme alors que cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){ int bB; int c$; int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu de b. */
a=c; /* assigne 24 à b */ a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a); }
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à ma question.
Voici un peu de code pour illustrer mon propos :
class A { public: A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B // tout en préservant A B& get() const { return _b; }
private: mutable B& _b; };
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec les versions précédents de GCC et les versions actuelles de Visual Studio d'ailleurs).
Yann
On 08/04/2011 11:39 AM, Pascal J. Bourguignon wrote:
Yann Renard<no@spam.please> writes:
Bonjour à tous,
dans la dernière version de GCC, il y a un correctif qui empêche de
déclarer les références mutable.
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id3558>
Qu'est ce qui motive une telle restriction dans la norme alors que
cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){
int bB;
int c$;
int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu
de b. */
a=c; /* assigne 24 à b */
a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a);
}
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à ma
question.
Voici un peu de code pour illustrer mon propos :
class A
{
public:
A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B
// tout en préservant A
B& get() const { return _b; }
private:
mutable B& _b;
};
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec
les versions précédents de GCC et les versions actuelles de Visual
Studio d'ailleurs).
Qu'est ce qui motive une telle restriction dans la norme alors que cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){ int bB; int c$; int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu de b. */
a=c; /* assigne 24 à b */ a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a); }
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à ma question.
Voici un peu de code pour illustrer mon propos :
class A { public: A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B // tout en préservant A B& get() const { return _b; }
private: mutable B& _b; };
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec les versions précédents de GCC et les versions actuelles de Visual Studio d'ailleurs).
Yann
Pascal J. Bourguignon
Yann Renard writes:
On 08/04/2011 11:39 AM, Pascal J. Bourguignon wrote:
Yann Renard writes:
Bonjour à tous,
dans la dernière version de GCC, il y a un correctif qui empêche de déclarer les références mutable.
Qu'est ce qui motive une telle restriction dans la norme alors que cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){ int bB; int c$; int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu de b. */
a=c; /* assigne 24 à b */ a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a); }
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à ma question.
Voici un peu de code pour illustrer mon propos :
class A { public: A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B // tout en préservant A B& get() const { return _b; }
private: B a; B c; mutable B& _b;
void f(){ /* Il n'y a pas moyen de changer a pour lui faire référencer a ou c au lieu de ce avec quoi il a été initialisé. */ b=a; /* assigne a à b */ b=&c; /* signale une erreur pour assignement d'un pointeur à un B */ } };
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec les versions précédents de GCC et les versions actuelles de Visual Studio d'ailleurs).
On 08/04/2011 11:39 AM, Pascal J. Bourguignon wrote:
Yann Renard<no@spam.please> writes:
Bonjour à tous,
dans la dernière version de GCC, il y a un correctif qui empêche de
déclarer les références mutable.
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id3558>
Qu'est ce qui motive une telle restriction dans la norme alors que
cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){
int bB;
int c$;
int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu
de b. */
a=c; /* assigne 24 à b */
a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a);
}
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à
ma question.
Voici un peu de code pour illustrer mon propos :
class A
{
public:
A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B
// tout en préservant A
B& get() const { return _b; }
private:
B a;
B c;
mutable B& _b;
void f(){
/* Il n'y a pas moyen de changer a pour lui faire référencer a ou c
au lieu de ce avec quoi il a été initialisé. */
b=a; /* assigne a à b */
b=&c; /* signale une erreur pour assignement d'un pointeur à un B */
}
};
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec
les versions précédents de GCC et les versions actuelles de Visual
Studio d'ailleurs).
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Qu'est ce qui motive une telle restriction dans la norme alors que cela reste possible avec des pointeurs ?
Les références ne sont pas mutables, et ne l'ont jamais été.
int f(){ int bB; int c$; int& a=b;
/* Il n'y a pas moyen de changer a pour lui faire référencer c au lieu de b. */
a=c; /* assigne 24 à b */ a=&c; /* signale une erreur pour assignement d'un pointeur à un b qui est int */
return(a); }
Merci Pascal pour cette réponse mais je crois qu'elle ne répond pas à ma question.
Voici un peu de code pour illustrer mon propos :
class A { public: A(B& ref) _b(b) { }
// Je veux exposer une ref non const de B // tout en préservant A B& get() const { return _b; }
private: B a; B c; mutable B& _b;
void f(){ /* Il n'y a pas moyen de changer a pour lui faire référencer a ou c au lieu de ce avec quoi il a été initialisé. */ b=a; /* assigne a à b */ b=&c; /* signale une erreur pour assignement d'un pointeur à un B */ } };
le "mutable B& _b;" n'est pas autorisé (mais compilait quand même avec les versions précédents de GCC et les versions actuelles de Visual Studio d'ailleurs).