C++ 设计（基类中的行为，派生类中提供的私有成员）

Question

我有 6 个类都执行相同的操作。我想将常见的行为移到一个常见的 [base] 类中。

需要对 6 个单独的对象执行操作。这六个对象位于派生类中。直观地说，私有成员对象将通过基类中的子类（派生类）访问。

我正在寻找的 C++ 模式是什么？

class Base
{
  // Common behavior, operate on m_object
  ...
  void Foo()
  {
    m_object.Bar();
  }
};

class Derived1 : public Base
{
  // No methods, use Base methods

  private:
  MyObject1 m_object;
}

class Derived2 : public Base
{
  // No methods, use Base methods

  private:
  MyObject2 m_object;
}

让我陷入这种情况的是MyObject1、MyObject2 等提供Bar()，但不共享一个公共基类。我真的无法修复派生，因为对象来自外部库。

Answer 1

如果在派生类中引入它们，则基类不能直接访问它们。基类如何知道所有派生类都有特定的成员？

你可以像这样使用虚拟保护方法：

class my_base
{
protected:
    virtual int get_whatever();
    virtual double get_whatever2();
private:
    void process()
    {
       int y = get_whatever();
       double x = get_whatever2();
       //yay, profit?
    }
}

class my_derived_1 : my_base
{
protected:
    virtual int get_whatever()
    {
        return _my_integer;
    }

    virtual double get_whatever2()
    {
       return _my_double;
    }
}

另一种可能性（如果您想从派生类调用基方法）是简单地将参数提供给基方法。

class my_base
{
protected:
    void handle_whatever(int & arg);
};

class my_derived : my_base
{
    void do()
    {
      my_base::handle_whatever(member);
    }

    int member;
};

Answer 2

C++ 做和不做。它有非常强大的多重继承支持，所以没有super关键字。为什么？假设您的基类被另外两个类继承，甚至是虚拟继承层次结构的一部分。在这种情况下，您无法真正说出super 应该是什么意思。另一方面，有虚方法，你总是可以将它们放在基类中并在派生类中实现（这就是像 Java 这样的语言所做的，只是它们不支持多类继承）。如果你不想使用多态，你可以使用这样的东西：

#include <cstdio>

template <typename T>
struct Base
{
    void foo ()
    {
        std::printf ("Base::foo\n");
        static_cast<T *> (this)->bar ();
    }
};

struct Derived : Base<Derived>
{
    void bar ()
    {
        std::printf ("Derived::bar\n");
    }
};

int
main ()
{
    Derived d;
    d.foo ();
}

这是一个非常简单的示例 - 您可以使用访问控制、好友、编译时断言等扩展上述示例，但您明白了。

Answer 3

你考虑过不使用继承吗？

class FooBar
{
   MyObject m_object;
public:
   FooBar(MyObject m): m_object(m) {}
   //operate on different m_objects all you want
};

Answer 4

从一个公共基类派生六个独立的对象怎么样？然后您可以在该基类中声明虚拟方法来创建您的接口，然后在派生对象类中实现它们。

Answer 5

也许您只需要一个模板而不是超类和 6 个派生类？

似乎您需要访问的不是父字段，而是子字段。您应该通过引入抽象方法来做到这一点：

class ParentClass
{
  public:
    void f();
  protected:
    virtual int getSomething() = 0;
};

ParentClass::f()
{
    cout << getSomething() << endl;
}

class DerivedClass : public ParentClass
{
  protected:
    virtual int getSomething();
}

DerivedClass::getSomething() { return 42; }

如果你需要访问parent的方法，只需使用ParentClass::method(...)：

class ParentClass
{
  public:
    virtual void f();
};

class DerivedClass : public ParentClass
{
  public:
    virtual void f();
};

void DerivedClass::f()
{
    ParentClass::f();
}