受保护时保护太多

Question

这是关于“保护”的，解释为：“当一个类继承另一个类时，派生类的成员可以访问从基类继承的受保护成员。”但是，看看这段代码：

class Base {
public:
  Base( int m ) : member(m){}
protected:
  int member;
};

class Derived : public Base { // one of several subclasses
public:
  Derived( int m ) : Base(m), value(10) {}
  int diff( Base x ){
    return value - x.member;
  }
private:
  int value;
};

派生访问“x.member”，它在其基类中受到保护，对吗？但是编译器会标记一个错误，“Base::member is protected”。而且，在考虑了一分钟之后，我不得不同意编译器。

问题来了：我怎样才能做到这一点，同时将信息隐藏的损失降到最低？

1. 显然，将“成员”公开编译，但这违背了初衷。
2. 使用 Base 中的“朋友”机制让子类访问“成员”（以及所有其他私有和受保护的内容）更糟糕（除了超类与其自己的子类的愚蠢绑定 - 维护噩梦）。
3. 在简单示例中，public int getMember(){ return member; } 是可以接受的。但如果成员的类型是 X*，那么您能做的最好的事情就是 public const X* getMember(){...}。

我错过了什么吗？

Answer 1

您可以使用静态保护访问器：

class Base {
public:
  Base( int m ) : member(m){}
private:
  int member;
protected:
  static int GetMember(const Base &b)
  { return b.member; }
};

class Derived : public Base { // one of several subclasses
public:
  Derived( int m ) : Base(m), value(10) {}
  int diff( Base &x ){ //beware of your slicing!
    return value - GetMember(x);
  }
private:
  int value;
};

现在让我补充一下我对 C++ 访问控制为什么会这样工作的想法......

C++ 中的访问控制不是关于信息隐藏。这是关于封装。也就是说，简单地说，您过滤掉了对任何使用不当会破坏类的成员的访问。

在理想的班级

• 公共成员不能用于破坏对象。
• 私人成员知道他们在做什么。

如您所见，在我的计划中，受保护成员几乎没有位置：

• 受保护的成员用于实现继承接口（如果有）。

受保护的成员变量的位置更少。

因此，将您的变量设为私有，并编写一个受保护的访问器。访问器必须是静态的才能从派生对象中使用。

Answer 2

您可以保留受保护的属性，添加您提到的 getter 函数。至于受保护的指针属性，getter 将确保返回 int（或大对象的 const ref），然后您可以在接受 Derived 和 Base 参数的函数模板中进行区别（getter 为您提供计算值）。

保护数据属性允许直接访问派生类中的受保护属性。您尝试的是访问另一个对象的私有属性。这部分代码：

int diff( Base x ){
    return value - x.member;
  }

相当于写在main:

Base x; 
cout << x.member << endl;

这是一个如何使用您自己建议的选项 3 解决问题的示例，其派生类 PointerDerived 使用指针进行存储：

#include <iostream>

class Base {
public:
  Base( int m ) : member(m){}

  int getMember() const
  {
      return member; 
  }

protected:
  int member;
};

class Derived : public Base { // one of several subclasses
public:
  Derived( int m ) : Base(m), value(10) {}

  int getValue() const
  {
      std::cout << "protected = " << member << std::endl;
      return value; 
  }

private:
  int value;
};

class PointerDerived : public Base { // one of several subclasses
public:

  PointerDerived( int m ) : Base(m), value(new int (10)) {}

  int getValue() const
  {
      std::cout << "protected = " << member << std::endl;
      return *value; 
  }

  ~PointerDerived()
  {
      delete value; 
      value = nullptr;  
  }

private:
  int* value;
};

template<typename Derived, typename Base>
int diff(const Derived& d, const Base& b)
{
    return d.getValue() - b.getMember(); 
}

using namespace std;

int main(int argc, const char *argv[])
{
    PointerDerived p(23); 
    Base q(1);

    cout << diff(p, q) << endl; 

    return 0;
}

由于nullptr，使用-std=c++11编译程序，或者将其更改为NULL。

您将diff 设为函数模板，这样您就不必为每个派生类重载它，并让派生类处理存储和访问它，例如PointerDerived .