Question

我有以下代码。

#include <iostream>

class Base1
{
public:

  void print(){std::cout<<"Printing Base1\n";}
};


class Derived1: public Base1
{
public:
  void print_1(){std::cout<<"Printing Derived1 \n";}
};



class Base2
{
public:
  void myFunction1( Base1& b1)
  {
    myFunction2(b1);

  }

  virtual void myFunction2( Base1& b1)
  {
    b1.print();
  }
};

class Derived2: public Base2
{
public:
  void myFunction2( Derived1& d1)
  {
    d1.print_1();
  }
};





int main()
{
  Base1 b1;
  Derived1 d1;
  Base2 b2;
  Derived2 d2;
  b2.myFunction1(b1);
  d2.myFunction1(d1);
  return 0;
}

它产生以下输出：

Printing Base1
Printing Base1

我想到了以下输出

Printing Base1
Printing Derived1

获得所需输出的方法之一是执行以下操作。

class Derived2: public Base2
    {
    public:
      void myFunction2( Base1& b1)
      {
        Derived1* d1 = static_cast<Derived1*> (&b1);
        d1.print_1();
      }
    };

我想允许Derived2仅处理Derived1而不处理Base1。否则，某些用户可能会使用Base1对象调用Derived2 :: myFunction2，这会在这种情况下使程序崩溃。

有一个很好的解决方案吗？

Answer 1

myFunction2()中的

Derived2未覆盖myFunction2()中的Base2。

虚拟函数只有在其签名完全匹配时才会被覆盖。此派生类中的函数采用与基类中的函数不同的参数。因此，它不会覆盖。

作为您的第一步，您必须覆盖它。

class Derived2: public Base2
{
public:
  void myFunction2( Base1& d1) override;
};

现在它被覆盖了。如果你明确指定了override限定符，就像我在这里所做的那样，你的编译器就会对你大吼大叫。

现在，您的目标是拥有myFunction2所做的任何事情，只使它对Derived1类生效，对于所有其他Base1类，使用超类所做的事情。< / p>

确定。这将需要更多的工作，并且将有点难以遵循。需要发生的是另一个虚拟继承，这次是Base1：

class Derived2: public Base2
{
public:
  void myFunction2( Base1& d1) override
  {
      d1.print_from_Derived2( *this );
  }
};

现在，您需要定义Base1::printDerived2()，这将调用print()，根据您的问题，这是本案中应该发生的事情：

class Base1
{
public:
       virtual void print_from_Derived2( Derived2 &)
       {
              print();
       }
};

现在，在Derived1中覆盖它，以便将最后一块拼图放在一起：

class Derived1 : public Base1
{
public:
       void print_from_Derived2( Derived2 &) override
       {
              // Do whatever print() from Derived2 needs to do, for
              // this object, which is Derived1.
       }
};

在这里，您将为Derived2做任何需要做的事情，只打印Derived1。这是一条迂回路线，但你终于到达了两个演员都Derived1和Derived2的地方，没有违反任何规则，也没有任何丑陋的演员。

你需要在这里做一堆前进声明，以便拼接所有这些移动的部分。我的例子只是简单的简化，它们显然是相互引用的，并且必须分成单独的声明和定义，并附有适当的前向声明。

如何纠正多态性

1 个答案: