Template-Template-Argument - Typ/Wert Mismatch Fehler

Question

Hier ist ein Beispielcode:

#include <stack> 
#include <cstddef> 

template <std::size_t N, 
     template <class> class Stack = std::stack 
     > 
class Tower : protected Stack<int> 
{ 
    public: 
     Tower() : Stack<int>(N) 
     { 
     } 
}; 


int main(int argc, char **argv) 
{ 
    Tower<5L> tower1(); 
} 

Und ich sehe den Compiler (gcc) ist nicht glücklich:

file.cpp: In function 'int main(int, char**)': 
file.cpp:18:11: error: type/value mismatch at argument 2 in template parameter 
list for 'template<long unsigned int N, template<class> class Stack> class Tower' 
file.cpp:18:11: error: expected a template of type 'template<class> class Stack', 
got 'template<class _Tp, class _Sequence> class std::stack' 
file.cpp:18:21: error: invalid type in declaration before ';' token 

Der Standard Stapelbehälter diese Form hat :

template <class Type, class Container = deque<Type> > class stack;

Bedeutung Ich sollte in Ordnung sein, hier nur ein Template-Argument zu übergeben!

Irgendwelche Gedanken, wie man das löst? Danke

Answer 1

'template<class> class Stack', got 'template<class _Tp, class _Sequence> class std::stack' zeigt das Problem.

Hier ist, was std::stack wie

template< 
    class T, 
    class Container = std::deque<T> 
> class stack; 

sieht aus, als Sie es sehen können, ein zweiter Parameter ist.

Hinzufügen:

#include <deque> 
template <std::size_t N, 
     template <class T, class = std::deque<T>> class Stack = std::stack 
     > 

sollte es kompilieren machen.

Answer 2

std::stack hat mehr als ein Template-Argument. Daher kann es in Ihrem Fall nicht verwendet werden. Sie können dies in C++ 11 mit Vorlage Typdefs umgehen.

template <typename T> 
using stack_with_one_type_parameter = std::stack<T>; 

template <std::size_t N, 
    template <class> class Stack = stack_with_one_type_parameter 
    > 
class Tower; 

Answer 3

Danke, das hat schön funktioniert. Hier ist eine Änderung meines Codes, die funktioniert:

#include <stack> 
#include <queue> 
#include <cstddef> 

template <std::size_t N, 
     class T, 
     template <class, class> class Stack = std::stack, 
     class C = std::deque<T> 
     > 
class Tower : protected Stack<T,C> 
{ 
    public: 
     Tower() : Stack<T,C>(N) 
     { 
     } 
}; 


int main(int argc, char **argv) 
{ 
    Tower<5UL, int> tower1(); 
    Tower<5UL, int, std::queue> tower2(); 
    Tower<5UL, int, std::stack, std::deque<int> > tower3(); 
}