我知道检查类型是否是采用TYPE参数的类模板的实例化很简单,如下所述:如何检查类型是否是给定类模板的实例化?
但是......是否有可能有一个可变参数“is_instantiation_of__ntp<...>”(NTP 代表非类型参数),它可以接受具有任意数量的异构 非类型参数的模板?例如:
template<char*, bool, long, size_t, char>
struct many_hetero_nontype_params_example {};
char HELLO_WORLD[] = "hello world";
using ManyHeteroNontypeParamsEx = many_hetero_nontype_params_example<HELLO_WORLD, false, -16, 777, 'x'>;
并且可以按如下方式使用它:
is_instantiation_of__ntp<char*, bool, long, size_t, char, many_hetero_nontype_params_example, ManyHeteroNontypeParamsEx>::value
我知道这对于非类型参数列表可以很容易地实现,这些参数列表是 1)“同质”(相同类型的值),或 2)少量参数(这样非可变解决方案是实用的)。我什至写了一个测试用例来演示这些特殊情况(使用 gcc 4.7.0 编译),以便更好地了解我在说什么:
namespace test__is_instantiation_of__
{
// is_instantiation_of
template< template<typename...> class Template, typename T >
struct is_instantiation_of : std::false_type {};
template< template<typename...> class Template, typename... Args >
struct is_instantiation_of< Template, Template<Args...> > : std::true_type {};
// is_instantiation_of__homogeneous_nontype_params__
template< typename NTP, template<NTP...> class Template, typename T >
struct is_instantiation_of__homogeneous_nontype_params__ : std::false_type {};
template< typename NTP, template<NTP...> class Template, NTP... Args >
struct is_instantiation_of__homogeneous_nontype_params__< NTP, Template, Template<Args...> > : std::true_type {};
// is_instantiation_of__fixedcount_nontype_params__
template< typename NTP1, typename NTP2, template<NTP1, NTP2> class Template, typename T >
struct is_instantiation_of__fixedcount_nontype_params__ : std::false_type {};
template< typename NTP1, typename NTP2, template<NTP1, NTP2> class Template, NTP1 v1, NTP2 v2 >
struct is_instantiation_of__fixedcount_nontype_params__< NTP1, NTP2, Template, Template<v1, v2> > : std::true_type {};
// type_params_example
template<typename T1, typename T2, typename T3>
struct type_params_example {};
// homogeneous_nontype_params_example
template<bool B1, bool B2, bool B3, bool B4>
struct homogeneous_nontype_params_example {};
// fixedcount_nontype_params_example
template<long L, char C>
struct fixedcount_nontype_params_example {};
using /*.........*/ TypeParamsEx = /*..........*/ type_params_example<std::string, std::tuple<long, void*>, double>;
using HomogenousNontypeParamsEx = homogeneous_nontype_params_example<true, false, true, false>;
using FixedCountNontypeParamsEx = fixedcount_nontype_params_example<777, 'x'>;
void run()
{
using std::cout;
using std::endl;
if ( is_instantiation_of<type_params_example, TypeParamsEx>::value ) {
cout << "[TypeParamsEx] specializes [type_params_example]" << endl;
}
if ( is_instantiation_of<type_params_example, HomogenousNontypeParamsEx>::value ) {
cout << "[HomogenousNontypeParamsEx] specializes [type_params_example]" << endl;
}
if ( is_instantiation_of<type_params_example, FixedCountNontypeParamsEx>::value ) {
cout << "[FixedCountNontypeParamsEx] specializes [type_params_example]" << endl;
}
if ( is_instantiation_of__homogeneous_nontype_params__<bool, homogeneous_nontype_params_example, TypeParamsEx>::value ) {
cout << "[TypeParamsEx] specializes [homogeneous_nontype_params_example]" << endl;
}
if ( is_instantiation_of__homogeneous_nontype_params__<bool, homogeneous_nontype_params_example, HomogenousNontypeParamsEx>::value ) {
cout << "[HomogenousNontypeParamsEx] specializes [homogeneous_nontype_params_example]" << endl;
}
if ( is_instantiation_of__homogeneous_nontype_params__<bool, homogeneous_nontype_params_example, FixedCountNontypeParamsEx>::value ) {
cout << "[FixedCountNontypeParamsEx] specializes [homogeneous_nontype_params_example]" << endl;
}
if ( is_instantiation_of__fixedcount_nontype_params__<long, char, fixedcount_nontype_params_example, TypeParamsEx>::value ) {
cout << "[TypeParamsEx] specializes [fixedcount_nontype_params_example]" << endl;
}
if ( is_instantiation_of__fixedcount_nontype_params__<long, char, fixedcount_nontype_params_example, HomogenousNontypeParamsEx>::value ) {
cout << "[HomogenousNontypeParamsEx] specializes [fixedcount_nontype_params_example]" << endl;
}
if ( is_instantiation_of__fixedcount_nontype_params__<long, char, fixedcount_nontype_params_example, FixedCountNontypeParamsEx>::value ) {
cout << "[FixedCountNontypeParamsEx] specializes [fixedcount_nontype_params_example]" << endl;
}
}
}
正如预期的那样,您得到的输出是:
[TypeParamsEx] specializes [type_params_example]
[HomeogenousNonTypeParamsEx] specializes [homogeneous_nontype_params_example]
[FixedCountNonTypeParamsEx] specializes [fixedcount_nontype_params_example]
问题是这些模板都不适用于 many_hetero_nontype_params_example(上图)。即:一个单一的、可变的“is_instantiation_of__ntp”,它将接受具有任意数量的异构非类型参数的模板。
我认为如果不要求主模板在模板参数列表的末尾有参数包,那么这将很容易实现。或者是否可以使用包装结构/嵌套结构方法。这是我的(失败的)尝试:
namespace test__is_instantiation_of__nontypes__
{
template<char*, bool, long, size_t, char>
struct many_hetero_nontype_params_example {};
char HELLO_WORLD[] = "hello world";
using ManyHeteroNontypeParamsEx = many_hetero_nontype_params_example<HELLO_WORLD, false, -16, 777, 'x'>;
/*
* is_instantiation_of__nontypes_v1__ (version 1)
* if uncommented, syntax error as expected ...
* error: parameter pack 'NTPs' must be at the end of the template parameter list
* error: parameter pack argument 'NTPs ...' must be at the end of the template argument list
*/
//template< typename... NTPs, template<NTPs...> class Template, typename T >
//struct is_instantiation_of__nontypes_v1__ : std::true_type {};
//template< typename... NTPs, template<NTPs...> class Template, NTPs... NonTypeArgs >
//struct is_instantiation_of__nontypes_v1__< NTPs..., Template, Template<NonTypeArgs...> > : std::true_type {};
/*
* is_instantiation_of__nontypes_v2__ (version 2)
* no syntax error (but see instantiation errors below)
*/
template<typename... NTPs>
struct is_instantiation_of__nontypes_v2__
{
template< template<NTPs...> class Template, typename T >
struct impl : std::false_type {};
template< template<NTPs...> class Template, NTPs... NonTypeArgs >
struct impl< Template, Template<NonTypeArgs...> > : std::true_type {};
};
void run()
{
/*
* uncommented since "v1" template has syntax error, but this is how it would be used ...
*/
//if ( is_instantiation_of__nontypes_v1__<char*, bool, long, size_t, char, many_hetero_nontype_params_example, ManyHeteroNontypeParamsEx>::value ) {
// std::cout << "yes" << std::endl;
//}
/*
* "v2" template has no syntax error, but the following attempt to use it results in these errors ...
*
* error: type/value mismatch at argument 1 in template parameter list for 'template<class ... NTPs> template<template<template<NTPs ...<anonymous> > class Template, class T> template<class ... NTPs> template<NTPs ...<anonymous> > class Template, class T> struct is_instantiation_of__nontypes_v2__<NTPs>::impl'
* error: expected a template of type 'template<class ... NTPs> template<NTPs ...<anonymous> > class Template', got 'template<char* <anonymous>, bool <anonymous>, long int <anonymous>, long unsigned int <anonymous>, char <anonymous> > struct many_hetero_nontype_params_example'
*/
//if ( is_instantiation_of__nontypes_v2__<char*, bool, long, size_t, char>::impl<many_hetero_nontype_params_example, ManyHeteroNontypeParamsEx>::value ) {
// std::cout << "yes" << std::endl;
//}
}
}
...
是否有可能为此提供可变参数解决方案?
提前致谢。