5

我决定尝试使用模板在 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 的定义是可疑的，但它编译得很好，所以我很迷茫。谁能指导我度过这个愚蠢的过程？

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

到目前为止，这是我的想法。

我目前正在使用 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很棒，但不可链接。

4

2 回答 2

4

模板参数永远不能从嵌套类型中推导出来。即使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);
}
于 2012-10-16T18:17:35.420 回答
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将从第一个容器中的值类型转换为第二个容器中的值类型。

于 2012-10-16T18:53:23.213 回答