Mehrere Typen von C++-Vorlagen
Dieses Tutorial demonstriert die Verwendung von Vorlagen mit mehreren Typen in C++.
Mehrere Typen von C++-Vorlagen
Die Vorlagen in C++ können als Blaupause der Formeln definiert werden, um generische Funktionen und Klassen zu erstellen. Die Vorlagen sind einfache, aber leistungsstarke Werkzeuge in C++, bei denen die Idee darin besteht, den Datentyp an die Parameter zu übergeben, damit wir möglicherweise nicht denselben Code erneut für verschiedene Datentypen schreiben.
Die Vorlagen werden wie Makros zur Kompilierzeit erweitert. Der einzige Unterschied besteht darin, dass der Compiler die Datentypen überprüft, bevor er die Vorlagen erweitert.
Die Vorlagen können so definiert werden, dass der Quellcode nur Klassen oder Funktionen enthält, der Compilercode jedoch mehrere Kopien dieser Klassen oder Funktionen enthält.
Jetzt kann die Vorlage mit mehreren Typen als Mitgliedsvorlage einer Klasse definiert werden, die ebenfalls eine Vorlage ist und außerhalb ihrer Klassenvorlagendefinition definiert ist; Diese Klassendefinition sollte mit den Vorlagenparametern der Klassenvorlage gefolgt von Member-Vorlagenparametern angegeben werden.
In C++ gibt es zwei Arten von Templates.
Funktionsvorlage
Eine Funktionsvorlage kann mit mehreren Datentypen gleichzeitig arbeiten, eine Standardfunktion hingegen nicht. Die Syntax für die Funktionsvorlage ist unten.
template <class DataType>
Returntype FunctionName(parameter list) {
// function body
}
Versuchen wir es mit einem einfachen Beispiel einer Funktionsvorlage.
#include <iostream>
using namespace std;
// This template function will work for all data types/ it will return the
// minimum value from given parameters
template <typename Delftstack>
Delftstack MinValue(Delftstack a, Delftstack b) {
return (a < b) ? a : b;
}
int main() {
cout << MinValue<int>(78, 354) << endl; // Call the template function for int
cout << MinValue<double>(336.23, 4673.23)
<< endl; // Call the template function for double
cout << MinValue<char>('s', 'y')
<< endl; // Call the template function for char
return 0;
}
Das Obige enthält eine Vorlagenfunktion, MinValue, die für alle Datentypen funktioniert und den Mindestwert von gegebenen Werten zurückgibt. Siehe die Ausgabe:
78
336.23
s
Klassenvorlage
Die Klassenvorlage weiß auch, dass die generischen Vorlagen ähnlich wie die Funktionsvorlagen funktionieren. Die Klassenvorlagen definieren eine Familie von Klassen in C++; Die Syntax für die Klassenvorlage ist unten.
template <class Ttype>
class ClassName {
// class body;
}
Lassen Sie uns nun ein Beispiel mit der Klassenvorlage ausprobieren.
#include <iostream>
using namespace std;
template <typename Delftstack>
class DemoArray {
private:
Delftstack* ptr;
int arraysize;
public:
DemoArray(Delftstack arr[], int number);
void print();
};
template <typename Delftstack>
DemoArray<Delftstack>::DemoArray(Delftstack arr[], int number) {
ptr = new Delftstack[number];
arraysize = number;
for (int x = 0; x < arraysize; x++) ptr[x] = arr[x];
}
template <typename Delftstack>
void DemoArray<Delftstack>::print() {
for (int x = 0; x < arraysize; x++) cout << " " << *(ptr + x);
cout << endl;
}
int main() {
int arr[7] = {23, 12, 43, 74, 55, 36, 67};
DemoArray<int> demo(arr, 7);
demo.print();
return 0;
}
Der obige Code erstellt eine Template-Array-Klasse und eine template-Methode, um die Mitglieder eines Arrays auszugeben; Wir haben das Member-Template außerhalb der Klasse template definiert. Siehe die Ausgabe:
23 12 43 74 55 36 67
Klassenvorlage mit mehreren Typen
Ein Klassen-Template mit mehreren Typen bedeutet, dass wir ein Klassen-Template mit mehreren Parametern definieren müssen, was mit C++ möglich ist. Die Syntax zum Definieren einer Klassenvorlage mit mehreren Typen ist unten.
template <class Delft1, class Delft2, class Delft3 = char>
class DemoClassTemplate {
// class body
}
Lassen Sie uns zum Beispiel springen, um die Klassenvorlage mit mehreren Typen zu verstehen.
#include <iostream>
using namespace std;
// Class template containing multiple type parameters
template <class Delft1, class Delft2, class Delft3 = char>
class DemoClassTemplate {
private:
Delft1 value1;
Delft2 value2;
Delft3 value3;
public:
DemoClassTemplate(Delft1 v1, Delft2 v2, Delft3 v3)
: value1(v1), value2(v2), value3(v3) {} // constructor
void printVar() {
cout << "The Value 1 = " << value1 << endl;
cout << "The Value 2 = " << value2 << endl;
cout << "The Value 3 = " << value3 << endl;
}
};
int main() {
// object with int, double and char types using the template class
DemoClassTemplate<int, double> DemoObject1(57, 34.7, 'Delftstack');
cout << "DemoObject 1 Values: " << endl;
DemoObject1.printVar();
// object with int, double and boolean types using the template class
DemoClassTemplate<double, char, bool> DemoObject2(789.8, 'Delft', true);
cout << "\nDemoObject 2 values: " << endl;
DemoObject2.printVar();
return 0;
}
Wie wir sehen können, erstellt der obige Code eine Vorlagenklasse mit mehreren Typparametern, die Standardparameter enthalten. Nun können wir Objekte dieser Vorlagen-Klasse erstellen und beliebige Datentypen verwenden.
Ausgang:
DemoObject 1 Values:
The Value 1 = 57
The Value 2 = 34.7
The Value 3 = k
DemoObject 2 values:
The Value 1 = 789.8
The Value 2 = t
The Value 3 = 1
Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.
LinkedIn Facebook