变量的访问修饰符：私有与受保护

Question

我有一个案例，我找不到合适的解决方案。我需要有模板基类和一个对该基类进行一些工作的管理器类。这是代码

class Base;

class Manager
{
public:
    void DoSomethingTo(Base * bclass)
    {
        if(bclass->PrivateVar == 0)
            // Some code
    }
}

class Base
{
protected: 
    int PrivateVar;
friend class Manager;
};

template<class T>
class TempBase : public Base
{
private:
    Manager * man;
public:
    void DoWork()
    {
        PrivateVar = 0;
        man->DoSomethingTo(this);
    }
}

我的问题是 PrivateVar 变量实际上必须是 TempBase 私有的，并且不能从 TempBase 派生的类访问，但由于我无法将其指针传递给 Manager::DoSomethingTo()，所以我有要从基类派生它，基类必须拥有 PrivateVar。由于我在 TempBase 中使用 PrivateVar，它不能是 Base 的私有变量，这使得它可以从 TempBase 的子类访问。

如何编写 TempBase 类，以便 PrivateVar 是私有成员，而可以从 Manager::DoSomethingTo() 访问它？

谢谢

Answer 1

首先，让我们开始火焰之战：

类的属性永远不会被保护。它应该是私有（在大多数情况下），或者在某些极端情况下可能是公共。请注意，因为每个派生类都会看到一个 protected 属性，所以 protected 只会带来一种错误的安全感：人们无法控制 protected 上的任何不变量。属性，因此它本质上是一个 public 属性，其顶部有一条注释 Don't Touch。

现在这一切都已经说了，我建议将其简单地更改为：

class Base {};
template <typename T> class TBase;

class DoKey { template <typename T> friend class TBase; DoKey(); };

class Manager
{
public:
  void DoSomethingTo(Base& base, DoKey const& key);
};

template <typename T>
class TBase: public Base
{
public:
  void Do()
  {
    Manager manager;
    if (PrivateVar == 0) { manager.DoSomething(*this, DoKey()); }
  }

private:
  int PrivateVar;
};

通过将测试的责任委托给变量的所有者，我们可以温和地解决所有的担忧。当然，如果我们需要多个类以类似的方式表现，那么我们可以在 Base 中引入一个纯虚 void ShouldIDoSomething() const 并在 中检查它经理的方法。

Answer 2

删除Base内部的访问保护，然后私有继承。

class Manager
{
public:
    void DoSomethingTo(struct Base * bclass);
};

struct Base
{
    int PrivateVar;
};

void Manager::DoSomethingTo(struct Base * bclass)
{
    if(bclass->PrivateVar == 0)
        ; // Some code
}

template<class T>
class TempBase : private Base
{
private:
    Manager * man;
public:
    void DoWork()
    {
        PrivateVar = 0;
        man->DoSomethingTo(this);
    }
};

Answer 3

您可以将受保护的成员函数放入 Base 本身：

class Base
{
protected:
   void sendPrivateVarToManager( Manager& manager )
   {
      manager.DoSomethingToPrivateVar( privateVar );
   }
};

由于 Base 不是模板，因此实际上可以将实现放在 Base 之外。

您的另一个问题是您希望 privateVar 存在于 Base 中，对 TempBase 可见，但在层次结构中不可见。您可以将其移动到 TempBase 中，在这种情况下，您也可以将 sendPrivateVarToManager 放入该类中，尽管您必须实现它，或者也将 privateVar 作为参数传递给该类。您的另一个选择是使 TempBase 成为 Base 的友元，但这似乎是错误的。我不确定为什么 TempBase 需要访问权限。

Answer 4

您可以将 PrivateVar 设为私有，并将 TempBase 和 Manager 设为 Base 的好友。请参阅此处。请注意，这段代码并不是最干净的。

Answer 5

我认为我可以将一个公共纯虚函数放入 Base 来检索 PrivateVar，同时将 PrivateVar 保留在 TempBase 中。

class Manager
{
public:
    void DoSomethingTo(Base * bclass)
    {
        if(bclass->GetPrivateVar() == 0)
            // Some code
    }
}
class Base
{
private:
virtual int GetPrivateVar() = 0;  
friend class Manager;
};

template<class T>
class TempBase : public Base
{
private:
    Manager * man;
    int PrivateVar;
    int GetPrivateVar() {return PrivateVar;}
public:
    void DoWork()
    {
        PrivateVar = 0;
        // Some code
        man->DoSomethingTo(this);
        // Some code
    }
friend class Manager;
}