¿Por qué no es posible usar el método privado en una lambda?

Question

Tener una clase como esta:

class A { 
public: 
    bool hasGrandChild() const; 

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

Por qué no es posible utilizar un método privado hasChild() en una expresión lambda se define en el método hasGrandChild() así?

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

compilador emite un error que el método hasChild() es privado dentro del contexto. ¿Hay algún trabajo alrededor?

Editar: Parece que el código como lo publiqué originalmente funciona. Pensé que es equivalente, pero el código que does not work on GCC es de la misma familia:

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

Parece que hay un problema con los nombres completos como this does not work, pero this works.

Answer 1

Parece ser sólo un error GCC en un caso especial cuando el lambda intenta acceder a un miembro protegido de la clase padre usando el nombre completamente calificado. 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(); 
    }); 
    } 
}; 

, pero this works:

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

Según C++ 11, 5.1.2/3:

El tipo de la lambda-expresión (que es también el tipo del objeto de cierre ) es un tipo de clase no sindicalizado exclusivo y sin nombre, denominado tipo de cierre , cuyas propiedades se describen a continuación. Este tipo de clase no es un agregado (8.5.1). El tipo de cierre se declara en el ámbito de bloque más pequeño , alcance de clase o ámbito de espacio de nombres que contiene la correspondiente expresión lambda.

Y entonces C++ 11, 11,7/1:

una clase anidada es miembro y como tal tiene los mismos derechos de acceso como cualquier otro miembro.

Por lo tanto, la función lambda local de la función debe tener los mismos derechos de acceso que cualquier otro miembro de la clase. Por lo tanto, debería ser capaz de llamar a un método protegido desde una clase principal.

Answer 2

No es posible porque la lambda no es parte de la clase. Es lo mismo que realizar una función fuera de clase y llamarla en lugar de crear una lambda. Por supuesto, no tiene acceso a miembros privados.

Answer 3

El estándar (C++ 11, §5.1.2/3) establece que

El tipo de la lambda-expresión (que también es el tipo del objeto cierre) es un único, tipo de clase no sindical sin nombre - llamado tipo de cierre.

Ya que es un tipo de clase única que no es un friend de A, que no tiene acceso a los miembros privados A 's.

Lo que el compilador hace aquí es crear un tipo de clase que tenga los miembros apropiados para almacenar cualquier variable capturada, un operator() apropiado, que es exactamente lo que escribiría usted mismo si quisiera emular lambdas en C++ 03. Este tipo no tendría acceso a los miembros private, lo que podría hacer que sea más fácil visualizar por qué existe la limitación y por qué no hay una solución .

actualización con respecto a posibles soluciones:

sería mejor decir "no hay soluciones alternativas utilizando un lambda", porque en soluciones generales no existir aunque requieren que renunciar a la sintaxis lambda conveniente. Por ejemplo, usted podría:

1. Escribe una clase local que captura de forma explícita this junto con cualesquiera otros locales que requiere (inspirado por el comentario de Björn Pollex a continuación).
2. Escriba un método private en lugar de un lambda y páselo como devolución de llamada (por ejemplo, usando std::bind para mayor comodidad). Si desea capturar locales además de this, puede usar más std::bind en el sitio de llamadas para hacerlo.

Answer 4

Solución:

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 5

Puede capturar this explícitamente y convertirlo en un "miembro lambda" que tiene acceso a miembros privados.

Por ejemplo, consideremos el siguiente ejemplo:

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