Klassenvorlagenvererbung in C++

1. Vorlagen in C++
2. Funktionsvorlagen in C++
3. Klassenvorlagen in C++
4. Klassenvorlagenvererbung in C++

Dieser Artikel behandelt eine der beliebtesten und am häufigsten verwendeten Methoden in C++ (d. h. Klassenvorlagen).

Das Hinzufügen von Vorlagen zu C++ führte zu einem neuen Programmierparadigma, das als generische Programmierung bekannt ist. Dies ist jetzt ein wichtiges Element des C++-Programmier-Toolkits, die Grundlage für einen Großteil der Standardbibliothek und etwas, dem viele von uns neueren C++-Hackern noch nie zuvor begegnet sind.

Die generische Programmierung wird manchmal dem Konzept der Vererbung in der objektorientierten Programmierung gegenübergestellt. Andererseits erfordert ein echter Multi-Paradigmen-Ansatz, dass man sich anschaut, wie die beiden interagieren.

Vorlagen in C++

In C++ ist ein Template ein einfaches, aber mächtiges Werkzeug. Die Grundidee besteht darin, den Datentyp als Parameter zu übergeben, wodurch die Notwendigkeit entfällt, denselben Code für mehrere Datentypen zu schreiben.

Beispielsweise kann ein Softwareunternehmen für viele Datenarten sort() benötigen. Anstatt zahlreiche Codes zu schreiben und zu pflegen, können wir eine einzige sort()-Funktion konstruieren und den Datentyp als Parameter übergeben.

C++ hat zwei neue Schlüsselwörter zur Unterstützung von Templates hinzugefügt: template und typename. Anstelle des zweiten Schlüsselwortes kann immer das Schlüsselwort class verwendet werden.

Syntax:

template <typename T>
void myFunction(T var )
{
    //function definition
}

In der oben gezeigten Syntax können wir sehen, dass wir zum Definieren einer Funktion, die eine Template-Variable als Parameter akzeptiert, eine Zeile template<typename T> hinzugefügt haben. Jetzt kann diese Funktion einen Parameter eines beliebigen Datentyps akzeptieren; Es ist eine generische Funktion, die für int, char und viele andere Datentypen verwendet wird.

Funktionsweise von Vorlagen in C++

Vorlagen werden während des Kompilierungsprozesses erweitert. Dies ist ähnlich wie bei Makros.

Andererseits führt der Compiler vor der Vorlagenerweiterung eine Typprüfung durch. Das Konzept ist einfach: Der Quellcode enthält nur eine Funktion oder Klasse, während generierter Code zahlreiche Kopien derselben Funktion oder Klasse enthalten kann.

Dies wird im folgenden Beispiel näher ausgeführt.

#include <iostream>
using namespace std;

template <typename T>
T checkMaxValue(T a, T b) {
  if (a > b)
    return a;
  else if (b > a)
    return b;
  else
    return 0;
}

// driver program
int main() {
  cout << checkMaxValue(102, 204) << endl;  // int value
  cout << checkMaxValue('c', 'f') << endl;  // char value
}

Beachten Sie, dass wir zwei Ganzzahlen an die Funktion in der ersten Zeile des Treiberprogramms übergeben haben und dass sie schließlich den Ganzzahlwert von beiden zurückgeben wird. Wir haben in der zweiten Zeile zwei Zeichenwerte an dieselbe Funktion übergeben, und die Funktion gibt den maximalen Zeichenwert zurück.

Zur Kompilierzeit rufen wir die Funktion wie unten gezeigt auf:

int checkMaxValue(int a, int b)

Und für den zweiten Aufruf schreiben wir Folgendes:

char checkMaxValue(char a, char b)

Wir können sehen, dass mehrere Kopien derselben Funktion zur Kompilierzeit erstellt werden, abhängig vom Variablentyp, der beim Aufrufen der Funktion übergeben wird.

Wir können Vorlagen für Funktionen und Klassen verwenden. Wir werden beide Typen besprechen und wie man beide implementiert.

Funktionsvorlagen in C++

Wir werden eine generische Funktion erstellen, die mit verschiedenen Datenarten arbeiten kann. Sort(), max(), min() und printArray sind Beispiele für Funktionsvorlagen.

Beispielcode:

template <class T>
void sortArray(T arr[], int s) {
  for (int i = 0; i < s - 1; i++)
    for (int j = s - 1; i < j; j--)
      if (arr[j] < arr[j - 1]) {
        int var = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = var;
      }
  cout << " Sorted array : ";
  for (int i = 0; i < s; i++) cout << arr[i] << " ";
  cout << endl;
}

