Je souhaite écrire une classe qui hérite d'une classe template qui en pratique
doit être fille d'une classe mère connue. Est-il possible de spécifier cette
contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur
de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere;
class fille1; // hérite de mere
class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere
class maclasse : public T
{
//...
};
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
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
Je souhaite écrire une classe qui hérite d'une classe template qui en
pratique doit être fille d'une classe mère connue. Est-il possible de
spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous
connaissez un bon lien sur de la documentation, je suis preneur (je n'ai
pas encore réussi à trouver).
class mere;
class fille1; // hérite de mere
class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere
class maclasse : public T
{
//...
};
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche
"concept checking".
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
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
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
Marc Duflot
Aurélien Barbier-Accary wrote:
Bonjour et bonne année,
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
Regarde du côté de Boost.TypeTraits :
BOOST_STATIC-ASSERT(is_base_of<mere, T>::value)
(non-testé).
Aurélien Barbier-Accary wrote:
Bonjour et bonne année,
Je souhaite écrire une classe qui hérite d'une classe template qui en
pratique doit être fille d'une classe mère connue. Est-il possible de
spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous
connaissez un bon lien sur de la documentation, je suis preneur (je n'ai
pas encore réussi à trouver).
class mere;
class fille1; // hérite de mere
class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere
class maclasse : public T
{
//...
};
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
Regarde du côté de Boost.TypeTraits :
BOOST_STATIC-ASSERT(is_base_of<mere, T>::value)
(non-testé).
Aurélien Barbier-Accary
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
A+
Je n'ai pas encore trouvé ce que je cherche mais merci pour le tuyau. Et pour les curieux, je vous conseille de lire http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre plus sur l'utilisation des templates pour faire de la meta-programmation avec des gains d'exécution et de maintenance énormes. Bon par contre il faut s'accrocher, côté temps de développement au début... :-)
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche
"concept checking".
A+
Je n'ai pas encore trouvé ce que je cherche mais merci pour le tuyau.
Et pour les curieux, je vous conseille de lire
http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre plus sur
l'utilisation des templates pour faire de la meta-programmation avec des gains
d'exécution et de maintenance énormes. Bon par contre il faut s'accrocher, côté
temps de développement au début... :-)
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
A+
Je n'ai pas encore trouvé ce que je cherche mais merci pour le tuyau. Et pour les curieux, je vous conseille de lire http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre plus sur l'utilisation des templates pour faire de la meta-programmation avec des gains d'exécution et de maintenance énormes. Bon par contre il faut s'accrocher, côté temps de développement au début... :-)
Marc Boyer
Le 05-01-2006, Aurélien Barbier-Accary a écrit :
Bonjour et bonne année,
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
/// Declaration de la contrainte template <class T, class B> struct Derived_from { static void constraints(T* p) { B* pb = p; } Derived_from() { void(*p)(T*) = constraints; } };
template <class T> // T doit être une fille de mere class maclasse : public T { maclasse(...){ Derived_from<T,mere>(); .... } .... }
Marc Boyer -- Entre le fort et le faible, c'est la liberte qui opprime et le droit qui libere. Henri Lacordaire, Dominicain
Le 05-01-2006, Aurélien Barbier-Accary a écrit :
Bonjour et bonne année,
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique
doit être fille d'une classe mère connue. Est-il possible de spécifier cette
contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur
de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere;
class fille1; // hérite de mere
class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere
class maclasse : public T
{
//...
};
Je souhaite écrire une classe qui hérite d'une classe template qui en pratique doit être fille d'une classe mère connue. Est-il possible de spécifier cette contrainte ? et si oui comment bien sûr ? :-) Si vous connaissez un bon lien sur de la documentation, je suis preneur (je n'ai pas encore réussi à trouver).
class mere; class fille1; // hérite de mere class fille2; // hérite de mere mais n'a aucun lien avec fille1
template <class T> // T doit être une fille de mere class maclasse : public T { //... };
/// Declaration de la contrainte template <class T, class B> struct Derived_from { static void constraints(T* p) { B* pb = p; } Derived_from() { void(*p)(T*) = constraints; } };
template <class T> // T doit être une fille de mere class maclasse : public T { maclasse(...){ Derived_from<T,mere>(); .... } .... }
Marc Boyer -- Entre le fort et le faible, c'est la liberte qui opprime et le droit qui libere. Henri Lacordaire, Dominicain
kanze
Aurélien Barbier-Accary wrote:
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
Je n'ai pas encore trouvé ce que je cherche mais merci pour le tuyau. Et pour les curieux, je vous conseille de lire http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre plus sur l'utilisation des templates pour faire de la meta-programmation avec des gains d'exécution et de maintenance énormes. Bon par contre il faut s'accrocher, côté temps de développement au début... :-)
C'est une bonne introduction, mais méfie-toi en ce qui concerne les gains de maintenance. Les métaprogrammes eux-même sont extrèmement difficile à maintenir. Les gains ne se réalisent donc que si 1) le métaprogramme sert beaucoup (ce qui implique qu'il est bien documenté et facile à utilisé), et 2) il est assez stable lui-même, pour qu'on n'a pas souvent besoin d'y intervenir.
Dans la pratique, je crains que ces conditions ne soient rarement remplies dans les bureaux d'études d'informatique des sociétés non spécialisées, où on développe surtout des applications « in house ». Dans ces cas-là, je n'hésiterais pas à utiliser des métaprogrammes existants, surtout de Boost, mais j'aurais des réticences à en développer des propres moi-même.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Aurélien Barbier-Accary wrote:
Il y a des techniques mais j'ai pas le temps de les decrire.
Recherche "concept checking".
Je n'ai pas encore trouvé ce que je cherche mais merci pour le
tuyau. Et pour les curieux, je vous conseille de lire
http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre
plus sur l'utilisation des templates pour faire de la
meta-programmation avec des gains d'exécution et de
maintenance énormes. Bon par contre il faut s'accrocher, côté
temps de développement au début... :-)
C'est une bonne introduction, mais méfie-toi en ce qui concerne
les gains de maintenance. Les métaprogrammes eux-même sont
extrèmement difficile à maintenir. Les gains ne se réalisent
donc que si 1) le métaprogramme sert beaucoup (ce qui implique
qu'il est bien documenté et facile à utilisé), et 2) il est
assez stable lui-même, pour qu'on n'a pas souvent besoin d'y
intervenir.
Dans la pratique, je crains que ces conditions ne soient
rarement remplies dans les bureaux d'études d'informatique des
sociétés non spécialisées, où on développe surtout des
applications « in house ». Dans ces cas-là, je n'hésiterais pas
à utiliser des métaprogrammes existants, surtout de Boost, mais
j'aurais des réticences à en développer des propres moi-même.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Il y a des techniques mais j'ai pas le temps de les decrire. Recherche "concept checking".
Je n'ai pas encore trouvé ce que je cherche mais merci pour le tuyau. Et pour les curieux, je vous conseille de lire http://home.fnal.gov/~wb/metaprogramming.ppt pour en apprendre plus sur l'utilisation des templates pour faire de la meta-programmation avec des gains d'exécution et de maintenance énormes. Bon par contre il faut s'accrocher, côté temps de développement au début... :-)
C'est une bonne introduction, mais méfie-toi en ce qui concerne les gains de maintenance. Les métaprogrammes eux-même sont extrèmement difficile à maintenir. Les gains ne se réalisent donc que si 1) le métaprogramme sert beaucoup (ce qui implique qu'il est bien documenté et facile à utilisé), et 2) il est assez stable lui-même, pour qu'on n'a pas souvent besoin d'y intervenir.
Dans la pratique, je crains que ces conditions ne soient rarement remplies dans les bureaux d'études d'informatique des sociétés non spécialisées, où on développe surtout des applications « in house ». Dans ces cas-là, je n'hésiterais pas à utiliser des métaprogrammes existants, surtout de Boost, mais j'aurais des réticences à en développer des propres moi-même.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Gilles
| class mere; | class fille1; // hérite de mere | class fille2; // hérite de mere mais n'a aucun lien avec fille1 | | template <class T> // T doit être une fille de mere | class maclasse : public T | { | //... | };
Bonjour,
Il y a quelques semaines je suis tombé sur un code qui pourrait faire l'affaire (voir ci-dessous).
Gilles.
template <class BaseClass, class Class> class Inherit { private: class Yes { int a; }; class No { int a[4]; }; static Yes Test(BaseClass*); static No Test(...); // NB: il n'est pas utile de definir les fonctions Test ; elles // ne sont jamais appelees. public: // Is vaut 1 ssi Class derive de BaseClass enum { Is = (sizeof(Test((Class*)0)) == sizeof(Yes) ? 1: 0) }; };
// CheckInt compile ssi I vaut 1 template <int I> struct CheckInt { CheckInt() { error !! // provoque une erreur de compilation } }; template <> struct CheckInt<1> {};
int main() { Truc<Machin> t1; // ok Truc<int> t2; // erreur }
| class mere;
| class fille1; // hérite de mere
| class fille2; // hérite de mere mais n'a aucun lien avec fille1
|
| template <class T> // T doit être une fille de mere
| class maclasse : public T
| {
| //...
| };
Bonjour,
Il y a quelques semaines je suis tombé sur un code qui pourrait faire
l'affaire (voir ci-dessous).
Gilles.
template <class BaseClass, class Class>
class Inherit
{
private:
class Yes { int a; };
class No { int a[4]; };
static Yes Test(BaseClass*);
static No Test(...);
// NB: il n'est pas utile de definir les fonctions Test ; elles
// ne sont jamais appelees.
public:
// Is vaut 1 ssi Class derive de BaseClass
enum { Is = (sizeof(Test((Class*)0)) == sizeof(Yes) ? 1: 0) };
};
// CheckInt compile ssi I vaut 1
template <int I>
struct CheckInt
{
CheckInt()
{
error !! // provoque une erreur de compilation
}
};
template <> struct CheckInt<1> {};
| class mere; | class fille1; // hérite de mere | class fille2; // hérite de mere mais n'a aucun lien avec fille1 | | template <class T> // T doit être une fille de mere | class maclasse : public T | { | //... | };
Bonjour,
Il y a quelques semaines je suis tombé sur un code qui pourrait faire l'affaire (voir ci-dessous).
Gilles.
template <class BaseClass, class Class> class Inherit { private: class Yes { int a; }; class No { int a[4]; }; static Yes Test(BaseClass*); static No Test(...); // NB: il n'est pas utile de definir les fonctions Test ; elles // ne sont jamais appelees. public: // Is vaut 1 ssi Class derive de BaseClass enum { Is = (sizeof(Test((Class*)0)) == sizeof(Yes) ? 1: 0) }; };
// CheckInt compile ssi I vaut 1 template <int I> struct CheckInt { CheckInt() { error !! // provoque une erreur de compilation } }; template <> struct CheckInt<1> {};
/// Declaration de la contrainte template <class T, class B> struct Derived_from { static void constraints(T* p) { B* pb = p; } Derived_from() { void(*p)(T*) = constraints; } };
template <class T> // T doit être une fille de mere class maclasse : public T { maclasse(...){ Derived_from<T,mere>(); .... } .... }
Marc Boyer
Merci pour cette "astuce" ! Malheureusement finalement j'ai du abandonner l'idée car je voulais faire cela avec des Q_OBJECT (de Qt) ce qui n'est apparemment pas possible (hors quelques cas particuliers) :-( En tous cas j'ai gardé bien au chaud la structure Derived_from qui me servira sans doute très bientôt. Aurélien.
/// Declaration de la contrainte
template <class T, class B> struct Derived_from {
static void constraints(T* p) { B* pb = p; }
Derived_from() { void(*p)(T*) = constraints; }
};
template <class T> // T doit être une fille de mere
class maclasse : public T {
maclasse(...){
Derived_from<T,mere>();
....
}
....
}
Marc Boyer
Merci pour cette "astuce" !
Malheureusement finalement j'ai du abandonner l'idée car je voulais faire cela
avec des Q_OBJECT (de Qt) ce qui n'est apparemment pas possible (hors quelques
cas particuliers) :-(
En tous cas j'ai gardé bien au chaud la structure Derived_from qui me servira
sans doute très bientôt.
Aurélien.
/// Declaration de la contrainte template <class T, class B> struct Derived_from { static void constraints(T* p) { B* pb = p; } Derived_from() { void(*p)(T*) = constraints; } };
template <class T> // T doit être une fille de mere class maclasse : public T { maclasse(...){ Derived_from<T,mere>(); .... } .... }
Marc Boyer
Merci pour cette "astuce" ! Malheureusement finalement j'ai du abandonner l'idée car je voulais faire cela avec des Q_OBJECT (de Qt) ce qui n'est apparemment pas possible (hors quelques cas particuliers) :-( En tous cas j'ai gardé bien au chaud la structure Derived_from qui me servira sans doute très bientôt. Aurélien.
Aurélien Barbier-Accary
Regarde du côté de Boost.TypeTraits :
BOOST_STATIC-ASSERT(is_base_of<mere, T>::value)
(non-testé).
Merci. En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois déjà utiliser Qt et CGAL). Il faudra quand même que je me penche un peu plus sur Boost un de ces jours. Merci encore pour l'info. Aurélien
Regarde du côté de Boost.TypeTraits :
BOOST_STATIC-ASSERT(is_base_of<mere, T>::value)
(non-testé).
Merci.
En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser
Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois
déjà utiliser Qt et CGAL).
Il faudra quand même que je me penche un peu plus sur Boost un de ces jours.
Merci encore pour l'info.
Aurélien
Merci. En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois déjà utiliser Qt et CGAL). Il faudra quand même que je me penche un peu plus sur Boost un de ces jours. Merci encore pour l'info. Aurélien
Aurélien Barbier-Accary
[...] Dans ces cas-là, je n'hésiterais pas à utiliser des métaprogrammes existants, surtout de Boost, mais j'aurais des réticences à en développer des propres moi-même.
Merci pour cette mise en garde. Je n'ai pas encore commencé à faire de la méta-programmation mais j'y réfléchirai donc à deux fois. En tous cas l'idée est très stimulante... Aurélien.
[...] Dans ces cas-là, je n'hésiterais pas
à utiliser des métaprogrammes existants, surtout de Boost, mais
j'aurais des réticences à en développer des propres moi-même.
Merci pour cette mise en garde.
Je n'ai pas encore commencé à faire de la méta-programmation mais j'y
réfléchirai donc à deux fois.
En tous cas l'idée est très stimulante...
Aurélien.
[...] Dans ces cas-là, je n'hésiterais pas à utiliser des métaprogrammes existants, surtout de Boost, mais j'aurais des réticences à en développer des propres moi-même.
Merci pour cette mise en garde. Je n'ai pas encore commencé à faire de la méta-programmation mais j'y réfléchirai donc à deux fois. En tous cas l'idée est très stimulante... Aurélien.
Fabien LE LEZ
On Sun, 08 Jan 2006 11:00:59 +0100, Aurélien Barbier-Accary :
En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois déjà utiliser Qt et CGAL).
Il y a un phénomène qui joue contre Boost : à chaque fois qu'on pourrait l'utiliser, on se dit qu'installer Boost, c'est beaucoup de travail par rapport au petit problème qu'on a sur le moment, et on fait soi-même sa petite classe. Mais sur la longueur, il y a tellement de choses là-dedans que l'intégrer dans un projet peut être très intéressant. C'est d'ailleurs ma principale motivation pour abandonner Borland C++ 5.02.
On Sun, 08 Jan 2006 11:00:59 +0100, Aurélien Barbier-Accary :
En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser
Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois
déjà utiliser Qt et CGAL).
Il y a un phénomène qui joue contre Boost : à chaque fois qu'on
pourrait l'utiliser, on se dit qu'installer Boost, c'est beaucoup de
travail par rapport au petit problème qu'on a sur le moment, et on
fait soi-même sa petite classe.
Mais sur la longueur, il y a tellement de choses là-dedans que
l'intégrer dans un projet peut être très intéressant.
C'est d'ailleurs ma principale motivation pour abandonner Borland C++
5.02.
On Sun, 08 Jan 2006 11:00:59 +0100, Aurélien Barbier-Accary :
En fait (je ne suis pas sûr d'avoir raison mais) j'essaye de ne pas utiliser Boost pour réduire ma dépendance à de trop nombreuses bibliothèques (je dois déjà utiliser Qt et CGAL).
Il y a un phénomène qui joue contre Boost : à chaque fois qu'on pourrait l'utiliser, on se dit qu'installer Boost, c'est beaucoup de travail par rapport au petit problème qu'on a sur le moment, et on fait soi-même sa petite classe. Mais sur la longueur, il y a tellement de choses là-dedans que l'intégrer dans un projet peut être très intéressant. C'est d'ailleurs ma principale motivation pour abandonner Borland C++ 5.02.
