我有一个自定义 vector 类，就所有意图和目的而言，它的行为就像 std::vector。我想添加一个简单的 map 功能:

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”来避免对模板参数的需要，但你仍然需要转换所有的 lambda。

我将它转换为 std::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 会这样做(我可以很容易地用调用 std::transform 来替换 map 的主体)，但我的问题确实是以正确的方式指定模板参数。

最佳答案

首先，不要使用std::function针对这类问题。

我先给大家举个例子，再简单说明一下。请注意，我使用了 std::vector存储数据并提供功能，因为我真的不想实现整个 Vector自己上课 ;).

LIVE WORKING CODE

#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>()))部分是有趣的部分。在那，我们基本上问编译器

"What will be the return type of function given an argument value of type T?"

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

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

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

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

   ...

   return result;
}

关于c++ - 在 C++11 中将映射函数添加到 vector ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18886469/