// Driver Code
int main() {
  int a[5] = {10, 50, 30, 40, 20};
  int n = 5;
  sortArray<int>(a, n);

  char c[5] = {'g', 'a', 'i', 'h', 'e'};
  sortArray<char>(c, n);
  return 0;
}

Ausgang:

Im Code-Snippet haben wir eine Funktion sortArray() erstellt, die einen Array-Vorlagentyp und den Größenwert dieses Arrays akzeptieren und das sortierte Array drucken kann. Wir haben es im Hauptcode für zwei verschiedene Array-Typen aufgerufen: int- und char-Arrays.

Folglich können wir jeden Datentyp verwenden und dieselbe Funktion wird funktionieren. Es spart Zeit und Platz und ist zudem effizient in der generischen Programmierung.

Klassenvorlagen in C++

Klassenvorlagen sind wie Funktionsvorlagen praktisch, wenn eine Klasse etwas definiert hat, das nicht vom Datentyp abhängt. LinkedList-, BinaryTree-, Stack-, Queue-, Array- und weitere Klassen können von Klassenvorlagen profitieren.

Syntax:

template <class T>
class className {
 private:
  T a;
  ........public : T myFunc(T x);
  ........
};

In dieser Syntax ist T der Vorlagentyp, der als Platzhalter für den Datentyp verwendet wird. Beim Erstellen eines Objekts für diese Vorlagenklasse wird die folgende Syntax verwendet:

className<dataType> objectName;

In ähnlicher Weise können wir es mit dieser Syntax schreiben:

className<int> objectName;
className<double> objectName;

Beispiel:

#include <iostream>
using namespace std;

template <class T>
class Number {
 private:
  T numb;

 public:
  Number(T a) : numb(a) {}

  T get() { return numb; }
};

int main() {
  Number<int> integerNumber(50);
  Number<double> doubleNumber(8.9);
  cout << "integer Number = " << integerNumber.get() << endl;
  cout << "double Number = " << doubleNumber.get() << endl;
  return 0;
}

Ausgang:

Sie können in diesem Beispiel sehen, dass dieselbe Klasse eine ganze Zahl und eine doppelte Zahl akzeptieren kann. Dieses Beispiel ist sehr generisch, damit Sie das Konzept von Klassenvorlagen verstehen.

Dieses Konzept kann erweitert werden, und viele Klassen können mithilfe von Vorlagen wie LinkedList, Stack, Queue usw. implementiert werden.

Klassenvorlagenvererbung in C++

Das Erben von einer Vorlagenklasse ist möglich. Es gelten alle regulären Vererbungs- und Polymorphismusregeln.

Wenn die neue abgeleitete Klasse allgemein sein soll, müssen wir sie zu einer Template-Klasse mit einem Template-Argument machen, das an die Basisklasse gesendet wird. Dies liegt daran, dass Vererbung nur mit einer Klasse möglich ist und eine Vorlage keine Klasse ist, es sei denn, sie wird instanziiert, indem ihr ein Datentyp übergeben wird.

Syntax:

template <class T>
class derived : public Base<T>{};

Beispiel:

#include <iostream>
using namespace std;

template <class T>
class Base {
 private:
  T val;

 public:
  void setVal(T a) { val = a; }
};
template <class T>
class Derived : public Base<T> {
 public:
  void setVal(T b) { Base<T>::setVal(b); }
};
int main() {
  Derived<int> a;
  a.setVal(4);
  return 0;
}

Wir haben eine Klassenvorlage Basis erstellt, die eine Vorlagentypvariable und eine Memberfunktion im Codeausschnitt enthält. Außerdem haben wir eine abgeleitete Klasse erstellt, die auch ein Klassen-Template ist und das Klassen-Template Base erweitert.

Beim Erweitern der Klasse Base müssen wir die Template-Variable wie Base<T> angeben. Die Klasse Basis ist generisch, und die abgeleitete Klasse ist ebenfalls generisch.

Die abgeleitete Klasse kann auch ihre Vorlagenparameter haben. Das vorherige Beispiel kann wie folgt modifiziert werden:

template <class T, class S>
class Derived : public Base<T> {
 private:
  S data;

 public:
  void setVal(T b) {
    Base<T>::setVal(b);
    data = b;
  }
};

Wir können also sehen, dass die Vererbung auch mithilfe von Klassenvorlagen implementiert werden kann. Darüber hinaus können wir Polymorphie- und Adapterklassen mit Klassenvorlagen implementieren.