通过模板滥用的函数式 C++

Question

我决定尝试使用模板在 C++ 中编写功能映射实现，这就是我想出的：

template <
    class U, 
    class V, 
    template <class> class T 
>

class T<V> WugMap(
    class T<U>::const_iterator first, 
    class T<U>::const_iterator second, 
    V (U::*method)() const)

{
    class T<V> collection;
    while (first != second)
    {
        collection.insert(collection.end(), ((*(first++)).*method)());
    }
    return collection;
}

现在这一切都很好，花花公子，甚至可以编译。问题是，我不知道如何实际调用它。

尝试天真的方式会产生以下错误：

prog.cpp:42: error: no matching function for call to 
‘WugMap(__gnu_cxx::__normal_iterator<Container*, std::vector<Container, 
std::allocator<Container> > >, __gnu_cxx::__normal_iterator<Container*, 
std::vector<Container, std::allocator<Container> > >, int (Container::*)()const)’

据我所知，所有论点都是正确的。 gcc 根本没有提出任何替代方案，这让我相信我对 WugMap 的定义是可疑的，但它编译得很好，所以我很迷茫。谁能指导我完成这个愚蠢的过程？

如果有人可以提出更好的方法来编写这样的函数，以支持使用包含任何类型对象的任何类型的集合，我会考虑更改它。

Here's my ideone so far.

我目前正在使用 Ideone，它使用的是 C++03，gcc 4.3.4。

附录 1

这在 C++11 中可行吗？有人暗示它是。我知道 C++11 中的模板支持不同数量的参数，所以我也会修改我的要求以适应它。我会花一些精力来写一些东西，但与此同时，我正在寻找以下要求：

• 应该有类似以下的签名：

  C2<V, ...> map(const C1<U, ...>&, V (U::*)(...), ...)
  

  这是获取一些集合 C1，包含 U 类型的元素，通过引用构造一些默认参数，还获取 U 的一些成员函数（返回 V 并获取一些未知类型的参数），然后按顺序获取要传递给成员函数的参数。该函数最终将返回一个 C2 类型的集合，该集合包含类型 V 的元素并使用未知数量的默认参数进行初始化。

• 应该是可链接的：

  vector<int> herp = map(
                     map(
                          set<Class1, myComparator>(),
                     &Class1::getClass2, 2, 3),
                     &Class2::getFoo);
  

• 如果我在使用它时不必有模板参数或任何其他额外的冗长，则可以加分。

std::transform 很棒，但不可链接。

Answer 1

模板参数永远不能从嵌套类型中推导出来。即使U和V可以从成员函数指针中推导出来，你也无法推导出模板类型T。

在ideone 的链接中明确指定模板参数（我在写上面的语句之前没有链接）也不起作用，主要是因为std::vector 的模板参数不仅仅是一个输入T！ std::vector 采用值类型和分配器类型。解决问题变得相当丑陋：

#include <vector>
#include <iostream>

using namespace std;

class Container
{
public:
    Container() {}
    Container(int _i) : i(_i) {}

    int get_i() const {return i;}

    int i;
};

    template <
        class U, 
        class V, 
        template <typename...> class T 
    >

    T<V> WugMap(
        typename T<U>::const_iterator first, 
        typename T<U>::const_iterator second, 
        V (U::*method)() const)
    {
        T<V> collection;
        while (first != second)
        {
            collection.insert(collection.end(), ((*(first++)).*method)());
        }
        return collection;
    }

int main()
{
    vector<Container> containers;
    for (int i = 0; i < 10; ++i) containers.push_back((Container(i)));

    WugMap<Container, int, std::vector>(
        containers.begin(), containers.end(), &Container::get_i);
}

Answer 2

不确定这是否应该是一个答案，但见鬼：

std::vector<std::string> src = f();
std::vector<std::string::size_type> sizes; 
sizes.reserve(src.size());
// Actual transformation:
std::transform( src.begin(), src.end(), std::back_inserter(sizes), 
                [](std::string const& s) { return s.size(); } );

类似的事情可以手动完成，但重新发明轮子真的没有意义。

至于std::transform 的不同之处，它并没有尝试如此紧密地绑定类型，它使用Iter1 作为前两个参数，Iter2 作为第三个参数，Functor 作为第三个参数.没有对接口进行检查以保证Iter1 和Iter2 是相同类型容器的迭代器，或者Functor 将从第一个容器中的值类型转换为第二个容器中的值类型。