Question

我很困惑......似乎两件事都做同样的事情。

在第一个代码中，我相信派生类隐藏了基类的函数名。

#include <iostream>

using namespace std;

class Quadrilateral {

public:
   void greeting() {
       std::cout << "i am a quadrilateral" << std::endl;
   }
};

class Square : public Quadrilateral {
 public:
    void greeting() {
        std::cout << "i am a square" << std::endl;
    }
};

class Trapezoid : public Quadrilateral {

public:
    void greeting() {   //hides greeting from quadrilateral function
        std::cout << "Hi I'm a Trapezoid" << std::endl;
    }
};

int main()
{
    Trapezoid tz;
    tz.greeting();  
}

这似乎有完全相同的结果：[这里它们被重写，因为它在基类中是虚拟的]

#include <iostream>
using namespace std;


class Quadrilateral {

public:

    virtual void greeting() {
        std::cout << "i am a quadrilateral" << std::endl;
    }
};

class Square : public Quadrilateral {
  public:
    void greeting() {
        std::cout << "i am a square" << std::endl;
    }
};

class Trapezoid : public Quadrilateral {

public:
    void greeting() {   //hides greeting from quadrilateral function
        std::cout << "Hi I'm a Trapezoid" << std::endl;
    }
};

int main()
{
    Trapezoid tz;
    tz.greeting();  
}

所以我想我真的很困惑......有什么区别？或者，如果它在这种情况下会产生相同的效果，那么在基类中实现虚拟的重点是什么？

Answer 1

虚函数用于从基类指针调用overriden函数。在第二个示例中，如果您在main()

中执行以下操作，则可以获得相同的结果

 Trapezoid tz;
 Quadrilateral *base = &tz;
 base->greeting(); // it will print "Hi I'm a Trapezoid"

这与第一个例子的区别在于：从基类指针调用派生函数的可能性。如果未覆盖派生类中的虚拟基本函数，则将调用基本虚函数。

用法示例。

想象一下，你想用基类Quadrilateral创建许多对象（例如五个正方形和三个梯形）：

Square sq1, sq2, sq3, sq4, sq5;
Trapezoid tz1, tz2, tz3;

现在，在您的代码中的某个时刻，您想要抛出所有这些对象并调用抽象函数（在您的情况下为greeting()）。因此，借助虚函数，您可以非常简单地执行：将所有对象放在指针数组中并调用propper函数。方法如下：

Quadrilateral *base[8] = {&sq1, &sq2, &sq3, &sq4, &sq5, &tz1, &tz2, &tz3};
for (int i = 0; i < 8; i++) {
    base[i]->greeting();
}

在输出中，您将收到五次"i am a square"和三次"Hi I'm a Trapezoid"。当您创建所有不同的形状（例如，具有不同的尺寸，属性）并希望抛出所有这些对象并调用（例如calc()函数来为每个形状单独计算时，它会有所不同。< / p>

我希望这会对你有所帮助。

Answer 2

在C ++中，如果你声明/拥有一个结构或类变量，就像在这个例子中一样，编译器通常会知道它的类型，并且总是调用正确的函数，而不管virtual / not。

虚函数仅在处理指针或引用时很重要。

尝试在现有代码之后，在main：

结束之前添加此内容

Quadrliateral *q = &t;
q->greeting();

你会发现所有的问候功能是否是虚拟的都很重要。

Answer 3

首先，请格式化您的代码！

第一个例子

class Quadrilateral {
  public:
    void greeting() {
      std::cout << "i am a quadrilateral" << std::endl;
  }
};

class Square : public Quadrilateral {
  void greeting() {
    std::cout << "i am a square" << std::endl;
  }
};

class Trapezoid : public Quadrilateral {
  public:
    void greeting() {   //hides greeting from quadrilateral function
      std::cout << "Hi I'm a Trapezoid" << std::endl;
    }
};

int main() {
  Trapezoid tz;
  tz.greeting();  
}

在这个例子中，Trapezoid.greeting（）隐藏了Quadrilateral.greeting（）是完全正常的：它是一个重写（相同的方法名称，相同的返回，相同的参数（无））。

第二个例子

class Quadrilateral {
  public:
   virtual void greeting() {
     std::cout << "i am a quadrilateral" << std::endl;
   }
};

class Square : public Quadrilateral {
  void greeting() {
    std::cout << "i am a square" << std::endl;
  }
};

class Trapezoid : public Quadrilateral {
 public:
  void greeting() {   //hides greeting from quadrilateral function
    std::cout << "Hi I'm a Trapezoid" << std::endl;
  } 
 };

int main() {
  Trapezoid tz;
  tz.greeting();  
}

同样的。你创建了一个具有动态类型梯形的静态类型梯形的objcet。所以tz.greeting将打印“我是一个梯形”，因为greeting（）是一个覆盖。

第三个例子

class Shape {
  public:
    virtual void greeting() {
      std::cout << "Shape" << std::endl;
  }
};

class Square : public Shape {
  /* override method greeting() of Shape class */
  void greeting() {
    std::cout << "Square" << std::endl;
  }
};

class Triangle : public Shape {
  public:
  /* override method greeting() of Shape class */
    void greeting() {   
      std::cout << "Triangle" << std::endl;
    }
};

int main() {
  Shape* shape = new Triangle();
  shape->greeting(); /* prints "Triangle" */
  shape = new Square();
  shape->greeting(); /* prints "Square" */
}

我想我的名字隐藏与功能覆盖混淆

3 个答案: