使用lambda的python map函数的等价物

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了使用lambda的python map函数的等价物相关的知识,希望对你有一定的参考价值。

我想知道是否有可能使用自动返回类型推导功能编写Python函数map的C ++等价物。我的想法是这样的:

vector<int> input({1,2,3});
auto output=apply(input,[](int num){return num*num;});

//output should be a vector {1,4,9}

我知道std::transform,但在目前的情况下,编写一个范围循环似乎更容易。

答案

这当然可以完成,可能看起来像这样:

template <class Container, class Function>
auto apply (const Container &cont, Function fun) {
    std::vector< typename
            std::result_of<Function(const typename Container::value_type&)>::type> ret;
    ret.reserve(cont.size());
    for (const auto &v : cont) {
        ret.push_back(fun(v));
    }
    return ret;
}

如果你想成为超级通用并处理C数组和所有内容,你可能需要为特殊情况添加几个重载。

Live example

另一答案

Baum mit Augen的答案大多数都在那里。只需要几个步骤来支持每个人都可以做的事情:

template <typename C, typename F>
auto apply(C&& container, F&& func)
{
    using std::begin;
    using std::end;

    using E = std::decay_t<decltype(std::forward<F>(func)(
        *begin(std::forward<C>(container))))>;

    std::vector<E> result;
    auto first = begin(std::forward<C>(container));
    auto last = end(std::forward<C>(container));

    result.reserve(std::distance(first, last));
    for (; first != last; ++first) {
        result.push_back(std::forward<F>(func)(*first));
    }
    return result;
}

我们甚至可以更进一步,通过不使用C ++ 14 auto演绎使这个SFINAE成为能够,而是将故障转移到演绎阶段。从begin / end的助手开始:

namespace adl_helper {
    using std::begin;
    using std::end;

    template <typename C>
    auto adl_begin(C&& c) -> decltype(begin(std::forward<C>(c))) {
        return begin(std::forward<C>(c));
    }

    template <typename C>
    auto adl_end(C&& c) -> decltype(end(std::forward<C>(c))) {
        return end(std::forward<C>(c));
    }    
}

using adl_helper::adl_begin;
using adl_helper::adl_end;

然后使用它来推断E更早:

using adl_helper::adl_begin;
using adl_helper::adl_end;

template <typename C,
          typename F,
          typename E = std::decay_t<decltype(std::declval<F>()(
              *adl_begin(std::declval<C>())
              ))>
           >
std::vector<E> apply(C&& container, F&& func)
{
    /* mostly same as before, except using adl_begin/end instead
       of unqualified begin/end with using
    */
}

现在我们可以在编译时测试一些容器/函数对是否是apply-able,错误是一个演绎失败而不是一个使用失败:

int arr[] = {1, 2, 3};
auto x = apply(arr, []{ return 'A'; });

main.cpp: In function 'int main()':
main.cpp:45:52: error: no matching function for call to 'apply(int [3], main()::<lambda()>)'
    auto x = apply(arr, []() -> char { return 'A'; });
                                                    ^
main.cpp:29:16: note: candidate: template<class C, class F, class E> std::vector<E> apply(C&&, F&&)
 std::vector<E> apply(C&& container, F&& func)
                ^
main.cpp:29:16: note:   template argument deduction/substitution failed:
main.cpp:25:50: error: no match for call to '(main()::<lambda()>) (int&)'
           typename E = decltype(std::declval<F>()(
                                                  ^

正如所指出的,这不会很好地处理输入迭代器的容器。所以让我们解决它。我们需要一些东西来确定容器的大小。如果容器具有size()成员函数,我们可以使用它。否则,如果迭代器没有类别input_iterator_tag(不知道任何其他方式来区分输入迭代器......),我们可以使用它。否则,我们有点不走运。像这样做降序排序的好方法是引入chooser层次结构:

namespace details {
    template <int I> struct chooser : chooser<I-1> { };
    template <> struct chooser<0> { };
}

然后走下去:

namespace details {
    template <typename C>
    auto size(C& container, chooser<2>) -> decltype(container.size(), void())
    {
        return container.size();
    }

    template <typename C,
              typename It = decltype(adl_begin(std::declval<C&>()))
              >
    auto size(C& container, chooser<1>) 
    -> std::enable_if_t<
        !std::is_same<std::input_iterator_tag,
            typename std::iterator_traits<It>::iterator_category
        >::value,
        size_t>
    {
        return std::distance(adl_begin(container), adl_end(container));
    }

    template <typename C>
    size_t size(C& container, chooser<0>)
    {
        return 1; // well, we have no idea
    }
}

template <typename C>
size_t size(C& container)
{
    return size(container, details::chooser<10>{});
}

然后我们可以尽我们最大的能力使用size()reserve()我们的向量:

template <typename C,
          typename F,
          typename E = std::decay_t<decltype(std::declval<F>()(
              *adl_begin(std::declval<C>())
              ))>
           >
std::vector<E> apply(C&& container, F&& func)
{
    std::vector<E> result;
    result.reserve(size(container));

    for (auto&& elem : container) {
        result.push_back(std::forward<F>(func)(std::forward<decltype(elem)>(elem)));
    }
    return result;
}
另一答案

这适用于您的示例以及大多数容器。我使用std :: transform,因为它可以针对每个stl迭代器进行优化。我从Baum mit Augen的回答开始,后来被删除了。

template<typename Container, typename Function>
using _mapT = std::vector<typename std::result_of<Function(const typename Container::value_type&)>::type>;

template <typename Container, typename Function>
_mapT<Container, Function> map(const Container &container, Function &&f)
{
    _mapT<Container, Function> ret; ret.reserve(container.size());
    std::transform(container.begin(), container.end(), std::back_inserter(ret), std::forward<Function>(f));
    return ret;
}

以上是关于使用lambda的python map函数的等价物的主要内容,如果未能解决你的问题,请参考以下文章

Python lambda

等效于 Java 中的 Python 的 lambda 函数?

Python中map与lambda的使用

map()函数 lambda函数 zip()函数的使用

Python-lambda函数,map函数,filter函数

python zip,lambda,map函数