La classe C++ template spécifique baseclass

Disons que j'ai des classes:

class Base{};

class A: public Base{
    int i;
};

class B:public Base{
    bool b;
};

Et maintenant, je veux définir basé sur un modèle de classe:

template < typename T1, typename T2 >
class BasePair{
    T1 first;
    T2 second;
};

Mais je tiens à le définir à ce que seuls les descendants de la classe de Base peut être utilisé comme templateparameters.

Comment puis-je le faire?

Vous devez corriger votre syntaxe du modèle. Et voulez-vous dire A et B d'être privé dérivé?

InformationsquelleAutor Mat | 2010-01-06

c++generics inheritance templates

Plus exactement:

class B {};
class D1 : public B {};
class D2 : public B {};
class U {};

template <class X, class Y> class P {
    X x;
    Y y;
public:
    P() {
        (void)static_cast<B*>((X*)0);
        (void)static_cast<B*>((Y*)0);
    }
};

int main() {
    P<D1, D2> ok;
    P<U, U> nok; //error
}

InformationsquelleAutor user213546

C++11 introduit <type_traits>

template <typename T1, typename T2>
class BasePair{
static_assert(std::is_base_of<Base, T1>::value, "T1 must derive from Base");
static_assert(std::is_base_of<Base, T2>::value, "T2 must derive from Base");

    T1 first;
    T2 second;
};

InformationsquelleAutor Hashbrown

9

C++ ne permet pas encore de permettre à cette directement. Vous pouvez le réaliser indirectement à l'aide d'un STATIC_ASSERT et la vérification de type à l'intérieur de la classe:
```
template < typename T1, typename T2 >
class BasePair{
    BOOST_STATIC_ASSERT(boost::is_base_of<Base, T1>);
    BOOST_STATIC_ASSERT(boost::is_base_of<Base, T2>);
    T1 first;
    T2 second;
};
```
- je ne veux pas les paramètres juste pour avoir la même classe de base - je veux qu'ils aient ma classe spécifique de la Base de baseclass
- Le mot clé étant "encore". Pour le bénéfice de ceux qui arrivent ici à partir d'un moteur de recherche, static_assert et is_base_of diplômé de langue officielle fonctionnalités de C++11. Ils font beaucoup plus intuitive/moins horrible que le code de la accepté de répondre.
InformationsquelleAutor Konrad Rudolph

C'était une bonne question! Alors que des recherches sur ce par l'intermédiaire de ce lien, je suis venu avec la suivante, qui, certes, n'est pas tellement différente de la solution fournie par là. Apprendre quelque chose tous les jours...check!

#include <iostream>
#include <string>
#include <boost/static_assert.hpp>
using namespace std;
template<typename D, typename B>
class IsDerivedFrom
{
class No { };
class Yes { No no[3]; };
static Yes Test(B*); //declared, but not defined
static No Test(...); //declared, but not defined
public:
enum { IsDerived = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes) };
};
class Base
{
public:
virtual ~Base() {};
};
class A : public Base
{
int i;
};
class B : public Base
{
bool b;
};
class C
{
string z;
};
template <class T1, class T2>
class BasePair
{
public:
BasePair(T1 first, T2 second)
:m_first(first),
m_second(second)
{
typedef IsDerivedFrom<T1, Base> testFirst;
typedef IsDerivedFrom<T2, Base> testSecond;
//Compile time check do...
BOOST_STATIC_ASSERT(testFirst::IsDerived == true);
BOOST_STATIC_ASSERT(testSecond::IsDerived == true);
//For runtime check do..
if (!testFirst::IsDerived)
cout << "\tFirst is NOT Derived!\n";
if (!testSecond::IsDerived)
cout << "\tSecond is NOT derived!\n";
}
private:
T1 m_first;
T2 m_second;
};
int main(int argc, char *argv[])
{
A a;
B b;
C c;
cout << "Creating GOOD pair\n";
BasePair<A, B> good(a, b);
cout << "Creating BAD pair\n";
BasePair<C, B> bad(c, b);
return 1;
}

InformationsquelleAutor RC.

0
```
class B
{
};
class D : public B
{
};
class U
{
};
template <class X, class Y> class P
{
X x;
Y y;
public:
P()
{
(void)static_cast<X*>((Y*)0);
}
};
```
- expliquez s'il vous plaît.. comment cela garantit que les paramètres du modèle sont les descendants de B?
- Lorsque vous instanciez le modèle P<B, D> ok; le compilateur va essayer d'utiliser le static_cast modèle de la fonction de convertir D pointeur de type B de type pointeur. Cela fonctionne bien, mais, en cas de P<B, U> nok; cette conversion échoue et vous recevez une erreur de compilateur (error C2440: 'static_cast' : impossible de convertir de 'U " à " B'). En outre, ce n'aurez pas le temps d'exécution de l'effet(le code n'est pas plus lent). C'est un statique ou au moment de la compilation de vérification de type.
InformationsquelleAutor user213546
0

Tout d'abord, fixer la déclaration
```
template < class T1, class T2 >
class BasePair{
T1 first;
T2 second;
};
```
Ensuite, vous pouvez déclarer, dans une classe de base certains private function Foo(); et que dire de la classe de Base pour avoir BasePair comme ami; puis, dans l'ami de constructeur, il vous suffit d'appeler cette fonction. De cette façon, vous obtiendrez l'erreur de compilation lorsque quelqu'un tente d'utiliser d'autres classes que les paramètres du modèle.
- “fixer la déclaration” – la va de même pour vous, trop. 😉
InformationsquelleAutor alemjerus
0

Dans la réponse suggérée par des inconnus(yahoo), il n'est pas nécessaire d'avoir des variables de type X et Y en tant que membres. Ces lignes sont suffisantes dans le constructeur:
```
static_cast<B*>((X*)0);
static_cast<B*>((Y*)0);
```
InformationsquelleAutor mukeshkumar

Vous devez vous connecter pour publier un commentaire.