在C ++中，如何确定类是否是继承链中的最后一个类/子类？ 即在基类的另一端

Question

我在简单地写这个问题时遇到了问题，但基本上在类中有一个函数可能是继承链中的最后一个类，或者它可能不是。 在此函数内部，如果类级函数是继承链中的最后一个函数，则将调用第二个函数。 显示我正在谈论的内容比解释它要容易得多，所以：

让我们说我有Z级。

Z派生自Y，它源自X，源自W.

所有类都有一个名为Execute（）的虚函数。

Z.Execute（）要求完成Y.Execute（），这需要完成X.Execute（），这需要完成W.Execute（）。

因此，Z的Execute（）函数如下所示：

void Z::Execute(void)
{
   Y::Execute();

   // do Z's stuff!
   return;
}

同样，Y的Execute（）函数如下所示：

void Y::Execute(void)
{
   X::Execute();

   // do Y's stuff!
   return;
}

等等继承链。

但Y，X和W都不是抽象的，因此每个都可以实例化，并且可能是也可能不是继承链中的最后一个类。

这是我需要知道的。 最后一个Execute（）需要调用DoThisAtEndOfExecute（）。 需要在类的内部调用DoThisAtEndOfExecute（），即。 它不会公开。

因此它不能在X的Execute（）中，因为如果类是Y，它将被调用得太早。 它不能在Y的Execute（）中，因为该类可能是Z.它不能在Z的Execute（）中，因为如果该类是Y，X或W，则该函数永远不会被调用。

那么有没有办法让一个类判断它是否已被继承FROM？ 基本上，相当于：

if (!IAmTheParentOfSomething)
   DoThisAtEndOfExecute();

这是怎么做到的？ 我承认，对于包含要执行的类的函数，更简单的方法是：

X.Execute();
X.DoThisAtEndOfExecute();

但这不是这个代码的一个选项。

Answer 1

如果将Execute拆分为非虚拟部件和虚拟部件，我认为可以实现您想要的功能。 前者将运行后者，然后调用DoThisAtEndOfExecute 。 像这样：

class X
{
public:
    void Execute()
    {
        ExecuteImpl(); //That one's virtual, the derived classes override it
        DoThisAtEndOfExecute();
    }

protected:
    virtual void ExecuteImpl()
    {
        //Whatever was in the legacy Execute
    }
}

Y和Z重写ExecuteImpl()并调用基数。 这样， DoThisAtEndOfExecute()在ExecuteImpl（）的派生版本最终完成后运行，不知道实际的类。

Answer 2

一种可能的解决方案是向Execute添加默认参数，在后续调用中将该参数更改为其他值。

class X{
    void Execute(bool isFinal = true);
};
//and so on.

void Z::Execute(bool isFinal)
{
   Y::Execute(false);
   // do Z's stuff!
   if(isFinal){
       // You're up!
   }
   return;
}

void Y::Execute(bool isFinal)
{
   X::Execute(false);

   // do Y's stuff!
   if(isFinal){
       // Y is the last class in this chain.
   }
   return;
}

这样，每当代码调用对象的Execute方法（ 没有参数）时，该方法将被告知某些外部代码正在执行它。 这也允许您通过将false传递给方法来阻止执行所述终止代码。

Answer 3

移动// do ...的东西怎么样！ 分成一个单独的功能？

class W
{
protected:
  void Stuff() { /*...*/ };
  void Finalize() { /*...*/ };
public:
  virtual ~W() {}
  virtual void Execute() { /*...*/ };
};
class X : public W
{
protected:
  void Stuff() { 
    // X Stuff
    W::Stuff();
  };
public:
  virtual ~X() {}
  virtual void Execute() { 
    X::Stuff();
    W::Finalize();
  };
};

class Y : public X
{
  void Stuff() {
    // Y Stuff
    X::Stuff();
  };
public:
  virtual ~Y() {}
  virtual void Execute() {
    Y::Stuff();
    W::Finalize();
  };
};