我是一名数学家，长期以来一直在进行“旧式”C++ 编程。我觉得 C++11 提供的一些新语法结构可以帮助我在我的专业项目中获得更好的代码。然而，由于我不是 CS 专业人士，我必须承认我缺乏理解我在自学过程中遇到的一些例子的知识，尽管到目前为止我已经很幸运/成功了。

我的印象是可变参数模板可用于实现类型安全的函数组合，如 this question .我的担心稍微更笼统一些，因为我想用异构(但兼容)的参数/返回类型来组合函数。我用谷歌搜索了很多，发现 another reference ，但对我来说这似乎完全是“黑魔法”；)而且我不会假装我可以在我的上下文中调整代码，尽管我觉得我应该在那里找到我需要的东西。

我认为下面的(最不完整的)代码对于我想要实现的目标是相对不言自明的。特别是，我相信正确的实现会在尝试编写不兼容的函数(此处为箭头)时抛出编译时错误，并且需要一段递归模板代码。

template <typename Source , typename Target> class Arrow
{
  Target eval (const Source &);
};

template <typename ...Arrows> class Compositor
{
  template <typename ...Arrows>
  Compositor (Arrows... arrows)
  {
     // do/call what needs be here
  };

  auto arrow(); // gives a function performing the functionnal composition of arrows

};

// define some classes A, B and C

int main(int argc, char **argv)
{
  Arrow < A , B >  arrow1;
  Arrow < B , C >  arrow2;

  Compositor< Arrow < A , B > , Arrow < B , C > > compositor(arrow1 , arrow2);

  Arrow < A , C >  expected_result = compositor.arrow();
}

理想情况下我会喜欢
Compositor
直接继承
Arrow < source_of_first_arrow , target_of_last_arrow>
和方法
arrow()
被相应的
替换 eval()

但我觉得上面的代码更能说明问题。

任何帮助都将不胜感激，即使它包含一个粗暴的指责，并指向一个现有的(相对基本的)示例，这肯定会逃脱我的搜索。谢谢!

最佳答案

如果我没记错的话，你不需要花哨的模板魔术来完成这个组合。这是几乎不言自明的代码:

#include <functional>
#include <string>
#include <iostream>

// it is just an std::function taking A and returning B
template <typename A, typename B>
using Arrow = std::function<B(const A&)>;

// composition operator: just create a new composed arrow
template <typename A, typename B, typename C>
Arrow<A, C> operator*(const Arrow<A, B>& arr1, const Arrow<B, C>& arr2)
{
    // arr1 and arr2 are copied into the lambda, so we won't lose track of them
    return [arr1, arr2](const A& a) { return arr2(arr1(a)); };
}

int main()
{
    Arrow<int, float> plusHalf([](int i){return i + 0.5;});
    Arrow<float, std::string> toString([](float f){return std::to_string(f);});

    auto composed = plusHalf * toString; // composed is Arrow<int, std::string>
    std::cout << composed(6) << std::endl; // 6.5

    //auto badComposed = toString * plusHalf; // compile time error
}

我在这里主要使用 lambda 函数。

事实证明，使用单个函数调用而不是运算符链是一个更棘手的问题。这次你得到了一些模板:

#include <functional>
#include <string>
#include <iostream>

// it is just an std::function taking A and returning B
template <typename A, typename B>
using Arrow = std::function<B(const A&)>;

// A helper struct as template function can't get partial specialization
template <typename... Funcs>
struct ComposerHelper;

// Base case: a single arrow
template <typename A, typename B>
struct ComposerHelper<Arrow<A, B>>
{
    static Arrow<A, B> compose(const Arrow<A, B>& arr)
    {
        return arr;
    }
};

// Tail case: more arrows
template <typename A, typename B, typename... Tail>
struct ComposerHelper<Arrow<A, B>, Tail...>
{
    // hard to know the exact return type here. Let the compiler figure out
    static auto compose(const Arrow<A, B>& arr, const Tail&... tail)
    -> decltype(arr * ComposerHelper<Tail...>::compose(tail...))
    {
        return arr * ComposerHelper<Tail...>::compose(tail...);
    }
};

// A simple function to call our helper struct
// again, hard to write the return type
template <typename... Funcs>
auto compose(const Funcs&... funcs)
-> decltype(ComposerHelper<Funcs...>::compose(funcs...))
{
    return ComposerHelper<Funcs...>::compose(funcs...);
}

using namespace std;

int main()
{
    Arrow<int, float> plusHalf([](int i){return i + 0.5;});
    Arrow<float, string> toString([](float f){return to_string(f);});
    Arrow<string, int> firstDigit([](const string& s){return s[0]-'0';});

    auto composed = compose(plusHalf, toString, firstDigit);
    // composed is Arrow<int, int>

    std::cout << composed(61) << std::endl; // "6"

    //auto badComposed = compose(toString, plusHalf); // compile time error
}

关于c++ - C++11 中可变参数模板的函数组合，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20829106/