C++ 如何让lambda成为班级的朋友？

比如说，我有一门课：

class A {
  int a;
};

我有一个lambda：

auto function = [](A* a) {
  a->a;  // <== gives an error in this line.
};

function(new A);

自动功能=[]（A*A）{
a->a；//为了使lambda成为朋友，您需要与定义lambda的类或函数成为朋友。下面是一个完整的示例：

#include <iostream>
using namespace std;

class A {
  int a;
public:
    A(int _a) : a(_a) {}
    friend int foo(A*); // Declare foo(A*) a friend of A
};

int foo(A* aa) {
    auto function = [](A* a) {
        return a->a;    // Now foo(A*) can access A::a, which is private
    };
    return function(aa);
}

int main() {
    A a(123);
    cout << foo(&a) << endl;
    return 0;
}

#包括
使用名称空间std；
甲级{
INTA；
公众：
A（int_A）：A（_A）{}
friend int foo（A*）；//声明foo（A*）是A的朋友
};
int foo（A*aa）{
自动功能=[]（A*A）{
返回a->a；//现在foo（a*）可以访问a：：a，这是私有的
};
返回函数（aa）；
}
int main（）{
A（123）；
cout为了使lambda成为朋友，您需要与定义lambda的类或函数成为朋友。下面是一个完整的示例：

#include <iostream>
using namespace std;

class A {
  int a;
public:
    A(int _a) : a(_a) {}
    friend int foo(A*); // Declare foo(A*) a friend of A
};

int foo(A* aa) {
    auto function = [](A* a) {
        return a->a;    // Now foo(A*) can access A::a, which is private
    };
    return function(aa);
}

int main() {
    A a(123);
    cout << foo(&a) << endl;
    return 0;
}

#包括
使用名称空间std；
甲级{
INTA；
公众：
A（int_A）：A（_A）{}
friend int foo（A*）；//声明foo（A*）是A的朋友
};
int foo（A*aa）{
自动功能=[]（A*A）{
返回a->a；//现在foo（a*）可以访问a：：a，这是私有的
};
返回函数（aa）；
}
int main（）{
A（123）；
cout您可以通过创建一个返回lambda函数的友元函数来实现。它继承友元访问：

struct A {
  friend std::function<void(A&, int)> f();

  private:
    int i;
    void test() {std::cout << "test: " << i << "\n";}
};

std::function<void(A&, int)> f() {
  return [] (A &a, int i) {a.i = i; a.test(); };
}

int main() {
    A a;
    f()(a, 13);

    return 0;
}

结构A{
friend std:：函数f（）；
私人：
int i；
void test（）{std:：cout您可以通过创建一个返回lambda函数的友元函数来执行此操作。它继承友元访问：

struct A {
  friend std::function<void(A&, int)> f();

  private:
    int i;
    void test() {std::cout << "test: " << i << "\n";}
};

std::function<void(A&, int)> f() {
  return [] (A &a, int i) {a.i = i; a.test(); };
}

int main() {
    A a;
    f()(a, 13);

    return 0;
}

结构A{
friend std:：函数f（）；
私人：
int i；
void test（）{std:：cout使用std:：函数需要额外的资源，因此我建议使用friend/or方法函数访问私有成员（friend函数隐式内联）：


编辑：我个人喜欢std:：function，但别忘了，std:：function总是占用额外的内存资源，并且可能不会内联，因此如果您可以在没有std:：function的情况下实现源代码，请不要使用std:：function。请参阅，
另外，
使用std:：function需要额外的资源，因此我建议使用friend/or method函数访问私有成员（friend函数隐式内联）：


编辑：我个人喜欢std:：function，但别忘了，std:：function总是占用额外的内存资源，并且可能不会内联，因此如果您可以在没有std:：function的情况下实现源代码，请不要使用std:：function。请参阅，
另外，
为什么不直接使用
std:：function
类型？你能给出一个这样的用例吗？lambda有很多可能访问私有成员的方法，但是在不知道用例的情况下，不清楚什么方法是可以接受的。@user2485710
std:：function
类型如何帮助我访问prilambda中的vate成员？@abyss.7：也许你想让你的测试类成为朋友。请注意，如果lambda是在类的范围内定义的，它确实可以访问私有成员。为什么不只使用
std:：function
类型？你能给出一个用例吗？lambda可以通过许多潜在的方式访问o私有成员，但在不知道用例的情况下，不清楚什么方法是可以接受的。@user2485710
std:：function
类型将如何帮助我访问lambdas中的私有成员？@abyss.7:也许你想让你的测试类成为朋友。请注意，如果lambda是在类的范围内定义的，它确实有访问私人会员。我从你的回答中了解到，使用“友好”是没有意义的lambda，是吗？-因为每个lambda定义都应该放在
friend
函数中，因此，我可以使用
friend
函数本身。@深渊。7不太可能：您可以在friend函数或friend类中生成lambda，然后在friend函数/类之外的其他地方使用它们。例如，您可以clare您的
函数
是
a
的朋友的类
B
的公共成员，然后使用
B:：函数
执行需要访问
a
的私人成员的操作。从您的回答中我了解到，使用“友好”没有意义lambda，是吗？-因为每个lambda定义都应该放在
friend
函数中，因此，我可以使用
friend
函数本身。@深渊。7不太可能：您可以在friend函数或friend类中生成lambda，然后在friend函数/类之外的其他地方使用它们。例如，您可以克莱尔你的
函数
是
a
的朋友的类
B
的公共成员，然后使用
B:：function
执行需要访问
a
的私有成员的操作。我会给
f
一个
auto
的返回类型，并延迟类型擦除，直到调用方需要它。那就是l使编译器更容易内联并可能对直接使用返回的闭包对象执行其他优化（例如，使用clang和
-Ofast
执行替换和编译实际上导致对
a:：test
的调用内联到
main
）。
f（）
不返回lambda函数。它返回包含lambda的类型erased
std:：function
。我会给
f
一个返回类型
auto
，并延迟类型擦除，直到调用方需要它。这将使编译器更容易内联并可能在直接使用时执行其他优化返回的闭包对象的s（例如，使用clang和
-Ofast
执行替换和编译实际上导致对
A:：test
的调用内联到
main
）。
f（）
不返回lambda函数。它返回包含lambda函数的类型erased
std:：function
。