134 
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' 的成员

4

5 回答 5

142

内部类是定义它的类的朋友。
所以，是的；类型对象可以访问类型对象Outer::Inner的成员变量。varOuter

Outer::Inner但与 Java 不同的是，类型对象和父类对象之间没有关联。您必须手动建立父子关系。

#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();
}
于 2009-01-28T01:33:02.867 回答
35

内部类可以访问外部类的所有成员，但它没有对父类实例的隐式引用（与 Java 的一些奇怪之处不同）。因此，如果您将对外部类的引用传递给内部类，它可以引用外部类实例中的任何内容。

于 2009-01-28T01:34:12.723 回答
6

任何属于 Outer一部分的东西都应该可以访问 Outer 的所有成员，无论是公共的还是私人的。

编辑：你的编译器是正确的，var 不是 Inner 的成员。但是如果你有一个指向 Outer 实例的引用或指针，它就可以访问它。

于 2009-01-28T01:18:41.257 回答
3

首先，您试图访问varC++ 中不允许的类之外的非静态成员。

马克的回答是正确的。

任何属于 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();

}

输出变量：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);

}

输出变量：1

编辑 - 外部链接是指向我的博客的链接。

于 2019-10-10T04:12:12.023 回答
2

var 不是内部类的成员。

要访问 var，应使用指向外部类实例的指针或引用。例如，如果内部类是外部类的朋友，则 pOuter->var 将起作用，或者，如果严格遵循 C++ 标准，则 var 是公共的。

一些编译器将内部类视为外部类的朋友，但有些可能不会。有关IBM 编译器，请参阅此文档：

“嵌套类在另一个类的范围内声明。嵌套类的名称对其封闭类是本地的。除非您使用显式指针、引用或对象名称，否则嵌套类中的声明只能使用可见结构，包括封闭类和全局变量中的类型名称、静态成员和枚举数。

嵌套类的成员函数遵循常规访问规则，并且对其封闭类的成员没有特殊的访问权限。封闭类的成员函数对嵌套类的成员没有特殊的访问权限。”

于 2012-02-20T15:08:11.153 回答