Est-ce possible de déclarer une propriété de même classe que celle qui la possède ?
class A { A a; };
ne compile pas.
Je suis vraiment trop con. C'est conceptuellement idiot ;)
Sylvain
Azuriel wrote on 28/09/2006 19:34:
Est-ce possible de déclarer une propriété de même classe que celle qui la possède ?
class A { A a; };
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile; cela peut même être une façon de coder un noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une référence ou un pointeur (les 2 valant pour un pointeur de taille connu alors que la classe est de taille inconnue lorsque la donnée 'a' est parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A { A& a; A(A another) : a(another) { ... } };
ou
class A { A* a; A() : a(null) { ... } A(A& another) : a(&another) { ... } A(A* another) : a(another) { ... } ou autres formes pertinentes };
Sylvain.
Azuriel wrote on 28/09/2006 19:34:
Est-ce possible de déclarer une propriété de même classe que celle qui
la possède ?
class A
{
A a;
};
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile; cela peut même être une façon de coder un
noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui
ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une
référence ou un pointeur (les 2 valant pour un pointeur de taille connu
alors que la classe est de taille inconnue lorsque la donnée 'a' est
parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A {
A& a;
A(A another) : a(another) { ... }
};
ou
class A {
A* a;
A() : a(null) { ... }
A(A& another) : a(&another) { ... }
A(A* another) : a(another) { ... }
ou autres formes pertinentes
};
Est-ce possible de déclarer une propriété de même classe que celle qui la possède ?
class A { A a; };
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile; cela peut même être une façon de coder un noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une référence ou un pointeur (les 2 valant pour un pointeur de taille connu alors que la classe est de taille inconnue lorsque la donnée 'a' est parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A { A& a; A(A another) : a(another) { ... } };
ou
class A { A* a; A() : a(null) { ... } A(A& another) : a(&another) { ... } A(A* another) : a(another) { ... } ou autres formes pertinentes };
Sylvain.
Azuriel
Azuriel wrote on 28/09/2006 19:34:
Est-ce possible de déclarer une propriété de même classe que celle qui la possède ?
class A { A a; };
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile;
Si si, je voulais *vraiment* que A contient une instance de lui-même en propriété et pas une référence ;). Quel idiot...
cela peut même être une façon de coder un noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une référence ou un pointeur (les 2 valant pour un pointeur de taille connu alors que la classe est de taille inconnue lorsque la donnée 'a' est parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
Azuriel wrote on 28/09/2006 19:34:
Est-ce possible de déclarer une propriété de même classe que celle
qui la possède ?
class A
{
A a;
};
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile;
Si si, je voulais *vraiment* que A contient une instance de lui-même en
propriété et pas une référence ;). Quel idiot...
cela peut même être une façon de coder un
noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui
ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une
référence ou un pointeur (les 2 valant pour un pointeur de taille connu
alors que la classe est de taille inconnue lorsque la donnée 'a' est
parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A {
A& a;
A(A another) : a(another) { ... }
};
Pour le cas du pointeur, c'est trivial, par contre pour les références,
j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y
arrive pas.
Puisqu'il faut forcément fournir un nouveau A au constructeur de A,
comment créer un A "originel" sans rien lui fournir ?
Est-ce possible de déclarer une propriété de même classe que celle qui la possède ?
class A { A a; };
Je suis vraiment trop con. C'est conceptuellement idiot ;)
non, ni idiot, ni inutile;
Si si, je voulais *vraiment* que A contient une instance de lui-même en propriété et pas une référence ;). Quel idiot...
cela peut même être une façon de coder un noeud dans un arbre ou une liste chainée (ok, depuis std::/set/ qui ferait ça?).
l'auto-référencement impose simplement que la donnée membre soit une référence ou un pointeur (les 2 valant pour un pointeur de taille connu alors que la classe est de taille inconnue lorsque la donnée 'a' est parsée - ce qui provoque l'impossibilité de compiler).
donc:
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
Sylvain
Azuriel wrote on 28/09/2006 20:17:
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
Sylvain.
Azuriel wrote on 28/09/2006 20:17:
class A {
A& a;
A(A another) : a(another) { ... }
};
Pour le cas du pointeur, c'est trivial, par contre pour les références,
j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y
arrive pas.
Puisqu'il faut forcément fournir un nouveau A au constructeur de A,
comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le
faisant passer pour qlq chose ...
A* first = null;
A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent
d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette
valeur ne conduira pas à un code très clean mais bon ...).
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
Sylvain.
Michel Decima
Sylvain wrote:
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
Est ce que *first a un comportement defini si first vaut NULL ?
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle
Vraiment ?
Sylvain wrote:
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le
faisant passer pour qlq chose ...
A* first = null;
A a(*first);
Est ce que *first a un comportement defini si first vaut NULL ?
une référence (hormis la simplification syntaxique) est l'équivalent
d'un pointeur, donc on peut lui affecter une valeur nulle
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
Est ce que *first a un comportement defini si first vaut NULL ?
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle
Vraiment ?
Azuriel
Azuriel wrote on 28/09/2006 20:17:
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
Ok ;) Donc c'était juste pour l'exercice de style quoi ;) J'espère jamais n'avoir à faire ce genre de choses. Par contre c'est intéressant, merci pour ton intervention.
Azuriel wrote on 28/09/2006 20:17:
class A {
A& a;
A(A another) : a(another) { ... }
};
Pour le cas du pointeur, c'est trivial, par contre pour les
références, j'aimerais un exemple qui compile dans ce cas et
utilisable car je n'y arrive pas.
Puisqu'il faut forcément fournir un nouveau A au constructeur de A,
comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le
faisant passer pour qlq chose ...
A* first = null;
A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent
d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette
valeur ne conduira pas à un code très clean mais bon ...).
Ok ;) Donc c'était juste pour l'exercice de style quoi ;) J'espère
jamais n'avoir à faire ce genre de choses.
Par contre c'est intéressant, merci pour ton intervention.
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
Ok ;) Donc c'était juste pour l'exercice de style quoi ;) J'espère jamais n'avoir à faire ce genre de choses. Par contre c'est intéressant, merci pour ton intervention.
Sylvain
Michel Decima wrote on 28/09/2006 21:50:
Sylvain wrote:
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
Est ce que *first a un comportement defini si first vaut NULL ?
quelle importance puisqu'il N'est PAS déréférencé ... sous réserve d'un cst A(A&) et non A(A) comme je l'ai noté.
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle
Vraiment ?
si tu comprends "affecter" comme "A& a = null;" alors ton étonnement (?) est légitime; mais je ne l'ai pas écrit comme cela.
Sylvain.
Michel Decima wrote on 28/09/2006 21:50:
Sylvain wrote:
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le
faisant passer pour qlq chose ...
A* first = null;
A a(*first);
Est ce que *first a un comportement defini si first vaut NULL ?
quelle importance puisqu'il N'est PAS déréférencé ... sous réserve d'un
cst A(A&) et non A(A) comme je l'ai noté.
une référence (hormis la simplification syntaxique) est l'équivalent
d'un pointeur, donc on peut lui affecter une valeur nulle
Vraiment ?
si tu comprends "affecter" comme "A& a = null;" alors ton étonnement (?)
est légitime; mais je ne l'ai pas écrit comme cela.
Ok ;) Donc c'était juste pour l'exercice de style quoi ;)
bonne pioche.
J'espère jamais n'avoir à faire ce genre de choses.
j'éviterai aussi.
Sylvain.
Pierre Barbier de Reuille
Azuriel wrote on 28/09/2006 20:17:
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
La différence fondamentale entre un pointeur et une référence est qu'il n'est pas possible de changer l'adresse pointée vers la référence ...
Du coup l'intérêt est assez limité ... (genre, pas possible de faire une liste chaînée avec ou alors une liste chaînée qui, une fois créée ne peut être changée ... très limité comme intérêt !!)
Enfin, une autre possibilité est:
struct A { A() : a( *this ) {} A( A& b ) : a( b ) {} A& a; };
int main() { A a; A b( a ); return 0; }
Tans que la référence n'est pas utilisée dans le constructeur par défaut c'est valide ...
Pierre
Azuriel wrote on 28/09/2006 20:17:
class A {
A& a;
A(A another) : a(another) { ... }
};
Pour le cas du pointeur, c'est trivial, par contre pour les
références, j'aimerais un exemple qui compile dans ce cas et
utilisable car je n'y arrive pas.
Puisqu'il faut forcément fournir un nouveau A au constructeur de A,
comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le
faisant passer pour qlq chose ...
A* first = null;
A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent
d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette
valeur ne conduira pas à un code très clean mais bon ...).
La différence fondamentale entre un pointeur et une référence est qu'il
n'est pas possible de changer l'adresse pointée vers la référence ...
Du coup l'intérêt est assez limité ... (genre, pas possible de faire une
liste chaînée avec ou alors une liste chaînée qui, une fois créée ne
peut être changée ... très limité comme intérêt !!)
Enfin, une autre possibilité est:
struct A
{
A() : a( *this ) {}
A( A& b ) : a( b ) {}
A& a;
};
int main()
{
A a;
A b( a );
return 0;
}
Tans que la référence n'est pas utilisée dans le constructeur par défaut
c'est valide ...
class A { A& a; A(A another) : a(another) { ... } };
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
;-) !
faute de pouvoir ne rien lui fournir, on peut lui fournir rien en le faisant passer pour qlq chose ...
A* first = null; A a(*first);
une référence (hormis la simplification syntaxique) est l'équivalent d'un pointeur, donc on peut lui affecter une valeur nulle (tester cette valeur ne conduira pas à un code très clean mais bon ...).
La différence fondamentale entre un pointeur et une référence est qu'il n'est pas possible de changer l'adresse pointée vers la référence ...
Du coup l'intérêt est assez limité ... (genre, pas possible de faire une liste chaînée avec ou alors une liste chaînée qui, une fois créée ne peut être changée ... très limité comme intérêt !!)
Enfin, une autre possibilité est:
struct A { A() : a( *this ) {} A( A& b ) : a( b ) {} A& a; };
int main() { A a; A b( a ); return 0; }
Tans que la référence n'est pas utilisée dans le constructeur par défaut c'est valide ...
Pierre
alexandre
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
class A { A& papa:
public: A(A& pere):papa(pere){} static A LePremier;
private: A():papa(*this){} };
et il suffit de construire un A à partir de l'instance statique "LePremier"... qui est son propre 'père'
Pour le cas du pointeur, c'est trivial, par contre pour les références,
j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y
arrive pas.
Puisqu'il faut forcément fournir un nouveau A au constructeur de A,
comment créer un A "originel" sans rien lui fournir ?
class A
{
A& papa:
public:
A(A& pere):papa(pere){}
static A LePremier;
private:
A():papa(*this){}
};
et il suffit de construire un A à partir de l'instance statique
"LePremier"... qui est son propre 'père'
Pour le cas du pointeur, c'est trivial, par contre pour les références, j'aimerais un exemple qui compile dans ce cas et utilisable car je n'y arrive pas. Puisqu'il faut forcément fournir un nouveau A au constructeur de A, comment créer un A "originel" sans rien lui fournir ?
class A { A& papa:
public: A(A& pere):papa(pere){} static A LePremier;
private: A():papa(*this){} };
et il suffit de construire un A à partir de l'instance statique "LePremier"... qui est son propre 'père'
