Menü

Vorlagen in C ++ mit Beispielen

templates c with examples

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Lernen Sie die verschiedenen Aspekte von Vorlagen in C ++ kennen.

Vorlagen sind eine der leistungsstärksten Funktionen in C ++. Vorlagen liefern uns den Code, der vom Datentyp unabhängig ist.

Mit anderen Worten, mithilfe von Vorlagen können wir einen generischen Code schreiben, der für jeden Datentyp funktioniert. Wir müssen nur den Datentyp als Parameter übergeben. Dieser Parameter, der den Datentyp übergibt, wird auch als Typname bezeichnet.

In diesem Tutorial werden wir uns ausführlich mit Vorlagen und ihren verschiedenen Aspekten befassen.

=> Klicken Sie hier für die Absolute C ++ - Schulungsserie.

Vorlagen in C ++

Was du lernen wirst:

Was sind Vorlagen?

Wie oben erwähnt, sind Vorlagen generisch, d. H. Unabhängig vom Datentyp. Vorlagen werden hauptsächlich verwendet, um die Wiederverwendbarkeit und Flexibilität des Codes der Programme sicherzustellen. Wir können einfach eine einfache Funktion oder eine Klasse erstellen, die den Datentyp als Parameter verwendet, und den Code implementieren, der für jeden Datentyp funktioniert.

Zum Beispiel, Wenn ein Sortieralgorithmus für alle numerischen Datentypen sowie für Zeichenfolgen funktionieren soll, schreiben wir einfach eine Funktion, die den Datentyp als Argument verwendet, und implementieren die Sortiertechnik.

Abhängig vom Datentyp (Typname), der an den Sortieralgorithmus übergeben wird, können die Daten dann unabhängig vom Datentyp sortiert werden. Auf diese Weise müssen wir nicht zehn Algorithmen für zehn Datentypen schreiben.

Somit können Vorlagen in Anwendungen verwendet werden, in denen der Code für mehr als einen Datentyp verwendet werden muss. Vorlagen werden auch in Anwendungen verwendet, in denen die Wiederverwendbarkeit von Code von größter Bedeutung ist.

Wie verwende ich Vorlagen / Implementierung?

Vorlagen können auf zwei Arten implementiert werden:

  • Als Funktionsvorlage
  • Als Klassenvorlage

Funktionsvorlage

Die Funktionsvorlage ist wie eine normale Funktion, der einzige Unterschied besteht jedoch darin, dass die normale Funktion nur für einen Datentyp und ein Funktionsvorlagencode für mehrere Datentypen verwendet werden kann.

Während wir eine normale Funktion tatsächlich überladen können, um mit verschiedenen Datentypen zu arbeiten, sind Funktionsvorlagen immer nützlicher, da wir das einzige Programm schreiben müssen und es mit allen Datentypen arbeiten kann.

Als nächstes sehen wir die Implementierung von Funktionsvorlagen.

Die allgemeine Syntax der Funktionsvorlage lautet:

