为什么不能在 lambda 中使用私有方法？

Question

有这样的课程：

class A {
public:
    bool hasGrandChild() const;

private:
    bool hasChild() const;
    vector<A> children_;
};

为什么不能像这样在方法hasGrandChild()中定义的lambda表达式中使用私有方法hasChild()？

bool A::hasGrandChild() const {
    return any_of(children_.begin(), children_.end(), [](A const &a) {
        return a.hasChild();
    });
}

编译器发出一个错误，指出方法hasChild() 在上下文中是私有的。有什么解决办法吗？

编辑： 看来我发布的代码最初是有效的。我以为是等价的，但是does not work on GCC的代码更像这样：

#include <vector>
#include <algorithm>

class Foo;

class BaseA {
protected:
    bool hasChild() const { return !children_.empty(); }
    std::vector<Foo> children_;
};

class BaseB {
protected:
    bool hasChild() const { return false; }
};

class Foo : public BaseA, public BaseB {
public:
  bool hasGrandChild() const {
    return std::any_of(children_.begin(), children_.end(), [](Foo const &foo) {
        return foo.BaseA::hasChild();
      });
  }  
};

int main()
{
  Foo foo;
  foo.hasGrandChild();
  return 0;
}

似乎this does not work 的完全限定名称存在问题，但this works。

Answer 1

当 lambda 尝试使用完全限定名从父类访问受保护成员时，这似乎只是一个 GCC 错误。 This does not work:

class Base {
protected:
    bool hasChild() const { return !childs_.empty(); }
    std::vector<Foo> childs_;
};

class Foo : public Base {
public:
  bool hasGrandChild() const {
    return std::any_of(childs_.begin(), childs_.end(), [](Foo const &foo) {
      return foo.Base::hasChild();
    });
  }  
};

，但是this works：

class Foo : public Base {
public:
  bool hasGrandChild() const {
    return std::any_of(childs_.begin(), childs_.end(), [](Foo const &foo) {
      return foo.hasChild();
    });
  }  
};

根据 C++11, 5.1.2/3：

lambda 表达式的类型（也是 闭包对象）是一个唯一的、未命名的非联合类类型——称为 闭包类型——其属性如下所述。此类类型 不是一个集合（8.5.1）。 闭包类型在 包含的最小块作用域、类作用域或命名空间作用域 对应的 lambda 表达式。

然后是 C++11、11.7/1：

嵌套类是一个成员，因此具有相同的访问权限 任何其他成员。

所以提到的函数局部 lambda 应该与类的任何其他成员具有相同的访问权限。因此它应该能够从父类调用受保护的方法。

Answer 2

标准（C++11，§5.1.2/3）声明

lambda 表达式的类型（也是 闭包对象）是一个唯一的、未命名的非联合类类型——称为 闭包类型。

由于它是一个独特的类类型，它不是A 的friend，它无权访问A 的私有成员。

编译器在这里所​​做的是创建一个类类型，该类类型具有适当的成员来存储任何捕获的变量、适当的operator() 等——如果你想在 C++03 中模拟 lambda，这正是你自己编写的.这种类型肯定无法访问private 成员，这可能更容易理解为什么存在限制以及为什么没有解决方法。

更新关于可能的解决方法：

最好说“没有使用 lambda 的变通方法”，因为通常变通方法确实存在，尽管它们要求您放弃方便的 lambda 语法。例如，您可以：

1. 编写一个本地类类型，显式捕获this 以及它需要的任何其他本地变量（受以下 Björn Pollex 评论的启发）。
2. 编写 private 方法而不是 lambda 并将其作为回调传递（例如，为方便起见，使用 std::bind）。如果您想捕获除this 之外的本地人，您可以在呼叫站点使用更多std::bind 来执行此操作。

Answer 3

解决方法：

typedef  bool (A::*MemFn)(void) const;

bool A::hasGrandChild() const {
    MemFn f = &A::hasChild;
    return any_of(childs_.begin(), childs_.end(), [=](A const &a) {
            return (a.*f)();
    });
}

Answer 4

您可以显式捕获this 并使其成为可以访问私有成员的“成员 lambda”。

例如，考虑以下示例：

#include <iostream>
class A {
private:
    void f() { std::cout << "Private"; }
public:
    void g() { 
        [this] { 
            f(); 
            // doesn't need qualification 
        }(); 
    }
};
class B {
private:
    void f() { std::cout << "Private"; }
public:
    void g() { [] { f(); }(); } // compiler error
};
int main() {
    A a;
    a.g();
}

Answer 5

这是不可能的，因为 lambda 不是类的一部分。这与创建类外函数并调用它而不是创建 lambda 相同。当然它不能访问私有成员。