Can inner classes access private variables?

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

This errors out when I compile with class Outer::Inner' has no member named `var'

122577 次浏览
小开

任何外层的 一部分都应该能够访问外层的所有成员，不管是公共的还是私人的。

编辑: 您的编译器是正确的，var 不是 Inside 的成员。但是，如果您有一个外部实例的引用或指针，它可以访问该实例。

小开

内部类是它所定义的类的朋友。
因此，是的; 类型为 Outer::Inner的对象可以访问类型为 Outer的对象的成员变量 var。

但是，与 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 的一些怪异之处)。因此，如果将对外部类的引用传递给内部类，它可以引用外部类实例中的任何内容。

小开

Var 不是内部类的成员。

要访问 var，应该使用指向外部类实例的指针或引用。例如，如果内部类是外部类的朋友，pForeign-> var 将会工作; 或者，如果严格遵循 C + + 标准，var 是 public。

有些编译器将内部类视为外部类的朋友，但有些则不然。参见 本文档用于 IBM 编译器:

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

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

小开

首先，您试图访问类之外的非静态成员 var，这在 C + + 中是不允许的。

马克的回答是正确的。

任何属于外层组织的东西都应该可以接触到外层组织的所有成员，无论是公共的还是私人的。

因此，您可以做两件事情，要么将 var声明为 static，要么使用外部类的一个实例的引用来访问“ var”(因为 朋友类别或功能也需要引用来访问私有数据)。

静态变量

如果不希望 var与类的实例关联，请将 var更改为 static。

#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

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


提交答案