C++-Klassenvorlagen

In diesem Tutorial lernen wir anhand von Beispielen etwas über Klassenvorlagen in C++.

Vorlagen sind leistungsstarke Funktionen von C++, mit denen wir generische Programme schreiben können. Es gibt zwei Möglichkeiten, wie wir Templates implementieren können:

Funktionsvorlagen
Klassenvorlagen

Ähnlich wie bei Funktionsvorlagen können wir Klassenvorlagen verwenden, um eine einzelne Klasse zu erstellen, die mit verschiedenen Datentypen arbeitet.

Klassenvorlagen sind praktisch, da sie unseren Code kürzer und überschaubarer machen können.

Klassenvorlagendeklaration

Eine Klassenvorlage beginnt mit dem Schlüsselwort template gefolgt von Template-Parameter(n) innerhalb von <> gefolgt von der Klassendeklaration.

template <class T>
class className {
  private:
    T var;
    ... .. ...
  public:
    T functionName(T arg);
    ... .. ...
};

In der obigen Deklaration T ist das Vorlagenargument, das ein Platzhalter für den verwendeten Datentyp ist, und class ist ein Schlüsselwort.

Innerhalb des Klassenkörpers eine Mitgliedsvariable var und eine Mitgliedsfunktion functionName() sind beide vom Typ T .

Erstellen eines Klassenvorlagenobjekts

Sobald wir ein Klassen-Template deklariert und definiert haben, können wir seine Objekte in anderen Klassen oder Funktionen erstellen (wie etwa dem main() Funktion) mit der folgenden Syntax

className<dataType> classObject;

Zum Beispiel

className<int> classObject;
className<float> classObject;
className<string> classObject;

Beispiel 1:C++-Klassenvorlagen

// C++ program to demonstrate the use of class templates

#include <iostream>
using namespace std;

// Class template
template <class T>
class Number {
   private:
    // Variable of type T
    T num;

   public:
    Number(T n) : num(n) {}   // constructor

    T getNum() {
        return num;
    }
};

int main() {

    // create object with int type
    Number<int> numberInt(7);

    // create object with double type
    Number<double> numberDouble(7.7);

    cout << "int Number = " << numberInt.getNum() << endl;
    cout << "double Number = " << numberDouble.getNum() << endl;

    return 0;
}

Ausgabe

int Number = 7
double Number = 7.7

In diesem Programm. Wir haben eine Klassenvorlage Number erstellt mit dem Code

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

   public:
    Number(T n) : num(n) {}
    T getNum() { return num; }
};

Beachten Sie, dass die Variable num , das Konstruktorargument n , und die Funktion getNum() sind vom Typ T , oder haben einen Rückgabetyp T . Das bedeutet, dass sie von jedem Typ sein können.

Unter main() haben wir die Klassenvorlage implementiert, indem wir ihre Objekte erstellt haben

Number<int> numberInt(7);
Number<double> numberDouble(7.7);

Beachten Sie die Codes Number<int> und Number<double> im Code oben.

Dadurch wird jeweils eine Klassendefinition für int erstellt und float , die dann entsprechend verwendet werden.

Bei der Deklaration von Objekten von Klassenvorlagen muss der Typ zwingend angegeben werden. Andernfalls wird der Compiler einen Fehler erzeugen.

//Error
Number numberInt(7);
Number numberDouble(7.7);

Definieren eines Klassenmitglieds außerhalb der Klassenvorlage

Angenommen, wir müssen eine Funktion außerhalb der Klassenvorlage definieren. Wir können dies mit dem folgenden Code tun:

template <class T>
class ClassName {
    ... .. ...
    // Function prototype
    returnType functionName();
};

// Function definition
template <class T>
returnType ClassName<T>::functionName() {
    // code
}

Beachten Sie, dass der Code template <class T> wird wiederholt, während die Funktion außerhalb der Klasse definiert wird. Dies ist notwendig und Teil der Syntax.

Betrachten wir den Code in Beispiel 1 , haben wir eine Funktion getNum() das innerhalb der Klassenvorlage Number definiert ist .

Wir können getNum() definieren außerhalb von Number mit folgendem Code:

template <class T>
class Number {
    ... .. ...
    // Function prototype
    T getnum();
};

// Function definition
template <class T>
T Number<T>::getNum() {
    return num;
}

Beispiel 2:Einfacher Rechner mit Klassenvorlagen

Dieses Programm verwendet eine Klassenvorlage, um Addition, Subtraktion, Multiplikation und Division zweier Variablen num1 auszuführen und num2 .

