Частичная специализация шаблона: соответствие по свойствам специализированного параметра шаблона

Question

template <typename X, typename Y> class A { 
    // Use Y::Q, a useful property, not used for specialization. 
}; 
enum Property {P1,P2}; 
template <Property P> class B {}; 
class C {}; 

Есть ли способ определить частичную специализацию A таким образом, что A<C, B<P1> > будет A «s нормальный шаблон, но A<C, B<P2> > будет специализация?

Редактировать в ответ на Marcelo: В частности, специализацию следует выбирать не только с помощью B, но и с любым типом, который обладает определенным свойством, например, что это шаблон, первым аргументом которого является P2.

Цель состоит в том, чтобы использовать Y, чтобы представить приятный интерфейс для A, что позволяет написать что-то вроде A<C, Y<P2,Q> >.

---

Замена параметр Y шаблона с помощью параметра шаблона шаблона был бы хорошо, но есть способ частично специализируется он основан на P тогда?

Намерение было бы написать что-то вроде:

template <typename X, template <Property P> typename Y> class A {}; 
template <typename X> class A<X,template<> Y<P2> > {}; // <-- not valid 

Редактировать в ответ на В силикомарганца: Я сказал, что было бы неплохо сделать Y параметр шаблона шаблон, но на самом деле это поражения цели что я хотел бы сделать, чтобы использовать Y для группировки логически связанных свойств вместе, но по-прежнему специализируемся на A на основе одного из этих под-свойств.

---

Есть ли способ, добавив черты к специализации template <> class B<P2>, а затем с помощью SFINAE в A? Намерение было бы написать что-то вроде:

template <> class B<P2> { 
    typedef int IAmP2; 
}; 

// The following is not valid because it's a simple redefinition. 
template <typename X, typename Y> class A { 
    // Substitution using this template would fail for Y<P1>, and only the 
    // general template would be left for selection. 
    typename Y::IAmP2 skipIfNotP2; 
}; 

Answer 1

Я понятия не имею, что вы имеете в виду. Параметры шаблона шаблона кажутся решением, хотя вы как-то говорите, что они не сработают. Почему бы не сделать это?

template <typename X, typename Y> 
class A { 
}; 

template <typename X, template<typename> class Y, typename P> 
class A< X, Y<P> > { 
    /* property is P */ 
}; 

Для вашего SFINAE вопрос, да, что это тоже возможно

template <typename X, typename Y, typename Sfinae = void> 
class A { 
}; 

template <typename X, typename Y> 
class A< X, Y, typename Y::IAmP2 > { 
    /* Y is the class having a property */ 
}; 

class Sample { 
    typedef void IAmP2; 
}; 

Тем не менее я не уверен, что вы имеете в виду вообще.

Answer 2

Без параметров шаблона шаблон (который я не знал бы использовать в данном контексте), это должно быть довольно просто:

template <> class A<C, B<P2> > { ... }; 

Слишком просто, на самом деле. Мне что-то не хватает, но я не вижу, что.

Answer 3

Это то, что вы хотите? (Испытано с Visual Studio 2005)

enum Property { P1, P2 }; 

template <Property P> class B {}; 
class C {}; 

// Other similar types, for the purpose of testing 
template <Property P> class AnotherB {}; 
class AnotherC {}; 

// Primary template 
template <typename X, template<Property P> class Y, Property P> class A 
{ 
public: 
    A() { ::printf("Primary template\n"); } 
}; 

// Partial specialization for P2 
template <typename X, template<Property P> class Y> class A<X, Y, P2> 
{ 
public: 
    A() { ::printf("Partially specialized template\n"); } 
}; 

int main() 
{ 
    // Trying out some combinations 
    A<C, B, P1> q;    // prints "Primary template" 
    A<C, B, P2> w;    // prints "Partially specialized template" 
    A<AnotherC, B, P1> e;  // prints "Primary template" 
    A<AnotherC, B, P2> r;  // prints "Partially specialized template" 
    A<C, AnotherB, P1> t;  // prints "Primary template" 
    A<C, AnotherB, P2> y;  // prints "Partially specialized template" 
    A<AnotherC, AnotherB, P1> u; // prints "Primary template" 
    A<AnotherC, AnotherB, P2> i; // prints "Partially specialized template" 
} 

Ваша попытка частичной специализации приводит к ошибкам компиляции, потому что вы можете передать только шаблоны для шаблона параметров шаблона. Вы не можете пройти в template <> class B<P2> для параметра шаблона шаблона, потому что это полный тип, а не шаблон.

Для первых двух строк кода в функции main(), C полный тип мы проходим, чтобы A «s типа параметр X. B является шаблон, который мы передаем в 's шаблона параметр Y, и этот шаблон должен принять Property как единственный параметр шаблона.Мы передаем значение Property (либо P1, либо P2) на Anontype параметр P отдельно. Когда мы перейдем к P2 для последнего аргумента шаблона A, компилятор увидит специализацию и будет использовать это - иначе компилятор будет использовать основной шаблон A. Аналогичная картина следует для следующих 6 строк.

Answer 4

Я дам еще один ответ в ответ на ваш комментарий с примером Matrix.

Для вашего Matrix Например, вы можете сделать это:

enum MatrixOrder { ColumnMajor, RowMajor }; 

template<MatrixOrder Order> class Dense {}; 
template<MatrixOrder Order> class Sparse {}; 

template<typename T, template<MatrixOrder> class Storage, MatrixOrder Order> 
class Matrix 
{ 
public: 
    Matrix() { ::printf("Primary\n"); } 
}; 

template<typename T, MatrixOrder Order> 
class Matrix<T, Dense, Order> 
{ 
public: 
    Matrix() { ::printf("Specialized\n"); } 
}; 

int main() 
{ 
    // Trying out some combinations... 
    Matrix<double, Dense, ColumnMajor> a; // Prints "Specialized" 
    Matrix<double, Dense, RowMajor> b;  // Prints "Specialized" 
    Matrix<double, Sparse, ColumnMajor> c; // Prints "Primary" 
    Matrix<double, Sparse, RowMajor> d; // Prints "Primary" 
    Matrix<float, Dense, ColumnMajor> e; // Prints "Specialized" 
    Matrix<float, Dense, RowMajor> f;  // Prints "Specialized" 
    Matrix<float, Sparse, ColumnMajor> g; // Prints "Primary" 
    Matrix<float, Sparse, RowMajor> h;  // Prints "Primary" 
    return 0; 
}; 

Он принимает на аналогичной схеме на мой последний ответ. Теперь все специализированные схемы хранения, взяв на себя Dense. Надеюсь, это поможет, по крайней мере, немного. :-)