Как объявить/определить класс с параметрами шаблона шаблона без использования дополнительного параметра шаблона

Question

Рассмотрит следующее использование параметров шаблона шаблона ...

#include <iostream> 

template <typename X> 
class A 
{ 
    X _t; 
public: 
    A(X t) 
     :_t(t) 
    { 
    } 
    X GetValue() 
    { 
     return _t; 
    } 
}; 

template <typename T, template <typename T> class C > 
class B 
{ 
    C<T> _c; 
public: 
    B(T t) 
     :_c(t) 
    { 
    } 
    T GetValue() 
    { 
     return _c.GetValue(); 
    } 
}; 

using namespace std; 

int main() 
{ 
    B<int, A> b(10); 
    cout<<b.GetValue(); 
    return 0; 
} 

Есть ли способ, с помощью которого параметр шаблона T может быть удален? Например, есть ли способ сделать следующую работу?

//Does not compile 
template <template <typename T> class C > 
class B 
{ 
    C _c; 
public: 
    B(T t) 
     :_c(t) 
    { 
    } 
    T GetValue() 
    { 
     return _c.GetValue(); 
    } 
}; 

int main() 
{ 
    B< A<int> > b(10); 
    cout<<b.GetValue(); 
    return 0; 
} 

Answer 1

Я предполагаю, что вы после X, а также A, в своем коде.

Обычная картина иметь

template<typename C> 
struct B 
{ 
    C c; 
}; 

, а затем, внутри классов, имеющих право на замещение:

template<typename X> 
class A 
{ 
    typedef X type_name; 
    X t; 
}; 

Затем вы можете получить доступ к параметру с помощью шаблона C::type_name.

Answer 2

Что случилось с:

template <typename C > 
struct B 
{ 
    C c; 
}; 

int main() 
{ 
    B< A<int> > b; 
    return 0; 
} 

Answer 3

Это не представляется возможным. Обратите внимание, что это распространенное недоразумение: A<int> больше не шаблон шаблона! Так что это не будет соответствовать параметру шаблона шаблона, но должны быть приняты с использованием типа-параметра:

template<typename C> 
struct B { 
    C c; 
}; 

B< A<int> > b; 

Ваш способ использования отдельного параметра в порядке.

Если вы хотите принять A<int> но хотите повторно связать его с другим параметром, вы можете использовать этот шаблон, используемый также стандартными-распределителей:

template<typename T> 
struct A { 
    template<typename U> 
    struct rebind { 
     typedef A<U> type; 
    }; 
}; 

template<typename C> 
struct B { 
    typename C::template rebind<float>::type c; 
}; 

B< A<int> > b; 

Теперь B< A<int> >::c имеет тип A<float>. typename до C:: сообщает компилятору, что ::type в конце является типом, а не статическим не-типом элементом. template после C:: сообщает компилятору, что rebind<float> - это экземпляр шаблона, а не сравнение.

Answer 4

Вы можете вложить параметры. То есть значение параметра может быть параметризовано.

template <typename X> 
struct A 
{ 
    X t; 
}; 

template <typename C> 
struct B 
{ 
    C c; 
}; 

int main() 
{ 
    B< A<int> > b; 
    return 0; 
} 

В этом примере, декларация b в main() создает специализацию A с использованием int в качестве параметра, то он создает специализацию B с использованием A<int> в качестве параметра. Таким образом, по специализации B, C составляет A<int>.