Je viens de tomber sur un souci en tentant une using-declaration des
plus anodines. Le Stroustrup ne laissant pas entendre qu'il puisse y
avoir de problème, je regarde la norme et je trouve :
7.3.3/6 « A using-declaration for a class member shall be a
member-declaration.»
Heureusement, l'exemple donné renseigne sur la signification de "shall" :
struct X {
int i;
static int s;
};
void f () {
using X::i; // error: X::i is a class member
// and this is not a member declaration
using X::s; // error: X::s is a class member
// and this is not a member declaration
}
Alors autant je comprends pour i, autant je ne comprends pas trop pour
une variable membre statique (X::s désignant de manière claire une et
une seule variable...). Ca m'ennuie d'autant plus que c'est justement ce
que j'étais en train d'essayer de faire. ;)
Si quelqu'un a un bout d'explication ?
(Et pour le fait que c'est reporté comme une opaque erreur de syntaxe
par mon gcc-3.qqch... je peux essayer de me faire une raison.)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michel Michaud
Dans news:401ef5c8$0$6976$,
Bonsoir,
Je viens de tomber sur un souci en tentant une using-declaration des plus anodines. Le Stroustrup ne laissant pas entendre qu'il puisse y avoir de problème, je regarde la norme et je trouve :
7.3.3/6 « A using-declaration for a class member shall be a member-declaration.»
Heureusement, l'exemple donné renseigne sur la signification de "shall" :
struct X { int i; static int s; };
void f () { using X::i; // error: X::i is a class member // and this is not a member declaration using X::s; // error: X::s is a class member // and this is not a member declaration }
Alors autant je comprends pour i, autant je ne comprends pas trop pour une variable membre statique (X::s désignant de manière claire une et une seule variable...). Ca m'ennuie d'autant plus que c'est justement ce que j'étais en train d'essayer de faire. ;)
Tu essaies de faire quoi ? Une déclaration using sur un membre doit être dans la définition de la classe, c'est aussi simple que ça. Et ça ne fera pas ce que tu veux.
Ce n'est pas un using sur un élément de namespace. Il n'y aucun moyen de permettre l'écriture « s » pour X::s en dehors de la classe comme on pourrait le faire avec un namespace. Il te faut donc écrire X::s ou faire int& s= X::s;
(si c'est le pourquoi de cette règle qui t'intéresse, j'imagine que c'est seulement qu'on n'a pas pensé que ce serait très utile.)
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:401ef5c8$0$6976$7a628cd7@news.club-internet.fr,
Bonsoir,
Je viens de tomber sur un souci en tentant une using-declaration des
plus anodines. Le Stroustrup ne laissant pas entendre qu'il puisse y
avoir de problème, je regarde la norme et je trouve :
7.3.3/6 « A using-declaration for a class member shall be a
member-declaration.»
Heureusement, l'exemple donné renseigne sur la signification de
"shall" :
struct X {
int i;
static int s;
};
void f () {
using X::i; // error: X::i is a class member
// and this is not a member declaration
using X::s; // error: X::s is a class member
// and this is not a member declaration
}
Alors autant je comprends pour i, autant je ne comprends pas trop
pour une variable membre statique (X::s désignant de manière claire
une et une seule variable...). Ca m'ennuie d'autant plus que c'est
justement ce que j'étais en train d'essayer de faire. ;)
Tu essaies de faire quoi ? Une déclaration using sur un membre
doit être dans la définition de la classe, c'est aussi simple
que ça. Et ça ne fera pas ce que tu veux.
Ce n'est pas un using sur un élément de namespace. Il n'y aucun
moyen de permettre l'écriture « s » pour X::s en dehors de la
classe comme on pourrait le faire avec un namespace. Il te faut
donc écrire X::s ou faire int& s= X::s;
(si c'est le pourquoi de cette règle qui t'intéresse, j'imagine
que c'est seulement qu'on n'a pas pensé que ce serait très
utile.)
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Je viens de tomber sur un souci en tentant une using-declaration des plus anodines. Le Stroustrup ne laissant pas entendre qu'il puisse y avoir de problème, je regarde la norme et je trouve :
7.3.3/6 « A using-declaration for a class member shall be a member-declaration.»
Heureusement, l'exemple donné renseigne sur la signification de "shall" :
struct X { int i; static int s; };
void f () { using X::i; // error: X::i is a class member // and this is not a member declaration using X::s; // error: X::s is a class member // and this is not a member declaration }
Alors autant je comprends pour i, autant je ne comprends pas trop pour une variable membre statique (X::s désignant de manière claire une et une seule variable...). Ca m'ennuie d'autant plus que c'est justement ce que j'étais en train d'essayer de faire. ;)
Tu essaies de faire quoi ? Une déclaration using sur un membre doit être dans la définition de la classe, c'est aussi simple que ça. Et ça ne fera pas ce que tu veux.
Ce n'est pas un using sur un élément de namespace. Il n'y aucun moyen de permettre l'écriture « s » pour X::s en dehors de la classe comme on pourrait le faire avec un namespace. Il te faut donc écrire X::s ou faire int& s= X::s;
(si c'est le pourquoi de cette règle qui t'intéresse, j'imagine que c'est seulement qu'on n'a pas pensé que ce serait très utile.)
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Gourgouilloult
(si c'est le pourquoi de cette règle qui t'intéresse,
Exactement. Si je citais la norme, c'était pour montrer que j'avais bien compris que j'avais pas le droit.
j'imagine que c'est seulement qu'on n'a pas pensé que ce serait très utile.)
Pourtant, dans l'exemple, ils ont songé à faire ressortir le cas des données membres statiques. Ca plutôt gros, comme coincidence, non ?
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas prévu de pouvoir vérifier dans une fonction ? Genre éviter les cas comme ça :
struct X { static int s_pub; private: static int s_priv; };
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
Gourgou (Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
(si c'est le pourquoi de cette règle qui t'intéresse,
Exactement. Si je citais la norme, c'était pour montrer que j'avais bien
compris que j'avais pas le droit.
j'imagine
que c'est seulement qu'on n'a pas pensé que ce serait très
utile.)
Pourtant, dans l'exemple, ils ont songé à faire ressortir le cas des
données membres statiques. Ca plutôt gros, comme coincidence, non ?
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir
raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas
prévu de pouvoir vérifier dans une fonction ? Genre éviter les cas comme
ça :
struct X {
static int s_pub;
private:
static int s_priv;
};
void f () {
using X::s_pub; // si ça passait, ça m'arrangerait
using X::s_priv; // ça, j'aimerais moins
}
Gourgou
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un
début d'idée, j'ai dit, hein...)
(si c'est le pourquoi de cette règle qui t'intéresse,
Exactement. Si je citais la norme, c'était pour montrer que j'avais bien compris que j'avais pas le droit.
j'imagine que c'est seulement qu'on n'a pas pensé que ce serait très utile.)
Pourtant, dans l'exemple, ils ont songé à faire ressortir le cas des données membres statiques. Ca plutôt gros, comme coincidence, non ?
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas prévu de pouvoir vérifier dans une fonction ? Genre éviter les cas comme ça :
struct X { static int s_pub; private: static int s_priv; };
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
Gourgou (Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
Gourgouilloult
Gourgouilloult parle tout seul :
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas prévu de pouvoir vérifier dans une fonction ?
Râh, genre pour dire des bêtises... faudrait qu'il y ait des tortuations folles dans la grammaire des using-declarations, pour que ça relève de ce genre de choses. Je veux dire, ça arrive d'avoir à résoudre des id de membres dans une fonction :
struct X { static int s_pub; private: static int s_priv; };
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
void g () { int i = X::s_pub; // ça marche, et c'est bien int j = X::s_priv; // ça marche pas, et c'est bien }
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans les bouquins ! [...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Gourgou Zut-euh !
Gourgouilloult parle tout seul :
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir
raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas
prévu de pouvoir vérifier dans une fonction ?
Râh, genre pour dire des bêtises... faudrait qu'il y ait des tortuations
folles dans la grammaire des using-declarations, pour que ça relève de
ce genre de choses. Je veux dire, ça arrive d'avoir à résoudre des id de
membres dans une fonction :
struct X {
static int s_pub;
private:
static int s_priv;
};
void f () {
using X::s_pub; // si ça passait, ça m'arrangerait
using X::s_priv; // ça, j'aimerais moins
}
void g () {
int i = X::s_pub; // ça marche, et c'est bien
int j = X::s_priv; // ça marche pas, et c'est bien
}
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans
les bouquins !
[...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un
début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Si je fais semblant d'avoir une idée, est-ce que je pourrais avoir raison de penser que ça a rapport aux niveaux d'accés, qu'il n'est pas prévu de pouvoir vérifier dans une fonction ?
Râh, genre pour dire des bêtises... faudrait qu'il y ait des tortuations folles dans la grammaire des using-declarations, pour que ça relève de ce genre de choses. Je veux dire, ça arrive d'avoir à résoudre des id de membres dans une fonction :
struct X { static int s_pub; private: static int s_priv; };
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
void g () { int i = X::s_pub; // ça marche, et c'est bien int j = X::s_priv; // ça marche pas, et c'est bien }
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans les bouquins ! [...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Gourgou Zut-euh !
Loïc Joly
Gourgouilloult wrote:
Gourgouilloult parle tout seul : Mais non, pas tout seul, certains écoutent...
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
void g () { int i = X::s_pub; // ça marche, et c'est bien int j = X::s_priv; // ça marche pas, et c'est bien }
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans les bouquins ! [...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Peut-être oublies-tu le but des using declaration pour des données membre, qui est tout autre que les using declaration pour les noms dans un namespace :
A usingdeclaration for a class member shall be a memberdeclaration.
Et :
A usingdeclaration used as a memberdeclaration shall refer to a member of a base class of the class being defined, shall refer to a member of an anonymous union that is a member of a base class of the class being defined, or shall refer to an enumerator for an enumeration type that is a member of a base class of the class being defined.
En gros, le but est uniquement de rendre visible aux utilisateurs d'une classe un nom d'une classe de base qui serait caché autrement.
-- Loïc
Gourgouilloult wrote:
Gourgouilloult parle tout seul :
Mais non, pas tout seul, certains écoutent...
void f () {
using X::s_pub; // si ça passait, ça m'arrangerait
using X::s_priv; // ça, j'aimerais moins
}
void g () {
int i = X::s_pub; // ça marche, et c'est bien
int j = X::s_priv; // ça marche pas, et c'est bien
}
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans
les bouquins !
[...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir
un début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Peut-être oublies-tu le but des using declaration pour des données
membre, qui est tout autre que les using declaration pour les noms dans
un namespace :
A usingdeclaration for a class member shall be a memberdeclaration.
Et :
A usingdeclaration used as a memberdeclaration shall refer to a member
of a base class of the class being defined, shall refer to a member of
an anonymous union that is a member of a base class of the class being
defined, or shall refer to an enumerator for an enumeration type that is
a member of a base class of the class being defined.
En gros, le but est uniquement de rendre visible aux utilisateurs d'une
classe un nom d'une classe de base qui serait caché autrement.
Gourgouilloult parle tout seul : Mais non, pas tout seul, certains écoutent...
void f () { using X::s_pub; // si ça passait, ça m'arrangerait using X::s_priv; // ça, j'aimerais moins }
void g () { int i = X::s_pub; // ça marche, et c'est bien int j = X::s_priv; // ça marche pas, et c'est bien }
Définitivement, cette dissymétrie m'interpelle... bon, hop, un tour dans les bouquins ! [...]
(Je suis pas certain que ça soit très sensé ; j'essaye juste d'avoir un début d'idée, j'ai dit, hein...)
Non, ç'a a vraiment pas l'air d'être ça. J'comprends pas.
Peut-être oublies-tu le but des using declaration pour des données membre, qui est tout autre que les using declaration pour les noms dans un namespace :
A usingdeclaration for a class member shall be a memberdeclaration.
Et :
A usingdeclaration used as a memberdeclaration shall refer to a member of a base class of the class being defined, shall refer to a member of an anonymous union that is a member of a base class of the class being defined, or shall refer to an enumerator for an enumeration type that is a member of a base class of the class being defined.
En gros, le but est uniquement de rendre visible aux utilisateurs d'une classe un nom d'une classe de base qui serait caché autrement.
-- Loïc
Gourgouilloult
Gourgouilloult parle tout seul :
Mais non, pas tout seul, certains écoutent...
Je ne craignais pas le contraire, mais il arrive que ma façon d'écrire tout ce que je pense (y compris, dans mes brouillons, ce que je pense de ce que j'écris, ainsi que les vannes à deux balles qui vont avec) surprenne. ;)
Définitivement, cette dissymétrie m'interpelle...
Peut-être oublies-tu le but des using declaration pour des données membre, qui est tout autre que les using declaration pour les noms dans un namespace : [...]
En gros, le but est uniquement de rendre visible aux utilisateurs d'une classe un nom d'une classe de base qui serait caché autrement.
En gros, on a using et using comme on a static, static et static... Mais tu conviendras que dans le cas des données membres statiques, c'est un poil lourd, quand même ?
Gourgou Inquiet ;)
Gourgouilloult parle tout seul :
Mais non, pas tout seul, certains écoutent...
Je ne craignais pas le contraire, mais il arrive que ma façon d'écrire
tout ce que je pense (y compris, dans mes brouillons, ce que je pense de
ce que j'écris, ainsi que les vannes à deux balles qui vont avec)
surprenne. ;)
Définitivement, cette dissymétrie m'interpelle...
Peut-être oublies-tu le but des using declaration pour des données
membre, qui est tout autre que les using declaration pour les noms dans
un namespace :
[...]
En gros, le but est uniquement de rendre visible aux utilisateurs d'une
classe un nom d'une classe de base qui serait caché autrement.
En gros, on a using et using comme on a static, static et static... Mais
tu conviendras que dans le cas des données membres statiques, c'est un
poil lourd, quand même ?
Je ne craignais pas le contraire, mais il arrive que ma façon d'écrire tout ce que je pense (y compris, dans mes brouillons, ce que je pense de ce que j'écris, ainsi que les vannes à deux balles qui vont avec) surprenne. ;)
Définitivement, cette dissymétrie m'interpelle...
Peut-être oublies-tu le but des using declaration pour des données membre, qui est tout autre que les using declaration pour les noms dans un namespace : [...]
En gros, le but est uniquement de rendre visible aux utilisateurs d'une classe un nom d'une classe de base qui serait caché autrement.
En gros, on a using et using comme on a static, static et static... Mais tu conviendras que dans le cas des données membres statiques, c'est un poil lourd, quand même ?
