4

我有一个自定义矢量类，它的所有意图和目的就像 std::vector 一样。我想添加一个简单的地图功能：

template <class T> class Vector
{
public:
    template<class mapFunction> Vector<typename mapFunction::result_type> map(mapFunction function)
    {
        Vector<mapFunction::result_type> result(_Length);
        for(UINT i = 0; i < _Length; i++)
        {
           result[i] = function(_Data[i]);
        }
        return result;
    }
    ...
}

用法：

Vector<int> v(5);
for(int i = 0; i < 5; i++) v[i] = i;
auto mappedVector = v.map(function<double(int)>([](int a) { return a * 2.0; }));

这可行，但我试图避免将 lambda 表达式转换为std::function. 理想情况下，v.map([](int a) { return a * 2.0; })); 我意识到我可能会编写一个类似于“make_pair”的“make_function”来避免需要模板参数，但你仍然需要转换所有的 lambdas。

我将它转换为 astd::function因为我不知道如何从原始 lambda 类型中提取返回类型；因此我使用std::function::result_type.

我认为以下方法会起作用，但它不起作用——编译器只是抱怨它无法推断出“returnType”的模板参数：

template<class mapFunction, class returnType> Vector<returnType> Map2(mapFunction function)
{
    Vector<returnType> result(_Length);
    for(UINT i = 0; i < _Length; i++)
    {
        result[i] = function(_Data[i]);
    }
    return result;
}

我意识到这样std::transform做（我可以很容易地用调用替换 map 的主体std::transform），但我的问题实际上在于指定模板参数的正确方法。

4

1 回答 1

11

首先，不要std::function用于这类问题。

我先给大家举个例子，然后做个简单的解释。请注意，我使用 anstd::vector来存储数据并提供功能，因为我真的不想自己实现整个Vector类；）。

实时工作代码

#include <iostream>
#include <vector>

//                /---------------------------------------------------------\
//                |                                                    //   |
template<typename T>                                                   //   |
class Vector {                                                         //   |
public:                                                                //   |
    std::vector<T> data;                                               //   |
                                                                       //   |
    template<class mapFunction>                                        //   |
    // Below: use C++11 trailing return type                                |
    auto map(mapFunction function) -> Vector<decltype(function(std::declval<T>()))>
    //                                       |                                   |
    {   //                                   |                                   |
        //                                   \-----------------------------------/
        //                                          |
        //                                          |
        //                 /-----------------------------------\
        //                 |                                   |
        using ReturnType = decltype(function(std::declval<T>()));

        Vector<ReturnType> result;

        auto size = data.size(); 
        result.data.reserve(size);

        for(std::size_t i = 0; i < size; i++)
        {
           result.data.push_back(function(data[i]));
        }

        return result;
    }
};

int main() {
    Vector<int> v;
    for(int i = 0; i < 10; ++i) {
        v.data.push_back(i);
    }

    auto newV = v.map([](int i) -> float {
        return (i * 2.0f) + 0.5f;       // Multiply by 2 and add 0.5
    });

    for(auto e : newV.data) {
        std::cout << e << std::endl;
    }
}

首先，它使用 C++11 的尾随返回类型特性。之所以需要这样做，是因为我们需要引用参数function。这decltype(function(std::declval<T>()))部分是有趣的部分。在那，我们基本上问编译器

“function给定类型的参数值的返回类型是T什么？”

然后编译器给出返回类型，这就是我们给结果的第一个参数的类型Vector。

后面的部分与你的本质相同，尽管我为了正确和优雅而修改了它们。

请注意，在 C++14 中，您可以删除尾随返回类型，然后执行

template<class mapFunction>
auto map(mapFunction function) {
   using ReturnType = decltype(function(std::declval<T>()));
   Vector<ReturnType> result;

   ...

   return result;
}
于 2013-09-19T05:21:30.680 回答