C++ 将映射函数添加到C++；11

我有一个定制的vector类，无论出于何种目的，它的行为都与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;
    }
    ...
}

---

我意识到

std:：transform

可以做到这一点（我可以很容易地用调用

std:：transform

来替换映射体），但我的问题实际上是指定模板参数的正确方法。

首先，对于此类问题，不要使用

std:：function

---

我先给你们举个例子，我会给你们一个简单的解释。注意，我使用了一个

std:：vector

来存储数据并提供功能，因为我真的不想自己实现整个

vector

类；）

---

除了lambda之外，尝试传递一个自定义的functor，该functor在类中定义了“result\u type”类型…..

decltype（function（declval（））

来代替

mapFunction:：result\u type

，也许？标准库中已经有一个具有相同功能的自由函数：

std:：transform（source.begin（），source.end（）），std:：back\u插入器（目标），my\u函数）代码> >长度>代码>代码>数据> /COD>是C++中保留的标识符。1的时间用来提供解决方案，同时绘制所有ASCII艺术图，将各部分链接在一起！我很好奇为什么您提到不使用std:：function来解决这些类型的问题。
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; }));

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;
}

#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;
    }
}

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

   ...

   return result;
}