Geschachtelte Klasse member-Funktion nicht zugreifen können, die Funktion der umschließenden Klasse. Warum?

Siehe Beispiel-code unten:

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

Innerhalb Klasse A & B Umsetzung:

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

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

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

Den compiler-flags der Aufruf von foo() in der Methode foobar(). Früher hatte ich foo() als private-member-Funktion der Klasse A, aber geändert, um der öffentlichkeit unter der Annahme, dass B die Funktion kann es nicht sehen. Natürlich, es hat nicht geholfen. Ich bin versucht zu re-verwenden Sie die Funktionen Einer Methode. Warum macht das nicht der compiler diese Funktion aufrufen? Wie ich es sehe, Sie sind Teil der gleichen umgebenden Klasse (A). Ich dachte, das Thema Barrierefreiheit für geschachtelte Klasse meebers für umschließenden Klasse in C++ - standards gelöst wurde.

Wie kann ich erreichen, was ich versuche zu tun, ohne das neu-schreiben der gleichen Methode (foo()) für B, die halten B verschachtelt ist?

Bin ich mit VC++ compiler ver-9 (Visual Studio 2008). Danke für Eure Hilfe.

InformationsquelleAutor der Frage Rahul | 2010-06-17

  1. 18

    foo() ist eine nicht-statische member-Funktion von A und Sie versuchen, es zu nennen, ohne eine Instanz.

    Die geschachtelte Klasse B ist eine separate Klasse, die nur einige Zugriffsrechte und muss keine speziellen Kenntnisse über die vorhandenen Instanzen von A.

    Wenn B benötigt Zugriff auf eine A müssen Sie ihm eine Referenz, z.B.:

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

    InformationsquelleAutor der Antwort Georg Fritzsche

  2. 1

    Dies ist ein automagic, wenn auch eventuell nonportable trick (funktioniert auf VC++ seit 6.0). Klasse B ein Mitglied der Klasse A für diese zu arbeiten.

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

    InformationsquelleAutor der Antwort Igor Zevaka

  3. 0

    Wenn Sie wollen, um die Wiederverwendung von Funktionalität aus, dann sollten Sie Erben von Einer nicht-nest-B drin.

    InformationsquelleAutor der Antwort Gary

  4. 0

    Im Grunde das, was Georg Fritzsche sagte

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

    Wenn Sie kommentieren Sie die Standard-B-Konstruktor würden Sie eine Fehlermeldung erhalten,

    InformationsquelleAutor der Antwort enthusiasticgeek

Schreibe einen Kommentar