C++ 使用派生类对象检查私有变量

下面是一个小程序。 我想使用类B的对象检查类A的私有变量x的值。 有可能吗

#include<stdio.h>
#include<conio.h>
#include<iostream>

class A {
    int x;
public:
    A() {
        x=10;
    }
};

class B : public A { 
public:
    int x;
};

int main()
{
    B obj;
    obj.x=20;
    std::cout<< obj.x;
    getch();
}

#包括
#包括
#包括
甲级{
int x；
公众：
(){
x=10；
}
};
B类：公共A{
公众：
int x；
};
int main（）
{
B obj；
obj.x=20；
std:：cout派生类看不到祖先私有。您可以使用“protected”让后代查看数据，但不能使用不相关的类。
派生类看不到祖先私有。您可以使用“protected”让子代看到数据，而不是不相关的类。
您必须使变量受保护，或者，您可以在类a中创建一个受保护的成员方法，该方法返回变量x

使用第二方法（受保护成员方法或属性（C++中可能的）），B类可以读取变量，但不能更改它。
 < p>您必须使变量受保护，或者，可以在类A中创建受保护的成员方法，该方法返回变量x.< /p>
使用第二种方法（受保护成员方法或属性（C++中可能的）？），类B可以读取变量，但不能更改它。
您不能检查基类的私有成员的值。因此：在A中添加一个访问器或使A:：x受保护。
您不能检查基类的私有成员的值。因此：在A中添加一个访问器或使A:：x受保护。
使x受保护并在B中编写一个方法看起来像这样：

int getAX(){
  return A::x
}

将x设为受保护的，并在B中编写一个如下所示的方法：

int getAX(){
  return A::x
}

你不应该

由于您的
A
类告诉该成员是私有的，因此只有
A
才能访问它

如果
B
是一个-
A
，则相同的规则有效：
A:：x
仍然不可访问

你想要访问它意味着你要么需要一种不同的
a
（即使
a:：x
公开），要么你想要错误的东西。
你不应该这样做

由于您的
A
类告诉该成员是私有的，因此只有
A
才能访问它

如果
B
是一个-
A
，则相同的规则有效：
A:：x
仍然不可访问

您想要访问它意味着您需要另一种
a
（即使
a:：x
公开），或者你想要错误的东西。
除了私有/受保护的问题之外，你的
B:：x
成员对
A
的
x
进行了遮罩。因此，即使两者都是公共的，你也必须编写
B.A:：x
。看起来很奇怪，但效果很好（见下面的代码）

这是语法方面的。当然，正如这里的每个人所说，您应该这样做。使用具有有意义名称的受保护成员和访问器函数

class A {
public:
  int x;
};

class B: public A {
public:
  int x;
  void f() { std::cout << "B::x=" << x << ", A::x=" << A::x << '\n'; }
};

int main()
{
  B b;
  b.A::x = 10;
  b.x = 20;
  b.f();
}

除了私有/受保护的问题外，您的
B:：x
成员对
A
的
x
进行了遮罩。因此，即使两者都是公共的，您也必须编写
B.A:：x
。看起来很奇怪，但工作正常（请参见下面的代码）

这是语法方面的。当然，正如这里的每个人所说，您应该这样做。使用具有有意义名称的受保护成员和访问器函数

class A {
public:
  int x;
};

class B: public A {
public:
  int x;
  void f() { std::cout << "B::x=" << x << ", A::x=" << A::x << '\n'; }
};

int main()
{
  B b;
  b.A::x = 10;
  b.x = 20;
  b.f();
}

好吧，如果你真的想知道它是否可能：它是。
public
，
protected
和
private
只是编译时检查。在运行时绕过它们的一个可能选项是：

#include <iostream>
class A{
    int x;
    A() : x(10){}
};
struct pubA{
    int x;
};

int main(){
    A a;
    // evil casting
    pubA* pa = reinterpret_cast<A*>(&a);
    std::cout << pa->x << std::endl; // should print 10
}

#包括
甲级{
int x；
A（）：x（10）{}
};
耻骨结构{
int x；
};
int main（）{
A A；
//邪恶的铸造
pubA*pa=重新解释铸件（&a）；
std：：cout x如果你真的想知道它是否可能：它是。
public
，
protected
和
private
只是编译时检查。在运行时绕过它们的一个可能选项是：

#include <iostream>
class A{
    int x;
    A() : x(10){}
};
struct pubA{
    int x;
};

int main(){
    A a;
    // evil casting
    pubA* pa = reinterpret_cast<A*>(&a);
    std::cout << pa->x << std::endl; // should print 10
}

#包括
甲级{
int x；
A（）：x（10）{}
};
耻骨结构{
int x；
};
int main（）{
A A；
//邪恶的铸造
pubA*pa=重新解释铸件（&a）；
std:：cout x为什么不使用，比如说，受保护的访问器？为什么不使用，比如说，受保护的访问器？我想知道我们是否可以在不将x设为受保护的情况下检查值！不，private意味着private，并且定义类之外的任何人都看不到它。同样，受保护的整个要点是，派生类可以看到父类的成员，而没有人可以看到它LSE可以。我想知道我们是否可以在不保护X的情况下检查值。不，私有意味着私有，并且在定义类之外没有人能看到它。同样，保护的整个点是派生的，类可以看到父成员，而没有其他人可以。C++中的保护提供了对派生类的完全访问。如果您想给出的话。派生类只读访问然后使用受保护的访问方法。C++中的保护提供对派生类的完全访问。如果您想给派生类只读访问，则使用受保护的访问方法。