c++ - son - La función miembro de Clase anidada no puede acceder a la función de clase adjunta. ¿Por qué?

los polinomios son diferenciables

Question

Por favor vea el código de ejemplo a continuación:

class A
{
private:
    class B
    {
    public:
        foobar();
    };
public:
    foo();
    bar();
};

Dentro de la implementación de clase A y B:

A::foo()
{
    //do something
}

A::bar()
{
    //some code
    foo();
    //more code
}

A::B::foobar()
{
    //some code
    foo(); //<<compiler doesn''t like this
}

El compilador marca la llamada a foo () dentro del método foobar (). Anteriormente, tenía foo () como función miembro privada de la clase A, pero cambié a público asumiendo que la función de B no puede verla. Por supuesto, no ayudó. Estoy tratando de reutilizar la funcionalidad proporcionada por el método de A. ¿Por qué el compilador no permite esta función de llamada? Como yo lo veo, son parte de la misma clase adjunta (A). Pensé que el problema de accesibilidad para los miembros de clase anidados para incluir la clase en los estándares de C ++ se resolvió.

¿Cómo puedo lograr lo que estoy tratando de hacer sin volver a escribir el mismo método (foo ()) para B, que mantiene a B anidada dentro de A?

Estoy usando el compilador VC ++ ver-9 (Visual Studio 2008). Gracias por tu ayuda.

Answer 1

Básicamente lo que dijo Georg Fritzsche

#include <iostream>
#include <cstring>
using namespace std;

class A
{
private:
    class B
    {
     A& parent_;
     public:
        //B();  //uncommenting gives error
        ~B();
        B(A& parent) : parent_(parent) {}

        void foobar() 
        { 
         parent_.foo();  
         cout << "A::B::foo()" <<endl; 
        }

        const std::string& foobarstring(const std::string& test) const 
        { 
         parent_.foostring(test); cout << "A::B::foostring()" <<endl;
        }
    };
public:
    void foo();
    void bar();
    const std::string& foostring(const std::string& test) const;
    A(); 
    ~A(){};
    B b_;
};

//A::B::B() {}; //uncommenting gives error
A::B::~B(){};

A::A():b_(*this) {}


void A::foo()
{
    cout << "A::foo()" <<endl;
}

const std::string& A::foostring(const std::string& test) const
{
    cout << test <<endl;
    return test;
}

void A::bar()
{
    //some code
    cout << "A::bar()" <<endl;
    foo();
    //more code
}

int main(int argc, char* argv[])
{
A a;
a.b_.foobar();
a.b_.foobarstring("hello");

return 0;
}

Si elimina el comentario del constructor B predeterminado, obtendría un error

Answer 2

Este es un truco automágico, aunque posiblemente no transportable (aunque funcionó en VC ++ desde 6.0). La clase B tiene que ser miembro de la clase A para que esto funcione.

#ifndef OUTERCLASS
#define OUTERCLASS(className, memberName) /
    reinterpret_cast<className*>(reinterpret_cast<unsigned char*>(this) - offsetof(className, memberName))
#endif 

class A
{
private:
    class B
    {
    public:
        void foobar() {
           A* pA = OUTERCLASS(A, m_classB);
           pA->foo();
        }
    } m_classB;
public:
    foo();
    bar();
};

Answer 3

Si desea reutilizar la funcionalidad de A, debe heredar de A y no anidar B en su interior.

Answer 4

foo() es una función miembro no estática de A y está intentando llamarlo sin una instancia.
La clase anidada B es una clase separada que solo tiene algunos privilegios de acceso y no tiene ningún conocimiento especial sobre las instancias existentes de A

Si B necesita acceder a una A , debe darle una referencia, por ejemplo:

class A {
    class B {
        A& parent_;
    public:
        B(A& parent) : parent_(parent) {}
        void foobar() { parent_.foo(); }
    };
    B b_;
public:
    A() : b_(*this) {}
};