假设我有两个返回期货的函数:
std::future<T> foo(int);
std::future<U> bar(T const &);
我想将这两个函数组合成一个带有intas参数并返回a 的函数std::future<U>.我应该怎么写这个函数？对于返回期货的函数,是否可以推广函数组合？
std::future<U> foobar1(int x)
{
auto foo_x = foo(x);
return bar(foo_x.get());
}
此函数将阻塞,直到返回的未来foo完成,对吧？这显然不是我想要的.
std::future<U> foobar2(int x)
{
return std::async([=]()
{
auto foo_x = foo(x);
return bar(foo_x.get()).get();
});
}
如果只是为了让它变成一个新的未来,那么对于get()回归的未来感到愚蠢barstd::async
std::future<U> foobar3(int x)
{
return foo(x).then([](std::future<T> f)
{
return bar(f.get()).get();
};
}
在这里,我必须再次呼吁get()将来回归,bar否则我会有一个future<future<U>>.这是正确的方法吗？
我有一个类型特征,检查给定类型是否是给定类模板的实例:
template <template <typename...> class C, typename T>
struct check_is_instance_of : std::false_type { };
template <template <typename...> class C, typename ...Ts>
struct check_is_instance_of<C, C<Ts...>> : std::true_type { };
template <template <typename...> class C, typename T>
struct is_instance_of : check_is_instance_of<C, std::remove_cv_t<T>> { };
不幸的是,这不适用于非类型模板参数,因为它们不会被可变参数模板参数"捕获",因此
is_instance_of<std::integral_constant, std::true_type>
产生编译错误.有没有办法编写一个is_instance_of适用于任意数量的类型和非类型模板参数的实现？
我想以下列方式从另一个可变参数函数调用一个可变参数函数:
template <typename ...Ts>
void f(Ts const & ...) { /* ... */ }
template <typename ...Args>
void g(Args const & ...args)
{
// shall call f(arg0.a(), arg0.b(), arg1.a(), arg1.b(), ...)
}
我是通过以下方式完成的:
struct sentinel_t { };
template <typename Arg, typename ...Args>
void g_impl(Arg const & arg, Args const & ...args)
{
g_impl(args..., arg.a(), arg.b());
}
template <typename ...Ts>
void g_impl(sentinel_t , Ts const & ...ts)
{
f(ts...);
}
template <typename ...Args>
void g(Args const & ...args)
{
g_impl(args..., sentinel_t{}); …我希望能够检查元程序中使用的类的不变量。我的第一个天真的方法是
template <int N>
struct digit
{
static_assert((N >= 0) && (N < 10), "bad invariant");
};
using boom = digit<99>;
然而，这编译没有任何问题。只有在构造非法类时才会触发静态断言。
添加额外的模板参数时是可能的：
#include <type_traits>
template <int N,
typename = typename std::enable_if<(N >= 0) && (N < 10)>::type>
struct digit;
using crash = digit<-7>;
当我想将此技术应用于用作类型列表的类时：
#include <type_traits>
template <typename ...> struct are_integral;
template <typename T, typename ...Ts>
struct are_integral<T, Ts...>
{
static const bool value = std::is_integral<T>::value &&
are_integral<Ts...>::value;
};
template <>
struct are_integral<> : std::true_type { };
template <typename …我知道如何编写一个可以在编译时检测给定类T是否具有给定类型的给定名称的成员的类,例如
#include <type_traits>
template <typename T, typename Type, bool = std::is_class<T>::value>
struct has_member_foo
{
private:
template <Type T::*> struct helper;
template <typename U>
static std::false_type test(...);
template <typename U>
static std::true_type test(helper<&U::foo> *);
typedef decltype(test<T>(nullptr)) testresult;
public:
static const bool value = testresult::value;
};
template <typename T, typename Type>
struct has_member_foo<T, Type, false> : std::false_type { };
struct Has_Foo
{
int foo;
};
struct Has_No_Foo
{
int bar;
};
void test()
{
static_assert(has_member_foo<Has_Foo, int>::value == true, ":(");
static_assert(has_member_foo<Has_No_Foo, int>::value == …将
std::is_empty<std::tuple<Args...>>::value
如果每个类型都Args为空,则返回true ？gcc 4.9中的快速测试表明情况确实如此,但标准是否需要？