ชั้นในสามารถเข้าถึงตัวแปรส่วนตัวได้หรือไม่?

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";

ข้อผิดพลาดนี้เกิดขึ้นเมื่อฉันคอมไพล์กับคลาส Outer :: Inner 'ไม่มีสมาชิกชื่อ `var'

ชั้นในคือเพื่อนของชั้นเรียนที่ถูกกำหนดไว้ภายใน
ใช่; วัตถุของการพิมพ์ที่Outer::Innerสามารถเข้าถึงตัวแปรสมาชิกของวัตถุของการพิมพ์varOuter

แตกต่างจาก Java แม้ว่าจะไม่มีความสัมพันธ์ระหว่างอ็อบเจ็กต์ประเภทOuter::Innerและอ็อบเจ็กต์ของคลาสพาเรนต์ คุณต้องสร้างความสัมพันธ์แม่ลูกด้วยตนเอง

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

คลาสภายในสามารถเข้าถึงสมาชิกทั้งหมดของคลาสภายนอก แต่ไม่มีการอ้างอิงโดยนัยไปยังอินสแตนซ์คลาสพาเรนต์ (ไม่เหมือนกับความแปลกประหลาดบางอย่างกับ Java) ดังนั้นหากคุณส่งการอ้างอิงไปยังคลาสชั้นนอกไปยังคลาสชั้นในก็สามารถอ้างอิงอะไรก็ได้ในอินสแตนซ์คลาสภายนอก

สิ่งใดก็ตามที่เป็นส่วนหนึ่งของ Outer ควรเข้าถึงสมาชิกของ Outer ทั้งหมดไม่ว่าจะเป็นภาครัฐหรือเอกชน

แก้ไข: คอมไพเลอร์ของคุณถูกต้อง var ไม่ใช่สมาชิกของ Inner แต่ถ้าคุณมีข้อมูลอ้างอิงหรือตัวชี้ไปที่อินสแตนซ์ของ Outer ก็สามารถเข้าถึงสิ่งนั้นได้

var ไม่ใช่สมาชิกของชั้นใน

ในการเข้าถึง var ควรใช้ตัวชี้หรือการอ้างอิงไปยังอินสแตนซ์คลาสภายนอก เช่น pOuter-> var จะใช้งานได้ถ้าชั้นในเป็นเพื่อนของชั้นนอกหรือ var เป็นสาธารณะถ้าเป็นไปตามมาตรฐาน C ++ อย่างเคร่งครัด

คอมไพเลอร์บางตัวถือว่าคลาสชั้นในเป็นเหมือนเพื่อนของชั้นนอก แต่บางคนอาจไม่ทำ ดูเอกสารนี้สำหรับคอมไพเลอร์ IBM :

"คลาสที่ซ้อนกันถูกประกาศภายในขอบเขตของคลาสอื่นชื่อของคลาสที่ซ้อนกันเป็นคลาสที่อยู่ภายในของคลาสที่ปิดล้อมเว้นแต่คุณจะใช้พอยน์เตอร์การอ้างอิงหรือชื่ออ็อบเจ็กต์ที่ชัดเจนการประกาศในคลาสที่ซ้อนกันสามารถใช้ได้เฉพาะโครงสร้างที่มองเห็นได้เท่านั้นซึ่งรวมถึง พิมพ์ชื่อสมาชิกแบบคงที่และตัวนับจากคลาสที่ปิดล้อมและตัวแปรส่วนกลาง

ฟังก์ชันสมาชิกของคลาสที่ซ้อนกันเป็นไปตามกฎการเข้าถึงปกติและไม่มีสิทธิ์การเข้าถึงพิเศษสำหรับสมาชิกของคลาสที่ปิดล้อม ฟังก์ชันสมาชิกของคลาสที่ปิดล้อมไม่มีการเข้าถึงพิเศษสำหรับสมาชิกของคลาสที่ซ้อนกัน "

ก่อนอื่นคุณกำลังพยายามเข้าถึงสมาชิกที่ไม่คงที่varนอกคลาสซึ่งไม่ได้รับอนุญาตใน C ++

คำตอบของมาร์คถูกต้อง

สิ่งใดก็ตามที่เป็นส่วนหนึ่งของ Outer ควรเข้าถึงสมาชิกของ Outer ทั้งหมดไม่ว่าจะเป็นภาครัฐหรือเอกชน

ดังนั้นคุณสามารถทำสองสิ่งได้ทั้งประกาศvarเป็นstaticหรือใช้การอ้างอิงของอินสแตนซ์ของคลาสภายนอกเพื่อเข้าถึง 'var' (เนื่องจากคลาสเพื่อนหรือฟังก์ชันต้องการการอ้างอิงเพื่อเข้าถึงข้อมูลส่วนตัวด้วย)

ตัวแปรคงที่

เปลี่ยนvarเป็นstaticถ้าคุณไม่ต้องการvarเชื่อมโยงกับอินสแตนซ์ของคลาส

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

}

เอาต์พุต - var: 1

ตัวแปรไม่คงที่

การอ้างอิงของออบเจ็กต์ต้องเข้าถึงตัวแปรสมาชิกที่ไม่คงที่

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

}

เอาต์พุต - var: 1

แก้ไข - ลิงก์ภายนอกคือลิงก์ไปยังบล็อกของฉัน