Die Variablen können von beliebigem Typ sein, obwohl wir nur int verwendet haben und float Typen in diesem Beispiel.

#include <iostream>
using namespace std;

template <class T>
class Calculator {
   private:
    T num1, num2;

   public:
    Calculator(T n1, T n2) {
        num1 = n1;
        num2 = n2;
    }

    void displayResult() {
        cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
        cout << num1 << " + " << num2 << " = " << add() << endl;
        cout << num1 << " - " << num2 << " = " << subtract() << endl;
        cout << num1 << " * " << num2 << " = " << multiply() << endl;
        cout << num1 << " / " << num2 << " = " << divide() << endl;
    }

    T add() { return num1 + num2; }
    T subtract() { return num1 - num2; }
    T multiply() { return num1 * num2; }
    T divide() { return num1 / num2; }
};

int main() {
    Calculator<int> intCalc(2, 1);
    Calculator<float> floatCalc(2.4, 1.2);

    cout << "Int results:" << endl;
    intCalc.displayResult();

    cout << endl
         << "Float results:" << endl;
    floatCalc.displayResult();

    return 0;
}

Ausgabe

Int results:
Numbers: 2 and 1.
2 + 1 = 3
2 - 1 = 1
2 * 1 = 2
2 / 1 = 2

Float results:
Numbers: 2.4 and 1.2.
2.4 + 1.2 = 3.6
2.4 - 1.2 = 1.2
2.4 * 1.2 = 2.88
2.4 / 1.2 = 2

Im obigen Programm haben wir ein Klassen-Template Calculator deklariert .

Die Klasse enthält zwei private Elemente vom Typ T :num1 &num2 , und einen Konstruktor zum Initialisieren der Member.

Wir haben auch add() , subtract() , multiply() , und divide() Funktionen, die den Rückgabetyp T haben . Wir haben auch einen void Funktion displayResult() die die Ergebnisse der anderen Funktionen ausgibt.

In main() haben wir zwei Objekte von Calculator erstellt :eine für int Datentyp und ein weiterer für float Datentyp.

Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2);

Dies veranlasst den Compiler, während der Kompilierung zwei Klassendefinitionen für die jeweiligen Datentypen zu erstellen.

C++-Klassenvorlagen mit mehreren Parametern

In C++ können wir mehrere Vorlagenparameter und sogar Standardargumente für diese Parameter verwenden. Zum Beispiel

template <class T, class U, class V = int>
class ClassName {
  private:
    T member1;
    U member2;
    V member3;
    ... .. ...
  public:
    ... .. ...
};

Beispiel 3:C++-Vorlagen mit mehreren Parametern

#include <iostream>
using namespace std;

// Class template with multiple and default parameters
template <class T, class U, class V = char>
class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;

   public:
    ClassTemplate(T v1, U v2, V v3) : var1(v1), var2(v2), var3(v3) {}  // constructor

    void printVar() {
        cout << "var1 = " << var1 << endl;
        cout << "var2 = " << var2 << endl;
        cout << "var3 = " << var3 << endl;
    }
};

int main() {
    // create object with int, double and char types
    ClassTemplate<int, double> obj1(7, 7.7, 'c');
    cout << "obj1 values: " << endl;
    obj1.printVar();

    // create object with int, double and bool types
    ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
    cout << "\nobj2 values: " << endl;
    obj2.printVar();

    return 0;
}

Ausgabe

obj1 values: 
var1 = 7
var2 = 7.7
var3 = c

obj2 values: 
var1 = 8.8
var2 = a
var3 = 0

In diesem Programm haben wir eine Klassenvorlage namens ClassTemplate erstellt , mit drei Parametern, von denen einer ein Standardparameter ist.

template <class T, class U, class V = char>
class ClassTemplate {
  // code  
};

Beachten Sie den Code class V = char . Das bedeutet, dass V ist ein Standardparameter, dessen Standardtyp char ist .

Innerhalb von ClassTemplate deklarieren wir 3 Variablen var1 , var2 und var3 , die jeweils einem der Vorlagenparameter entsprechen.

class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;
    ... .. ...
    ... .. ...
};

In main() , erstellen wir zwei Objekte von ClassTemplate mit dem Code

// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');

// create object with double, char and bool types
ClassTemplate<double, char, bool> obj2(8, 8.8, false);

Hier,

Objekt	T	U	V
`obj1`	`int`	`double`	`char`
`obj2`	`double`	`char`	`bool`

Für obj1 , T = int , U = double und V = char .

Für obj2 , T = double , U = char und V = bool .

Virtuelle C++-Funktionen C Schlüsselwörter und Bezeichner

C Sprache