Czy klasy wewnętrzne mogą uzyskać dostęp do zmiennych prywatnych?

class Outer {

    class Inner {
    public:
        Inner() {}
        void func() ;
    };

private:
    static const char* const MYCONST;
    int var;
};

void Outer::Inner::func() {
    var = 1;
}

const char* const Outer::MYCONST = "myconst";

Ten błąd pojawia się, gdy kompiluję z klasą Outer :: Inner 'nie ma elementu członkowskiego o nazwie `var'

Klasa wewnętrzna jest przyjacielem klasy, w której jest zdefiniowana.
Więc tak; obiekt typu Outer::Innermoże uzyskać dostęp do zmiennej varskładowej obiektu typu Outer.

Jednak w przeciwieństwie do Javy nie ma korelacji między obiektem typu Outer::Innera obiektem klasy nadrzędnej. Musisz ręcznie utworzyć relację rodzic-dziecko.

#include <string>
#include <iostream>

class Outer
{
    class Inner
    {
        public:
            Inner(Outer& x): parent(x) {}
            void func()
            {
                std::string a = "myconst1";
                std::cout << parent.var << std::endl;

                if (a == MYCONST)
                {   std::cout << "string same" << std::endl;
                }
                else
                {   std::cout << "string not same" << std::endl;
                }
            }
        private:
            Outer&  parent;
    };

    public:
        Outer()
            :i(*this)
            ,var(4)
        {}
        Outer(Outer& other)
            :i(other)
            ,var(22)
        {}
        void func()
        {
            i.func();
        }
    private:
        static const char* const MYCONST;
        Inner i;
        int var;
};

const char* const Outer::MYCONST = "myconst";

int main()
{

    Outer           o1;
    Outer           o2(o1);
    o1.func();
    o2.func();
}

Klasa wewnętrzna ma dostęp do wszystkich członków klasy zewnętrznej, ale nie ma niejawnego odwołania do instancji klasy nadrzędnej (w przeciwieństwie do pewnych dziwactw w Javie). Więc jeśli przekażesz referencję do klasy zewnętrznej do klasy wewnętrznej, może ona odwołać się do czegokolwiek w instancji klasy zewnętrznej.

Wszystko, co jest częścią Outer, powinno mieć dostęp do wszystkich członków Outer, publicznych lub prywatnych.

Edycja: twój kompilator jest poprawny, var nie jest członkiem Inner. Ale jeśli masz odniesienie lub wskaźnik do wystąpienia Outer, może uzyskać do niego dostęp.

var nie jest członkiem klasy wewnętrznej.

Aby uzyskać dostęp do zmiennej, należy użyć wskaźnika lub odwołania do instancji klasy zewnętrznej. Np. pOuter-> var zadziała, jeśli klasa wewnętrzna jest przyjacielem zewnętrznej lub var jest publiczna, jeśli ściśle przestrzega się standardu C ++.

Niektóre kompilatory traktują klasy wewnętrzne jak przyjaciela zewnętrznej, ale niektóre nie. Zobacz ten dokument dla kompilatora IBM :

„Klasa zagnieżdżona jest zadeklarowana w zakresie innej klasy. Nazwa klasy zagnieżdżonej jest lokalna dla klasy otaczającej. O ile nie używasz jawnych wskaźników, odwołań lub nazw obiektów, deklaracje w klasie zagnieżdżonej mogą używać tylko widocznych konstrukcji, w tym nazwy typów, statyczne elementy członkowskie i moduły wyliczające z otaczającej klasy i zmiennych globalnych.

Funkcje składowe klasy zagnieżdżonej są zgodne ze zwykłymi regułami dostępu i nie mają specjalnych uprawnień dostępu do członków klas obejmujących. Funkcje składowe klasy otaczającej nie mają specjalnego dostępu do elementów składowych klasy zagnieżdżonej. "

Przede wszystkim próbujesz uzyskać dostęp do niestatycznego elementu członkowskiego varpoza klasą, co nie jest dozwolone w C ++.

Odpowiedź Marka jest poprawna.

Wszystko, co jest częścią Outer, powinno mieć dostęp do wszystkich członków Outer, publicznych lub prywatnych.

Możesz więc zrobić dwie rzeczy, zadeklarować varjako staticlub użyć odwołania do instancji klasy zewnętrznej, aby uzyskać dostęp do zmiennej (ponieważ zaprzyjaźniona klasa lub funkcja również potrzebuje odwołania, aby uzyskać dostęp do prywatnych danych).

Static var

Zmień varna staticJeśli nie chcesz varbyć powiązany z wystąpieniami klasy.

#include <iostream>

class Outer {

private:
    static const char* const MYCONST;
    static int var;

public:
   class Inner {
    public:
        Inner() {
          Outer::var = 1;
        }
        void func() ;
    };
};

int Outer::var = 0;

void Outer::Inner::func() {
    std::cout << "var: "<< Outer::var;
}

int main() {
  Outer outer;
  Outer::Inner inner;
  inner.func();

}

Wyjście - var: 1

Niestat. Var

Odwołanie do obiektu musi mieć dostęp do wszelkich niestatycznych zmiennych składowych.

#include <iostream>

class Outer {

private:
    static const char* const MYCONST;
    int var;

public:
   class Inner {
    public:
        Inner(Outer &outer) {
          outer.var = 1;
        }
        void func(const Outer &outer) ;
    };
};

void Outer::Inner::func(const Outer &outer) {
    std::cout << "var: "<< outer.var;
}

int main() {
  Outer outer;
  Outer::Inner inner(outer);
  inner.func(outer);

}

Wyjście - var: 1

Edytuj - linki zewnętrzne to linki do mojego bloga.