Question simple sur templates

"Vivien Parlat" <pocky6@gmail.com> writes:

Je voudrais savoir s'il y a un moyen de préciser qu'une classe
paramètre d'un template doit avoir un certain type (hériter d'une
certaine interface).

Il n'y a pas encore de moyen simple; il y a quelques moyens detournes
(cherche 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

Vivien Parlat wrote:

Je voudrais savoir s'il y a un moyen de préciser qu'une classe
paramètre d'un template doit avoir un certain type (hériter d'une
certaine interface).

Si tu peux utiliser Boost <http://www.boost.org> :

#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>

class I {};
class A : public I {};
class B {};

template<typename T> class Truc
{
BOOST_STATIC_ASSERT((boost::is_base_of<I, T>::value));
};

int main()
{
Truc<A> ta; // Cela compile
Truc<B> tb; // et cela donne une erreur à la compilation
return 0;
}

Merci (à quand (c++)++...)

"Vivien Parlat" <pocky6@gmail.com> a écrit dans le message de news:
1134404591.717718.211790@f14g2000cwb.googlegroups.com...

Merci (à quand (c++)++...)

C'est la définition de C# (quatre '+' placés en carré).

Pour faire un #, deux + suffisent...

Et en passant, la gestion des génériques et du concept checking
associé en C# est bien plus simple qu'en C++. Avec les avantages et
inconvénients qui vont avec la simplicité.

Bonjour,

Je suis récemment tombé sur un bout de code qui pourrait t'intéresser.
Tel qu'il était présenté, ce code permettait d'implémenter un classe Array
qui gère deux types de données: ceux qui dérivent d'une classe Clonable
d'une part et tous les autres d'autre part. En détournant un peu ce code (cf
ci-dessous), on arrive à quelquechose qui pourrait t'être utile.

NB: Je ne sais pas trop dans quelle mesure ce code est portable (qu'en
disent les spécialistes ?) mais il compile au moins avec VC.NET.

Cordialement,

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>
{
};

struct Interface
{
};

template <class T>
struct Truc: CheckInt<Inherit<Interface,T>::Is>
{
};

struct Machin: Interface
{
};

int main()
{
Truc<Machin> t1; // ok
Truc<int> t2; // erreur
}