相关疑难解决方法(0)

从C++ 14开始,我们可以使用泛型lambdas:

auto generic_lambda = [] (auto param) {};

这基本上意味着它的调用操作符基于标记为auto的参数进行模板化.

问题是如何创建一个可以接受可变参数数量的lambda,类似于可变参数函数模板的工作方式？如果这不可能,最接近的东西可以用同样的方法吗？你会怎么存储它？有可能std::function吗？

我想创建一个类,它接受std :: function并允许处理指定的异常,但我不确定它是否可行.

这是一些伪草案:

//exception types
template<class... Args>
class CustomExceptionHandler
{
public:
    CustomExceptionHandler(std::function<void()> clb): clb_(std::move(clb)){}

    void ExecuteCallback()
    {
        try
        {
            clb_();
        }
        /*catch specified exception types*/
    }

private:
    std::function<void()> clb_;
};

//usage
CustomExceptionHandler<std::out_of_range, std::overflow_error> handler(clb);
handler.ExecuteCallback();

我不知道如何使用可变参数模板来获取异常类型并在以后使用它.可能吗 ？

我猜那个元组可能会有所帮助.

我在Code :: Blocks中准备了一个简单的可变参数模板测试,但是我收到一个错误:

调用'OutputSizes()'没有匹配函数

这是我的源代码:

#include <iostream>
#include <typeinfo>

using namespace std;

template <typename FirstDatatype, typename... DatatypeList>
void OutputSizes()
{
    std::cout << typeid(FirstDatatype).name() << ": " << sizeof(FirstDatatype) << std::endl;
    OutputSizes<DatatypeList...>();
}

int main()
{
    OutputSizes<char, int, long int>();
    return 0;
}

我正在使用GNU GCC -std=C++0x.使用-std=gnu++0x没有区别.

所以,如果我有这样的事情

template<typename... Args >
class tuple_class
{
  public:
  std::tuple<Args...> tup;

/*I left out the other functions */
};

我想重载运算符<<,以便它在类上调用时递归打印元组.

恩.

auto a = tuple_class(1, 2 ,3);
std::cout << a << endl;

希望打印'123'

我见过了元组打印机的其他例子,但我不能在没有麻烦的情况下将它应用到我的班级

我想我应该从这样的成员函数开始

  template<typename... Args>
  friend std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m);

然后是课外的实际功能

template<typename... Args>
std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m)
{
   os << "SOMETHING" << std::endl;
   return os;
}

当我在班上调用<<运算符时,这实际上有效.但我不知道如何让它实际打印元组.

任何帮助,将不胜感激

我已经嵌套了与VS 2015一起使用的部分专用模板代码,直到我发现它不符合标准.我希望它是如此,所以我扭曲了我的代码来克服前一个问题,而且那个问题现在已经发生了变化.

使用可变参数模板和部分特化我想在给定一组固定参数的情况下在编译时填充数组.

我想要达到的目标似乎与这个答案相似,但我没有设法让它发挥作用.

考虑以下程序:

#include <cstdlib>

template <typename T, std::size_t Size>
struct Array;

template <typename T, std::size_t Size, std::size_t Iteration, typename ...Args>
struct ArrayFiller {
    inline
    static void fill(Array<T, Size>& a, const Args&... args) {
        ArrayFiller<T, Size, Iteration, Args...>::fill_recursive(a, args...);
    }

    inline
    static void fill_recursive(Array<T, Size>& a, const T& i, const Args&... args) {
        a.data[Size - Iteration - 1] = i;
        ArrayFiller<T, Size, Iteration - 1>::fill_recursive(a, args...);
    }
};

template <typename T, std::size_t …

这与我之前的帖子有关.我想知道为什么一个尝试的解决方案不起作用.

template <typename... T>             /* A */
size_t num_args ();

template <>
size_t num_args <> ()
{
    return 0;
}

template <typename H, typename... T> /* B */
size_t num_args ()
{
    return 1 + num_args <T...> ();
}

如果我尝试调用,比方说,num_args<int,float>()那么错误是函数调用是不明确的:

• A与T = {int,float}
• B,H = int,T = {float}

我不明白这是多么模糊 - A是声明而B是A声明的函数的定义.对吗？

我试图让这个例子起作用,对我之前的问题的回答似乎声称它永远不会起作用.

如果是这样的话,可变自由函数有什么意义呢？有什么可怎么办呢？