Die Unterschiede zwischen virtuellen und rein virtuellen Funktionen in C++

1. Virtuelle Funktionen und ihre Eigenschaften in C++
2. Rein virtuelle Funktionen und abstrakte Typen in C++

In diesem Artikel werden die Unterschiede zwischen virtuellen und rein virtuellen Funktionen in C++ beschrieben.

Virtuelle Funktionen und ihre Eigenschaften in C++

Virtuelle Funktionen sind eng mit dem Konzept des Polymorphismus verbunden. In C++ können wir verschiedene Klassen in einer verknüpften Hierarchie organisieren, in der sie möglicherweise einige Datenmember gemeinsam nutzen und dieselben Memberfunktionen wie die Schnittstelle verfügbar machen.

Im Allgemeinen werden die Klassen, die einen Teil des Codes von anderen Klassen erben, abgeleitete Klassen genannt, während die geerbten Klassen die Basisklassen sind. Beachten Sie, dass diese Begriffe manchmal austauschbar mit Eltern-Kind- oder Superklassen-Unterklassennamen verwendet werden können. Die Funktionen, die in abgeleiteten Klassen überschrieben werden können, werden virtuelle Funktionen genannt und mit dem Schlüsselwort virtual deklariert. Virtuelle Funktionen haben innerhalb der gegebenen Klassenhierarchie denselben Namen, und jede abgeleitete Klasse kann ihre eigene Definition der Funktion implementieren.

Wenn die Funktion nicht überschrieben wird, ruft das abgeleitete Klassenobjekt die in der Basisklasse definierte Funktion auf. Das folgende Beispielprogramm unten demonstriert die grundlegende Verwendung virtueller Funktionen, indem die Funktion print sowohl in den Klassen Engineer als auch Employee definiert wird. Dann können wir eine beliebige Funktion Func implementieren, die den Verweis auf Employee akzeptiert und die Funktion print innerhalb des Körpers aufruft.

Nun kann sich die Func-Implementierung mehrfach ändern, ruft aber immer die entsprechende print-Funktion basierend auf dem als Parameter übergebenen Objekt auf. Wir können mehrere abgeleitete Klassen in der Klassenhierarchie Employee hinzufügen. Jeder von ihnen kann/darf die Funktion print implementieren, aber die Funktion Func akzeptiert ihre Instanzen und ruft die richtige virtuelle Funktion auf.

#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Employee {
 public:
  Employee(string fn, string ln)
      : first_name(std::move(fn)), last_name(std::move(ln)) {}
  virtual void print() {
    cout << "name: " << first_name << "\n"
         << "last name: " << last_name << "\n";
  };

 protected:
  string first_name, last_name;
};

class Engineer : public Employee {
 public:
  Engineer(string fn, string ln, string sp)
      : Employee(std::move(fn), std::move(ln)), specialization(std::move(sp)) {}

  void print() override {
    Employee::print();
    cout << "specialization: " << specialization << "\n";
  }

 private:
  string specialization;
};

void Func(Employee &em) { em.print(); }

int main() {
  Employee em1("Jim", "Jiao");
  Engineer eng1("Jin", "Baker", "Aerospace Engineering");

  Func(em1);
  cout << "\n";
  Func(eng1);

  return EXIT_SUCCESS;
}

Ausgabe:

name: Jim
last name: Jiao

name: Jin
last name: Baker
specialization: Aerospace Engineering

Rein virtuelle Funktionen und abstrakte Typen in C++

Andererseits haben wir das Konzept der rein virtuellen Funktionen, die ähnlich wie die regulären virtuellen Funktionen deklariert werden und die Notation = 0; enthalten. am Ende der Erklärung. Diese Funktionen haben im Wesentlichen keine Definition in der Basisklasse, wo sie zuerst deklariert werden. Daher werden sie höchstwahrscheinlich in den abgeleiteten Klassen definiert.

Die Klassen, die rein virtuelle Funktionen enthalten, werden abstrakte Klassen genannt und werden normalerweise verwendet, um die Schnittstelle für die abgeleiteten Klassen zu spezifizieren. Beachten Sie, dass abstrakte Klassen nicht direkt instanziiert werden können.

Der nächste Codeausschnitt implementiert die Klassen Triangle und Rectangle mit der abstrakten Basisklasse Shape. In diesem Fall haben wir in beiden abgeleiteten Klassen die rein virtuelle Funktion printArea definiert. Manchmal definiert eine abgeleitete Klasse keine geerbte rein virtuelle Funktion, was sie zu einer anderen abstrakten Klasse in der gegebenen Klassenhierarchie macht. Eine abgeleitete Klasse kann mehrere rein virtuelle Funktionen erben. Wenn sie nicht einmal eine von ihnen definiert, wird eine abstrakte Klassifizierung auf die Klasse angewendet.

#include <iostream>
#include <string>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class Shape {
 public:
  virtual void printArea() = 0;
};

class Triangle : public Shape {
 public:
  Triangle(double b, double h) : base(b), height(h) {}

  void printArea() override { cout << (base * height) / 2.0; }

 private:
  double base;
  double height;
};

class Rectangle : public Shape {
 public:
  Rectangle(double i1, double i2) : edges({i1, i2}) {}

  void printArea() override { cout << edges[0] * edges[1]; }

 private:
  vector<double> edges;
};

int main() {
  Triangle t1(3, 5);
  t1.printArea();
  cout << "\n";

  Rectangle r1(3, 5);
  r1.printArea();
  cout << "\n";

  return EXIT_SUCCESS;
}

Ausgabe:

7.5
15