template T function_name(T args){ …… //function body }

Hier ist T das Vorlagenargument, das verschiedene Datentypen akzeptiert, und class ist ein Schlüsselwort. Anstelle der Schlüsselwortklasse können wir auch 'Typname' schreiben.

Wenn ein bestimmter Datentyp an Funktionsname übergeben wird, erstellt der Compiler eine Kopie dieser Funktion, wobei dieser Datentyp als Argument und Funktion ausgeführt wird.

Sehen wir uns ein Beispiel an, um Funktionsvorlagen besser zu verstehen.

#include using namespace std; template void func_swap(T &arg1, T &arg2) { T temp; temp = arg1; arg1 = arg2; arg2 = temp; } int main() { int num1 = 10, num2 = 20; double d1 = 100.53, d2 = 435.54; char ch1 = 'A', ch2 = 'Z'; cout << 'Original data '; cout << 'num1 = ' << num1 << ' num2 = ' << num2<

In der Hauptfunktion definieren wir Daten vom Typ int, double und char. Wir rufen die Funktion func_swap für jeden Datentyp auf. Dann zeigen wir die ausgetauschten Daten für jeden Datentyp an.

Dies zeigt also, dass wir nicht drei Funktionen für drei Datentypen schreiben müssen. Es reicht aus, nur eine Funktion zu schreiben und macht sie zu einer Vorlagenfunktion, damit sie vom Datentyp unabhängig ist.

Klassenvorlagen

Wie in Funktionsvorlagen müssen wir möglicherweise eine Klasse haben, die allen anderen Aspekten ähnlich ist, aber nur unterschiedliche Datentypen.

In dieser Situation können unterschiedliche Klassen für unterschiedliche Datentypen oder unterschiedliche Implementierungen für unterschiedliche Datentypen in derselben Klasse vorhanden sein. Dadurch wird unser Code jedoch sperrig.

Die beste Lösung hierfür ist die Verwendung einer Vorlagenklasse. Die Vorlagenklasse verhält sich auch ähnlich wie Funktionsvorlagen. Wir müssen den Datentyp als Parameter an die Klasse übergeben, während wir Objekte erstellen oder Elementfunktionen aufrufen.

Die allgemeine Syntax für die Klassenvorlage lautet:

template class className{ ….. public: T memVar; T memFunction(T args); };

In der obigen Definition fungiert T als Platzhalter für den Datentyp. MemVar und memFunction der öffentlichen Mitglieder verwenden T auch als Platzhalter für Datentypen.

Sobald eine Vorlagenklasse wie oben definiert ist, können wir Klassenobjekte wie folgt erstellen:

className classObejct1; className classObject2; className classObject3;

Lassen Sie uns ein Codebeispiel implementieren, um Klassenvorlagen zu demonstrieren:

#include using namespace std; template class myclass { T a, b; public: myclass (T first, T second) {a=first; b=second;} T getMaxval (); }; template T myclass::getMaxval () { return (a>b? a : b); } int main () { myclass myobject (100, 75); cout<<'Maximum of 100 and 75 = '<

Das obige Programm implementiert ein Beispiel für eine Klassenvorlage. Wir haben die Vorlagenklasse myclass. Darin befindet sich ein Konstruktor, der die beiden Mitglieder a und b der Klasse initialisiert. Es gibt eine weitere Mitgliedsfunktion getMaxval, die ebenfalls eine Funktionsvorlage ist, die maximal a und b zurückgibt.

In der Hauptfunktion konstruieren wir zwei Objekte, mein Objekt vom Typ Ganzzahl und mein Objekt vom Typ Zeichen. Dann rufen wir die Funktion getMaxval für jedes dieser Objekte auf, um den Maximalwert zu bestimmen.

Beachten Sie, dass Vorlagenfunktionen neben Vorlagentypparametern (Parameter vom Typ T) auch normale Parameter wie normale Funktionen und Standardparameterwerte haben können.

Typname Vs. Klassenschlüsselwort

Beim Deklarieren der Vorlagenklasse oder -funktion verwenden wir eines der beiden Schlüsselwörter Klasse oder Typname. Diese beiden Wörter sind semantisch äquivalent und können austauschbar verwendet werden.

wie man DVD kostenlos rippt

In einigen Fällen können wir diese Wörter jedoch nicht als äquivalent verwenden. Zum Beispiel, Wenn wir abhängige Datentypen in Vorlagen wie 'typedef' verwenden, verwenden wir den Typnamen anstelle der Klasse.

Außerdem muss das Schlüsselwort class verwendet werden, wenn eine Vorlage explizit instanziiert werden muss.

Instanziierung und Spezialisierung von Vorlagen

Die Vorlagen sind generisch geschrieben. Dies bedeutet, dass es sich um eine allgemeine Implementierung handelt, unabhängig vom Datentyp. Gemäß dem angegebenen Datentyp müssen wir für jeden Datentyp eine konkrete Klasse generieren.

Zum Beispiel, Wenn wir einen Algorithmus zum Sortieren von Vorlagen haben, können wir eine konkrete Klasse zum Sortieren, eine andere Klasse zum Sortieren usw. generieren. Dies wird als Instanziierung der Vorlage bezeichnet.

Wir ersetzen die Vorlagenparameter in der Definition der Vorlagenklasse durch die Vorlagenargumente (tatsächliche Datentypen).

Zum Beispiel,

template class sort {};

Wenn wir den Datentyp übergeben, ersetzt der Compiler den Datentyp durch 'T', sodass der Sortieralgorithmus sortiert wird.

Jedes Mal, wenn wir eine Vorlagenklasse oder -funktion verwenden, ist eine Instanz erforderlich, wenn wir einen bestimmten Datentyp übergeben. Wenn diese Instanz noch nicht vorhanden ist, erstellt der Compiler eine Instanz mit dem jeweiligen Datentyp. Dies ist die implizite Instanziierung.

Ein Nachteil der impliziten Instanziierung besteht darin, dass der Compiler nur für die derzeit verwendeten Argumente eine Instanzklasse generiert. Das heißt, wenn wir vor der Verwendung dieser Instanzen eine Instanzbibliothek generieren möchten, müssen wir eine explizite Instanziierung durchführen.

Ein Beispiel für eine Vorlagendeklaration ist unten angegeben:

template class Array(T)

Kann explizit instanziiert werden als:

template class Array

Wenn eine Klasse instanziiert wird, werden auch alle ihre Mitglieder instanziiert.

Vorlagenspezialisierung

Während der Programmierung mit Vorlagen kann es vorkommen, dass wir eine spezielle Implementierung für einen bestimmten Datentyp benötigen. In einem solchen Fall streben wir eine Vorlagenspezialisierung an.

In der Vorlagenspezialisierung implementieren wir ein spezielles Verhalten für einen bestimmten Datentyp, abgesehen von der ursprünglichen Vorlagendefinition für die anderen Datentypen.

Zum Beispiel, Betrachten wir eine Vorlagenklasse. myIncrement ’ Das hat einen Konstruktor zum Initialisieren eines Werts und eine Vorlagenfunktion inkrementieren das erhöht den Wert um 1.

Diese bestimmte Klasse funktioniert perfekt für alle Datentypen außer char. Anstatt den Wert für char zu erhöhen, geben Sie ihm ein spezielles Verhalten und konvertieren Sie das Zeichen stattdessen in Großbuchstaben.

Zu diesem Zweck können wir eine Vorlagenspezialisierung für den Datentyp char durchführen.

Diese Implementierung wird im folgenden Codebeispiel gezeigt.

#include using namespace std; // class template: template class myIncrement { T value; public: myIncrement (T arg) {value=arg;} T toIncrement () {return ++value;} }; // class template specialization: template class myIncrement { char value; public: myIncrement (char arg) {value=arg;} char uppercase () { if ((value>='a')&&(value<='z')) value+='A'-'a'; return value; } }; int main () { myIncrement myint (7); myIncrement mychar ('s'); myIncrement mydouble(11.0); cout<<'Incremented int value: '<< myint.toIncrement()<< endl; cout<<'Uppercase value: '<

Ausgabe:

Inkrementierter int-Wert: 8
Großbuchstabenwert: S.
Inkrementierter Doppelwert: 12

template_specialization

In dem obigen Programm, das die Spezialisierung von Vorlagen demonstriert, sehen Sie, wie wir eine spezielle Vorlage für den Char-Typ deklariert haben. Wir deklarieren zuerst die ursprüngliche Klasse und spezialisieren sie dann auf den Char-Typ. Um mit der Spezialisierung zu beginnen, verwenden wir die leere Vorlagendeklaration „Vorlage“.

Dann fügen wir nach dem Klassennamen den Datentyp ein. Nach diesen beiden Änderungen wird die Klasse für den Zeichentyp geschrieben.

Beachten Sie in der Hauptfunktion, dass es keinen Unterschied zwischen der Instanziierung des Zeichentyps und anderen Typen gibt. Der einzige Unterschied besteht darin, dass wir die Fachklasse neu definieren.

Beachten Sie, dass wir alle Mitglieder der spezialisierten Klasse definieren müssen, obwohl sie in der generischen / ursprünglichen Vorlagenklasse genau gleich sind. Dies liegt daran, dass wir keine Vererbungsfunktion für Mitglieder von der generischen Vorlage zur spezialisierten Vorlage haben.

Variable C ++ - Vorlagen

Bisher haben wir Funktionsvorlagen gesehen, die eine feste Anzahl von Argumenten annehmen. Es gibt auch Vorlagen, die eine variable Anzahl von Argumenten annehmen. Diese Funktionsvorlagen werden als variadische Vorlagen bezeichnet. Variadische Vorlagen sind eine der neuesten Funktionen von C ++ 11.

wie man die SQL-Injektion manuell testet

Variadische Vorlagen verwenden eine variable Anzahl von Argumenten, die typsicher sind, und die Argumente werden zur Kompilierungszeit aufgelöst.

Nehmen wir ein vollständiges Programmierbeispiel, um dies zu verstehen.

#include #include using namespace std; template T summation(T val) { return val; } template T summation(T first, Args... args) { return first + summation(args...); } int main() { long sum = summation(1, 2, 3, 8, 7); cout<<'Sum of long numbers = '<

Das obige Beispiel zeigt die Variadikfunktion „Summation“. Wie oben gezeigt, benötigen wir zuerst eine Basisfunktion, die den Basisfall implementiert. Dann implementieren wir die Variadic-Funktion über dieser Funktion.

In der Variablenfunktionssummierung wird 'typename ... args' aufgerufen Vorlagenparameterpaket wohingegen 'Args ... args' genannt wird Funktionsparameterpaket .

Nachdem wir eine Funktionsvorlage geschrieben haben, die den Basisfall implementiert, schreiben wir eine variable Funktion, die den allgemeinen Fall implementiert. Die Variadic-Funktion ist ähnlich wie die für die Summierung gezeigte Rekursion geschrieben (Argumente…). Das erste Argument wird vom Funktionsparameterpaket in Typ T (first) getrennt.

Mit jedem Aufruf der Summierung wird die Parameterliste um ein Argument enger und schließlich wird die Grundbedingung erreicht. Die Ausgabe zeigt die Summe für lange Ganzzahlen und Zeichen.

Fazit

Damit schließen wir dieses Tutorial zu Vorlagen in C ++ ab. Vorlagen helfen uns, unsere Programme generisch zu gestalten, d. H. Typunabhängig.

Lesen Sie auch = >> Flask Template Tutorial

Generische Programme stehen immer über den anderen Programmen, da wir nicht für jeden Datentyp separate Programme schreiben müssen. Daher kann die Entwicklung generischer typsicherer Programme ein wichtiger Schritt in Richtung einer effizienten Programmierung sein.

=> Lesen Sie hier die ausführlichen C ++ - Schulungsanleitungen.

Literatur-Empfehlungen

^