Absurde Fehler bei der Verwendung von Vorlagenvorlagenargumenten

Question

Ich habe versucht, eine Vorlagenklasse (Test2) zu erstellen, die 2 Vorlagenargumente benötigt, Type1 und Type2. Es ist bekannt, dass das zweite Argument auch eine Vorlagenklasse wäre, die 2 Vorlagenargumente (TypeA und TypeB) benötigt.

Nun, für ein Objekt von Test2 konstruieren, mag ich den Benutzer in der Lage sein, entweder von zwei Arten von Konstrukteuren zu verwenden:

1. Eine, die Objekte von Type1 und Type2 nimmt.
2. Eine, die Objekte von Type1, TypeA und TypeB übernimmt.

Ich schrieb den folgenden Code:

#include <iostream> 

template<class TypeA, class TypeB> 
struct Test 
{ 
    TypeA t1obj; 
    TypeB t2obj; 
    Test(const TypeA& t1, const TypeB& t2) 
     : t1obj(t1), t2obj(t2) {std::cout<<"Test::Type1, Type2\n";} 
}; 


template<class Type1, 
     template<typename TypeX, typename TypeY> class Type2 > 
struct Test2 
{ 
    Type1 t1obj; 
    Type2<typename TypeX, typename TypeY> t2obj; //Line 17 

    Test2(const Type1& t1, 
      const Type2<typename TypeX, typename TypeY>& t2) //Line 20 
     : t1obj(t1), t2obj(t2) { std::cout<<"Test2::Type1, Type2\n";} 

    Test2(const Type1& t1, 
      const TypeX& x, 
      const TypeY& y) 
     : t1obj(t1), t2obj(x,y) { std::cout<<"Test2::Type1, X, Y\n";} 

}; 

int main() 
{ 
    Test<int, char> obj1(1,'a'); 

    Test2<int, Test<int, char> > strangeobj1(10,obj1); 
    Test2<int, Test<int, char> > strangeobj2(1,2,'b'); 

} 

Ich habe viel versucht, aber ich wirklich absurd Fehler wie:

wrong number of template arguments (1, should be 2) auf der Linie 17 und 20.

Answer 1

Es spielt keine‘ So arbeiten Sie so. Test<int, char> ist eine vollständige Typ, anstelle einer Vorlage. So müssen Sie Typparameter

template<class Type1, 
     class Type2 > 
struct Test2 
{ 
    Type1 t1obj; 
    Type2 t2obj; //Line 17 

    Test2(const Type1& t1, 
      const Type2& t2) //Line 20 
     : t1obj(t1), t2obj(t2) { std::cout<<"Test2::Type1, Type2\n";} 

    Test2(const Type1& t1, 
      const typename Type2::a_type& x, 
      const typename Type2::b_type& y) 
     : t1obj(t1), t2obj(x,y) { std::cout<<"Test2::Type1, X, Y\n";} 

}; 

Für immer TypeX und TypeY ist es sinnvoll, sie zu exportieren, um sie in Test2 verwenden können, wie oben gezeigt.

template<class TypeA, class TypeB> 
struct Test 
{ 
    typedef TypeA a_type; 
    typedef TypeB b_type; 

    // and using them, to show their meaning 
    a_type t1obj; 
    b_type t2obj; 

    Test(const a_type& t1, const b_type& t2) 
     : t1obj(t1), t2obj(t2) {std::cout<<"Test::Type1, Type2\n";} 
}; 

Seien Sie sicher, Where to put the "template" and "typename" on dependent names zu verstehen, zu lesen, warum und wann wie oben typename vor Typnamen zu verwenden.

Answer 2

Type1 ist ein Typ, Type2 ist eine Vorlage. Was genau denkst du, TypeX und TypeY sind definiert? In der Zeile template<typename TypeX, typename TypeY> class Type2 > werden sie ignoriert.

Answer 3

Hier ist eine Option:

#include <iostream> 

template<class TypeA, class TypeB> 
struct Test 
{ 
    TypeA t1obj; 
    TypeB t2obj; 
    Test(const TypeA& t1, const TypeB& t2) 
     : t1obj(t1), t2obj(t2) {std::cout<<"Test::Type1, Type2\n";} 
}; 


template<class Type1, typename TypeX, typename TypeY, 
     template <typename TypeXi, typename TypeYi> class Type2> 
struct Test2 
{ 
    Type1 t1obj; 
    Type2<typename TypeX, typename TypeY> t2obj; //Line 17 

    Test2(const Type1& t1, 
      const Type2<typename TypeX, typename TypeY>& t2) //Line 20 
     : t1obj(t1), t2obj(t2) { std::cout<<"Test2::Type1, Type2\n";} 

    Test2(const Type1& t1, 
      const TypeX& x, 
      const TypeY& y) 
     : t1obj(t1), t2obj(x,y) { std::cout<<"Test2::Type1, X, Y\n";} 

}; 

int main() 
{ 
    Test<int, char> obj1(1,'a'); 

    Test2<int, int, char, Test> strangeobj1(10,obj1); 
    Test2<int, int, char, Test> strangeobj2(1,2,'b'); 

} 

Answer 4

Es gibt mehrere Fehler mit diesem, aber der Hauptfehler scheint zu sein, dass

Test2<int, Test<int, char> > 

nicht, wie Sie eine Vorlage Template-Parameter übergeben. Dies wäre mit geben

Test2<int, Test> 

Das liegt daran, dass Test ist eine Vorlage aber Test<int, char> ist ein Typ (generiert aus dieser Vorlage.)

Answer 5

Test<int, char> ist kein Spiel für template<typename TypeX, typename TypeY> class Type2

Die erste ist eine Instantiierung einer Template-Klasse, sie akzeptiert keine Parameter.Die zweite ist ein Vorlagenklassenmuster, das zwei Parameter akzeptiert.