Question

我需要在＆＃34; normal＆＃34;中进行这些功能。句法。我该如何改变呢？

template <template <class, class> class Container>
        typename const Container<Course*, std::allocator<Course*> >  Schedule<Container>::getAllCourses( ) const
        {
            Container<Course*, std::allocator<Course*> > newone;
            std::for_each(courses.begin(), courses.end(), [&newone](Course *c)
            {Course* nc = new Course(c->getName(),c->getNumber(), c->getFaculty()); newone.push_back(nc);});
            //make a container and push into it every course
            return newone;
        }

实际上，我需要更改功能＆＃34; for_each＆＃34;它将使用外面的课程。我不知道该怎么做。你能帮忙吗？

Answer 1

lambda函数是闭包类型，实现为未命名的仿函数。

您可以查看这些关键字，了解如何执行＆＃34;转换＆＃34;。相当规则就是这个lambda：

[capture_clause](args) -> return_type { /* lambda_body */ }

实际上（在简化视图中 - 这里未明确显示的通用lambdas或value / ref捕获）

struct no_name
{
    no_name(capture_clause) : /* Initialize the closure */ { }
    return_type operator()(args) { /* lambda_body */ }
};

在您的情况下，您必须创建类似以下的类：

template <template <class, class> class Container>
struct lamda_fun
{
    Container<Course*, std::allocator<Course*> > &newone;

    lamda_fun(Container<Course*, std::allocator<Course*> > &newone)
        : newone(newone) {
    }
    void operator()(Course *c) {
        Course* nc = new Course(c->getName(),c->getNumber(), c->getFaculty());     
        newone.push_back(nc);
    }
};

如果您仍想摆脱lambda语法，请将其称为

std::for_each(courses.begin(), courses.end(), lamda_fun<Container>(newone));

即使将仿函数的副本传递给for_each，仿函数也会包含一个引用，以便完成正确的操作。

更简单的方法是使用for循环（是的，仍然存在）

// range based version
for (auto c : courses) {
    Course* nc = new Course(c->getName(), c->getNumber(), c->getFaculty());     
    newone.push_back(nc);
}

// traditional version
for (auto it = courses.begin(), ite = courses.end(); it != ite; ++it) 
{
    auto c = *it;
    Course* nc = new Course(c->getName(), c->getNumber(), c->getFaculty());     
    newone.push_back(nc);
}

Answer 2

您可以将lambda替换为本地类：

#include <algorithm>
#include <iostream>
#include <vector>

template <class Container>
Container transform(const Container& container) {

    struct Lambda {
        Container& result;
        Lambda(Container& result) : result(result) {}
        void operator () (const typename Container::value_type& value) {
            result.push_back(value + 1);
        }
    };

    Container result;
    std::for_each(container.begin(), container.end(), Lambda(result));
    return result;
}

int main() {
    std::vector<int> u;
    u.push_back(0);
    u.push_back(1);
    u.push_back(2);
    std::vector<int> v = transform(u);
    std::cout << v[0] << v[1] << v[2] << '\n';
}

如何摆脱lambda语法

2 个答案: