Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla
{
public:
int x;
class T;
};
class Bla::T : public Bla
{
public:
int h;
void aff(){printf("%d %d\n", x, h);}
};
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que
l'objet qui a créé la class Bla soit utilité pour créer celui de la
classe Bla::T et qu'on obtienne x=5 et h=7 ?
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main() { Bla *bla = new Bla; bla->x = 5; Bla* bla2 = new Bla; bla2->x = 6; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Adrien Constant <null@none.com> writes:
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla
{
public:
int x;
class T;
};
class Bla::T : public Bla
{
public:
int h;
void aff(){printf("%d %dn", x, h);}
};
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que
l'objet qui a créé la class Bla soit utilité pour créer celui de la classe
Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla* bla2 = new Bla;
bla2->x = 6;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main() { Bla *bla = new Bla; bla->x = 5; Bla* bla2 = new Bla; bla2->x = 6; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Alexandre
"Adrien Constant" a écrit dans le message de news:3f8cf8fd$0$20647$
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une classe par héritage d'une autre la contenant ? C'est tordu ?
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Merci.
Adrien Constant
"Adrien Constant" <null@none.com> a écrit dans le message de
news:3f8cf8fd$0$20647$626a54ce@news.free.fr...
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla
{
public:
int x;
class T;
};
class Bla::T : public Bla
{
public:
int h;
void aff(){printf("%d %dn", x, h);}
};
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une
classe par héritage d'une autre la contenant ?
C'est tordu ?
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que
l'objet qui a créé la class Bla soit utilité pour créer celui de la
classe Bla::T et qu'on obtienne x=5 et h=7 ?
"Adrien Constant" a écrit dans le message de news:3f8cf8fd$0$20647$
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une classe par héritage d'une autre la contenant ? C'est tordu ?
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Merci.
Adrien Constant
Adrien Constant
Dans quel cas (qui en fait n'est pas un cas que j'aurai la néccessité d'utiliser) je voudrais bien x=0 t=7, mais je voudrais avoir 5,7 sur le premier objet et 6,7 sur le second objet.
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main() { Bla *bla = new Bla; bla->x = 5; Bla* bla2 = new Bla; bla2->x = 6; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Dans quel cas (qui en fait n'est pas un cas que j'aurai la néccessité
d'utiliser) je voudrais bien x=0 t=7, mais je voudrais avoir 5,7 sur le
premier objet et 6,7 sur le second objet.
Jean-Marc Bourguet wrote:
Adrien Constant <null@none.com> writes:
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla
{
public:
int x;
class T;
};
class Bla::T : public Bla
{
public:
int h;
void aff(){printf("%d %dn", x, h);}
};
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que
l'objet qui a créé la class Bla soit utilité pour créer celui de la classe
Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla* bla2 = new Bla;
bla2->x = 6;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Dans quel cas (qui en fait n'est pas un cas que j'aurai la néccessité d'utiliser) je voudrais bien x=0 t=7, mais je voudrais avoir 5,7 sur le premier objet et 6,7 sur le second objet.
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Et quel resultat veux-tu pour
int main() { Bla *bla = new Bla; bla->x = 5; Bla* bla2 = new Bla; bla2->x = 6; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Adrien Constant
Non ce n'est pas tordu cela est courant dans certains langages.
struct T {}; struct Bla { struct T *t; };
Et bien je veux faire pareil avec des classes tout en ayant T qui puisse accéder aux méthodes / variables publiques de Bla. C'est évidemment possible de passer par une référence de Bla mais je pense qu'il est possible de faire autrement, puisque c'est a ca que sert l'héritage ai-je cru comprendre.
L'intéret n'est autre que pour la clareté du code, le plus simple est effectivement de faire deux classes séparées. Je ne vois pas ce qu'il y a de tordu a avoir une classe dans une classe et vouloir en hériter.
class Bla { public: int x, y, z; int *fd_list; }
On peut tout simplement avoir besoin d'une classe spéciale au lieu d'utiliser int *fd_list dans que cas on peut créer
class FdList { public: FdList(); ~FdList(); Add(int fd); Remove(int fd); int *fd_list; }
et décider de faire new Bla::FdList[15];
Alexandre wrote:
"Adrien Constant" a écrit dans le message de news:3f8cf8fd$0$20647$
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une classe par héritage d'une autre la contenant ? C'est tordu ?
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Merci.
Adrien Constant
Non ce n'est pas tordu cela est courant dans certains langages.
struct T {};
struct Bla { struct T *t; };
Et bien je veux faire pareil avec des classes tout en ayant T qui puisse
accéder aux méthodes / variables publiques de Bla. C'est évidemment
possible de passer par une référence de Bla mais je pense qu'il est
possible de faire autrement, puisque c'est a ca que sert l'héritage
ai-je cru comprendre.
L'intéret n'est autre que pour la clareté du code, le plus simple est
effectivement de faire deux classes séparées. Je ne vois pas ce qu'il y
a de tordu a avoir une classe dans une classe et vouloir en hériter.
class Bla {
public:
int x, y, z;
int *fd_list;
}
On peut tout simplement avoir besoin d'une classe spéciale au lieu
d'utiliser int *fd_list dans que cas on peut créer
class FdList {
public:
FdList();
~FdList();
Add(int fd);
Remove(int fd);
int *fd_list;
}
et décider de faire new Bla::FdList[15];
Alexandre wrote:
"Adrien Constant" <null@none.com> a écrit dans le message de
news:3f8cf8fd$0$20647$626a54ce@news.free.fr...
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla
{
public:
int x;
class T;
};
class Bla::T : public Bla
{
public:
int h;
void aff(){printf("%d %dn", x, h);}
};
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une
classe par héritage d'une autre la contenant ?
C'est tordu ?
int main()
{
Bla *bla = new Bla;
bla->x = 5;
Bla::T *t = new Bla::T;
t->h = 7;
t->aff();
}
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que
l'objet qui a créé la class Bla soit utilité pour créer celui de la
classe Bla::T et qu'on obtienne x=5 et h=7 ?
Non ce n'est pas tordu cela est courant dans certains langages.
struct T {}; struct Bla { struct T *t; };
Et bien je veux faire pareil avec des classes tout en ayant T qui puisse accéder aux méthodes / variables publiques de Bla. C'est évidemment possible de passer par une référence de Bla mais je pense qu'il est possible de faire autrement, puisque c'est a ca que sert l'héritage ai-je cru comprendre.
L'intéret n'est autre que pour la clareté du code, le plus simple est effectivement de faire deux classes séparées. Je ne vois pas ce qu'il y a de tordu a avoir une classe dans une classe et vouloir en hériter.
class Bla { public: int x, y, z; int *fd_list; }
On peut tout simplement avoir besoin d'une classe spéciale au lieu d'utiliser int *fd_list dans que cas on peut créer
class FdList { public: FdList(); ~FdList(); Add(int fd); Remove(int fd); int *fd_list; }
et décider de faire new Bla::FdList[15];
Alexandre wrote:
"Adrien Constant" a écrit dans le message de news:3f8cf8fd$0$20647$
Ou ne sait quel nom cela porte, mais considérant l'exemple suivant :
#include <stdio.h>
class Bla { public: int x; class T; };
class Bla::T : public Bla { public: int h; void aff(){printf("%d %dn", x, h);} };
j'avoue ne pas bien comprendre l'interet de la chose... Tu définies une classe par héritage d'une autre la contenant ? C'est tordu ?
int main() { Bla *bla = new Bla; bla->x = 5; Bla::T *t = new Bla::T; t->h = 7; t->aff(); }
Cela affiche évidemment x=undef=0 et h=7, hors comment faire pour que l'objet qui a créé la class Bla soit utilité pour créer celui de la classe Bla::T et qu'on obtienne x=5 et h=7 ?
Merci.
Adrien Constant
Jean-Marc Bourguet
Adrien Constant writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Adrien Constant <null@none.com> writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les
"inner classes" de Java (qui ne sont pas du tout la meme chose que les
classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non
plus comme tu veux en Java a ma connaissance.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Adrien Constant
Non, je ne pensais pas à java mais à perl
package Bla; package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance.
A+
Non, je ne pensais pas à java mais à perl
package Bla;
package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les
fonctions des deux. Le procédé est surement assez différent puisque pour
cela perl utilise des fonctions import qui traitent les ptrs sur
fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Jean-Marc Bourguet wrote:
Adrien Constant <null@none.com> writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les
"inner classes" de Java (qui ne sont pas du tout la meme chose que les
classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non
plus comme tu veux en Java a ma connaissance.
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance.
A+
Jean-Marc Bourguet
Adrien Constant writes:
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Non ce n'est pas tordu cela est courant dans certains langages. Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance. A+ Non, je ne pensais pas à java mais à perl
package Bla; package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Adrien Constant <null@none.com> writes:
Jean-Marc Bourguet wrote:
Adrien Constant <null@none.com> writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les
"inner classes" de Java (qui ne sont pas du tout la meme chose que les
classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non
plus comme tu veux en Java a ma connaissance.
A+
Non, je ne pensais pas à java mais à perl
package Bla;
package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions
des deux. Le procédé est surement assez différent puisque pour cela perl
utilise des fonctions import qui traitent les ptrs sur fonctions et
variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Non ce n'est pas tordu cela est courant dans certains langages. Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance. A+ Non, je ne pensais pas à java mais à perl
package Bla; package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Gabriel Dos Reis
Adrien Constant writes:
| Non, je ne pensais pas à java mais à perl
perl, c'est le compilateur/interpréteur ; le langage s'appelle Perl.
-- Gaby
Adrien Constant <null@none.com> writes:
| Non, je ne pensais pas à java mais à perl
perl, c'est le compilateur/interpréteur ; le langage s'appelle Perl.
perl, c'est le compilateur/interpréteur ; le langage s'appelle Perl.
-- Gaby
Adrien Constant
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Jean-Marc Bourguet wrote:
Adrien Constant writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance. A+
Non, je ne pensais pas à java mais à perl
package Bla; package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
Pq pas.
Bref... ce n'est pas vraiment ca car si j'ai bien compris les fctions statiques n'utilisent pas d'object, hors moi je veux pouvoir créer autant d'objet que je le souhaite de chaque classe.. si je me trompe dites le moi. EN tout cas, présenté de manière plus claire mais totalement fausse:
class Hello { public: int qf; Hello(unsigned int i=0){qf=i;}; ~Hello(){}; class World { World(){}; ~World(){}; void Aff(){printf("%dn",qf);}; }; };
int main() { Hello *hello1 = new Hello(5); // je sais que cette ligne est absurde mais c'est pour expliquer // ce que je veux faire et que je ne sais comment faire hello1->World = new Hello::World; hello1->World->Aff(); // il faut que cela affiche 5
Hello *hello2 = new Hello(42); hello2->World = new Hello::World; hello2->World->Aff(); // il faut que cela affiche 42 }
Voilà.. si qq'un arrive à me comprendre ce me serait vraiment très très utile de savoir :)
Jean-Marc Bourguet wrote:
Adrien Constant <null@none.com> writes:
Jean-Marc Bourguet wrote:
Adrien Constant <null@none.com> writes:
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant
c'est lequel? Je soupconne une grosse confusion avec Java et les
"inner classes" de Java (qui ne sont pas du tout la meme chose que les
classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non
plus comme tu veux en Java a ma connaissance.
A+
Non, je ne pensais pas à java mais à perl
package Bla;
package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions
des deux. Le procédé est surement assez différent puisque pour cela perl
utilise des fonctions import qui traitent les ptrs sur fonctions et
variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
Pq pas.
Bref... ce n'est pas vraiment ca car si j'ai bien compris les fctions
statiques n'utilisent pas d'object, hors moi je veux pouvoir créer
autant d'objet que je le souhaite de chaque classe.. si je me trompe
dites le moi. EN tout cas, présenté de manière plus claire mais
totalement fausse:
class Hello
{
public:
int qf;
Hello(unsigned int i=0){qf=i;};
~Hello(){};
class World
{
World(){};
~World(){};
void Aff(){printf("%dn",qf);};
};
};
int main()
{
Hello *hello1 = new Hello(5);
// je sais que cette ligne est absurde mais c'est pour expliquer
// ce que je veux faire et que je ne sais comment faire
hello1->World = new Hello::World;
hello1->World->Aff();
// il faut que cela affiche 5
Hello *hello2 = new Hello(42);
hello2->World = new Hello::World;
hello2->World->Aff();
// il faut que cela affiche 42
}
Voilà.. si qq'un arrive à me comprendre ce me serait vraiment très très
utile de savoir :)
Non ce n'est pas tordu cela est courant dans certains langages.
Peux-tu donner un exemple dans cet autre langage -- en nous disant c'est lequel? Je soupconne une grosse confusion avec Java et les "inner classes" de Java (qui ne sont pas du tout la meme chose que les classes imbriquees de C++) mais ce que tu fais ne fonctionne pas non plus comme tu veux en Java a ma connaissance. A+
Non, je ne pensais pas à java mais à perl
package Bla; package Bla::T;
et ce qui permet d'utiliser les variables globales (our) et les fonctions des deux. Le procédé est surement assez différent puisque pour cela perl utilise des fonctions import qui traitent les ptrs sur fonctions et variables déclarées pour etre importées.
Ca ne me dit tjs pas comment faire en C++...
Ce que tu as l'air de vouloir, c'est des membres statiques.
A+
(repond *apres* ce a quoi tu reponds stp)
Pq pas.
Bref... ce n'est pas vraiment ca car si j'ai bien compris les fctions statiques n'utilisent pas d'object, hors moi je veux pouvoir créer autant d'objet que je le souhaite de chaque classe.. si je me trompe dites le moi. EN tout cas, présenté de manière plus claire mais totalement fausse:
class Hello { public: int qf; Hello(unsigned int i=0){qf=i;}; ~Hello(){}; class World { World(){}; ~World(){}; void Aff(){printf("%dn",qf);}; }; };
int main() { Hello *hello1 = new Hello(5); // je sais que cette ligne est absurde mais c'est pour expliquer // ce que je veux faire et que je ne sais comment faire hello1->World = new Hello::World; hello1->World->Aff(); // il faut que cela affiche 5
Hello *hello2 = new Hello(42); hello2->World = new Hello::World; hello2->World->Aff(); // il faut que cela affiche 42 }
Voilà.. si qq'un arrive à me comprendre ce me serait vraiment très très utile de savoir :)
Adrien Constant
et moi j'avais entendu Perl est l'implémentation de perl donc ce serait bien en perl basé sur je ne sais plus quelle déclaration de Larry Wall...
Gabriel Dos Reis wrote:
Adrien Constant writes:
| Non, je ne pensais pas à java mais à perl
perl, c'est le compilateur/interpréteur ; le langage s'appelle Perl.
-- Gaby
et moi j'avais entendu Perl est l'implémentation de perl
donc ce serait bien en perl
basé sur je ne sais plus quelle déclaration de Larry Wall...
Gabriel Dos Reis wrote:
Adrien Constant <null@none.com> writes:
| Non, je ne pensais pas à java mais à perl
perl, c'est le compilateur/interpréteur ; le langage s'appelle Perl.
