C++ 通过继承的函数（？）读取基类的私有成员

在下面的示例中，调用

d.run（）打印
aD bD cD
，我不明白为什么。我认为它应该打印
aB bB cB aD bD cD
，而不是我们将
Base
的向量
vars_Base
全部6次（？）

根据输出，我认为
vars_Base
成员的副本是
派生的
类的，尽管它是
私有的
到
Base
（？）

我要澄清的是，这个问题的重点仅仅是理解下面示例的行为-我的意图不是通过
派生
访问
基地
的私人成员

#include <iostream>
#include <vector>

class Base
{
private:
  std::vector<std::string> vars_Base;

protected:
  std::vector<std::string> &get_vars()
  {
    return vars_Base;
  }

public:
  void push_back(const std::string &str)
  {
    get_vars().push_back(str);
  }

  void run()
  {
    for (auto int_vars_it : get_vars())
    {
      std::cout << int_vars_it << " ";
    }
  }
};

class Derived : public Base
{
};

int main(int argc, char *argv[])
{
  Base b;
  b.push_back("aB");
  b.push_back("bB");
  b.push_back("cB");
  b.run(); // prints aB bB cB

  std::cout << std::endl;

  Derived d;
  d.push_back("aD");
  d.push_back("bD");
  d.push_back("cD");
  d.run(); // prints aD bD cD

  return 0;
}

#包括
#包括
阶级基础
{
私人：
std：：向量变量库；
受保护的：
std:：vector和get_vars（）
{
返回vars_基地；
}
公众：
void push_back（常量std:：string和str）
{
获取变量（）；
}
无效运行（）
{
for（auto-int\u-vars\u-it:get\u-vars（））
{
std:：cout实例变量不会在类的不同实例之间共享。虽然
b
和
d
都有
b
的成员，但它们都有自己的向量副本，因为向量是实例变量

如果您希望一个类的所有实例共享一个变量的值，那么您应该使该变量成为静态的（如果您愿意，还可以使使用向量的方法也成为静态的）.
实例变量不会在类的不同实例之间共享。虽然
b
和
d
都有
b
的成员，但它们都有自己的向量副本，因为向量是实例变量

如果你想让一个类的所有实例共享一个变量的值，那么你应该使变量成为静态的（如果你愿意，你也可以使使用向量的方法成为静态的）。
因为
b
和
d
是不同的实例（对象）这意味着在
b
中有一个
std:：vector
vars_Base
，在
d
中有一个
std:：vector，它们不共享它的内容

Object b

+---------------------------------+
|  b                              |
|                                 |
|  vars_Base        +----------+  |
|                   |    aB    |  |
|                   +----------+  |
|                   |    bB    |  |
|                   +----------+  |
|                   |    cB    |  | 
|                   +----------+  |
+---------------------------------+

记忆中的其他地方

Object d
+---------------------------------+
|  d                              |
|                                 |
|  vars_Base        +----------+  |
|                   |    aD    |  |
|                   +----------+  |
|                   |    bD    |  |
|                   +----------+  |
|                   |    cD    |  | 
|                   +----------+  |
+---------------------------------+

类的实例不共享其内容，每个对象都有自己的内存和变量。
因为
b
和
d
是不同的实例（对象）这意味着在
b
中有一个
std:：vector
vars_Base
，在
d
中有一个
std:：vector，它们不共享它的内容

Object b

+---------------------------------+
|  b                              |
|                                 |
|  vars_Base        +----------+  |
|                   |    aB    |  |
|                   +----------+  |
|                   |    bB    |  |
|                   +----------+  |
|                   |    cB    |  | 
|                   +----------+  |
+---------------------------------+

记忆中的其他地方

Object d
+---------------------------------+
|  d                              |
|                                 |
|  vars_Base        +----------+  |
|                   |    aD    |  |
|                   +----------+  |
|                   |    bD    |  |
|                   +----------+  |
|                   |    cD    |  | 
|                   +----------+  |
+---------------------------------+

类的实例不共享其内容，每个对象都有自己的内存和变量。
层次结构中任何类的每个实例都有自己的
vars\u Base
实例。因此
B
也有自己的
D

事实上，
vars\u Base
在
Base
中是私有的，这意味着
vars\u Base
在
Derived
中也是私有的。这意味着您无法访问
b.vars\u Base
或
d.vars\u Base

但是同样地，
vars\u Base
的两个实例不共享任何内容，因此如果
B
和
D
中的
push\u-back
内容，这些对象存储在两个不同的
vector
中，层次结构中任何类的每个实例都有自己的
vars\u Base
实例。因此
B
有自己的作为well为
D

事实上，
vars\u Base
在
Base
中是私有的，这意味着
vars\u Base
在
Derived
中也是私有的。这意味着您无法访问
b.vars\u Base
或
d.vars\u Base

但是同样地，
vars\u Base
的两个实例不共享任何内容，因此如果
B
和
D
中的
push\u-back
内容，则这些对象存储在两个不同的
向量
Base B
和
派生D
中，它们是完全不同的对象，彼此没有关系

类是对象的蓝图，而不是对象本身。类的多个实例具有不同的内存区域

要获得所需的输出，可以将代码编写为

    Derived d;
    d.push_back("aB");
    d.push_back("bB");
    d.push_back("cB");

    d.push_back("aD");
    d.push_back("bD");
    d.push_back("cD");
    d.run();

Base b
和
Derived D
是完全不同的对象，彼此没有关系

类是对象的蓝图，而不是对象本身。类的多个实例具有不同的内存区域

要获得所需的输出，可以将代码编写为

    Derived d;
    d.push_back("aB");
    d.push_back("bB");
    d.push_back("cB");

    d.push_back("aD");
    d.push_back("bD");
    d.push_back("cD");
    d.run();

你推了三个东西，所以你打印了三个东西。不清楚为什么你期望六个。如果你用
Base d；
替换
Derived；
，你还会期望打印六个项目吗？
b
不是
d
的一部分。即使类型相互继承，变量也是完全独立的。因此有一个
vars\b在
b
和
d
中的ase
和@juanchopanza中的另一个ase，我们在所有6种情况下都在推进向量
变量库
，不是吗（？）@BillyJean不是同一个向量。这与继承或私有访问无关。如果你说
int i=42；
所有的int都变成42了吗？你推了三个东西，所以你打印了三个东西。不清楚为什么你期望六个。如果你用
Base d；
替换
派生的d；
你仍然希望打印六个项目吗？
b
不是
d
的一部分。即使类型彼此继承，变量也是完全独立的。因此在
b
中有一个
vars_Base
，在
d
@juanchopanza中有一个
vars_Base
，我们在所有6种情况下都在推进向量
vars_Base
，不是吗（？）@BillyJean不是同一个向量这与继承无关，