Полиморфизъм и виртуално в C++

Може би един пример може да помогне. Помислете за различен main(), като този:

int main()
{
    std::vector<std::unique_ptr<Pet>> menagerie;
    menagerie.push_back(std::make_unique<Dog>("Fido"));
    menagerie.push_back(std::make_unique<Cat>("Morris"));
    menagerie.push_back(std::make_unique<Cat>("Garfield"));
    menagerie.push_back(std::make_unique<Dog>("Rover"));

    for (auto&& pet : menagerie)
    {
        pet->MakeSound();
    }
}

Тук имаме куп домашни любимци. Можем да се справим с всички тях по един и същи начин, но те издават различни звуци. Извикването на MakeSound на всеки прави правилното нещо за този конкретен вид домашен любимец. Този вид случай на употреба е много често срещан.

Fido the Dog says: Woof! Woof!
Morris the Cat says: Meow! Meow!
Garfield the Cat says: Meow! Meow!
Rover the Dog says: Woof! Woof!

Сега опитайте да премахнете ключовата дума virtual и всички ще кажат „Шшт!

Прав си, не е лесно да се разбере как полиморфизмът е полезен и какво прави, когато го научиш. Често срещаните примери като посочените от вас всъщност не помагат, което просто демонстрира концепцията, но липсва реален контекст.

Разбирането и възможността за използване на полиморфизъм е доста напреднала тема в програмирането. Използва се, когато се следва наистина обектно ориентирано програмиране като SOLID и шаблони за проектиране.

Добър пример от реалния свят за полиморфизъм в действие е шаблонът за проектиране на итератор. Вие дефинирате базов клас, да речем за списък с метод като next(), след което можете да имате различни производни класове (за различни видове списъци), всички заменящи този метод и те го прилагат, така че да можете да итерирате този списък съответно.

Както може би виждате, става сложно, така че не мога да обясня всичко тук, но получавате представа и някои насоки.

Ключовата идея на полиморфизма е да има един метод. Този метод ще има различни реализации и конкретна реализация се извиква въз основа на определени ситуации.

Нека разгледаме този пример:

#include <iostream>
using namespace std;
class Polygon{

 protected:
  int numVertices;
  float *xCoord, *yCoord;

 public:
  void set(){
   cout<<"From Polygon"<< endl;
  }

};
class Rectangle : public Polygon{
public:

 void set(){
   cout<<"From Rectangle"<< endl;
}

class Triangle : public Polygon{
public:

 void set(){
   cout<<"From Triangle"<< endl;

 }
};
int main(){

 Polygon *poly;
 Rectangle rec;
 Triangle tri;

 poly = &rec;
 poly->set();
 poly = &tri;
 poly->set();
}

Когато стартирате този код, изходът ви е следният:

From Polygon
From Polygon

Нека добавим virtual към set() в базов клас (Polygon). Ето какво получавате:

From Rectangle
From Triangle

Ако сме създали виртуална функция в базовия клас (Polygon) и тя се отменя в производния клас (В този случай Triangle и Rectangle), тогава не се нуждаем от ключова дума virtual в производния клас, функциите автоматично се считат за виртуални функции в производния клас.

Идеята е set() да извика версията на базовия клас на метода, ако set() не е виртуален дори ако poly е насочен към Rect. От друга страна, set(), който е виртуален, той ще извика действителния метод от производния клас. (В този случай rect->set() ще отпечата „От правоъгълник“).

Това означава, че в ситуации, в които не знам конкретния тип обект, мога да използвам virtual и polymorphism и той ще използва правилния метод по време на повикване.

Надявам се това да помогне!