相关疑难解决方法(0)

我整个早上都遇到过这个问题而没有任何结果.基本上,我需要一个简单的元编程事物,如果传递的参数是一种std :: vector,我可以分支到不同的特化.

某种类型的is_base_of用于模板.

这样的事情存在吗 ？

我怎么static_assert样这个？如果没有C++或C++ 11中的新功能,Boost可能会支持它吗？

template<T>
struct foo {};

template<FooType>
struct bar {
  static_assert(FooType is indeed foo<T> for some T,"failure"); //how?
};

目前我有两个功能:

template<typename Type> bool f(Type* x);
template<typename... List> bool f(std::tuple<List...>* x);

有没有办法将这两个函数与一个额外的模板参数合并,该参数指示传递的类型是否为元组？

template<typename Type, bool IsTuple = /* SOMETHING */> bool f(Type* x);

我正在尝试创建一个具有传递给它的所有类型的元组的类.我希望它将类型列表作为模板参数,并使用该列表中的类作为内部元组将包含的类.目前,我有类似的东西,实际上并没有编译.

template<class ... T>
struct ComponentList {};

template<ComponentList<typename ...T> >
class ComponentManager{
    std::tuple<T...> components;
};

我想ComponentList成为自己的类型的原因是因为我想稍后传入其他类型列表.这可能吗？如果没有,那会有什么替代方案呢？

我正在玩这里提到的lambda"overloading" ,很快就发现我可以很方便地创建专门的lambda闭包.所以我最初是试错了,我最有希望的试验是

auto call_for_vector = [] template<typename T> (std::vector<T>) {};

然而,稍后对cppreference的看法表明,标准似乎不允许使用这种结构或类似结构.

为什么不支持此类专业化的原因是什么？

我知道可以使用SFINAE获得这种行为,但是它的可读性更低,更难写,更容易出错.当然也可以用适当的方式编写一个类operator(),但这是洙C++ 03 :-)

这种语法会有什么用处？:

一个例子,这将允许像下面的代码中那样容易的lambda"重载"

template <class F1, class F2>
struct overload_set : F1, F2
{
    overload_set(F1 x1, F2 x2) : F1(x1), F2(x2) {}
    using F1::operator();
    using F2::operator();
};

template <class F1, class F2>
overload_set<F1,F2> overload(F1 x1, F2 x2)
{
    return overload_set<F1,F2>(x1,x2);
} 

auto f = overload(
         [](auto&& x){ std::cout<<"call by default"<<std::endl;},
         [] template<typename T>(std::vector<T>){std::cout<<"call for vector"<<std::endl;}
         );

人们可以获得这种行为,例如通过使用SFINAE基于该答案中的技术,但是再次......这很糟糕.

SFINAE是否有一个简单的解决方法来获得特定的过载？

template<typename T>
struct check
{
  static const bool value = false;
};

我想要做的是有check<T>::value真当且仅当T是一个std::map<A,B>或std::unordered_map<A,B>两者A并B有std::string.所以基本上check可以启用类型的编译时检查T.我该怎么做呢？

我知道检查类型是否是采用TYPE参数的类模板的实例化是很简单的,如下所述:如何检查类型是否是给定类模板的实例化？

但是......是否有可能有一个可变的"is_instantiation_of__ntp <...>"(NTP代表非类型参数),它将接受具有任意数量的异构 NON-TYPE参数的模板？例如:

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

我知道这可以很容易地实现NON-TYPE参数列表,这些参数列表是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, …

在C++中看到许多元编程的例子,它们可以找出类的属性(例如知道类型是否是模板的特化),或者知道类是否包含给定的嵌套类型; 但我想知道是否有可能编写一个测试或特征来确定最后一个的倒数 - 检查一个给定Type是否嵌套在一个class或struct.

换句话说,我正在寻找以下伪代码的等价物:

template <typename Type> struct is_nested {
    enum { value = {__some magic__} };
};

typedef int type1;
struct Something { typedef int internal_type; };
typedef Something::internal_type type2;

//...later, likely at a different scope

is_nested< int >::value; // yields false
is_nested< std::vector<int>::iterator >::value; // yields true
is_nested< type1 >::value; // yields false
is_nested< type2 >::value; // yields true

我知道我可以sizeof用来实现是/否测试,我认为Type是那些测试的一部分,但我无法弄清楚如何在测试中插入某种"任何可行的类型",这样我就可以形成一个表达式喜欢Anytype::Type.

template 
struct is_nested …