Schablonen sind eine Eigenschaft des C ++ Programmiersprache, die Funktionen und Klassen erlauben, mit allgemeinen Typen zu funktionieren. Das erlaubt einer Funktion oder Klasse, an vielen verschiedenen Datentypen zu arbeiten, ohne für jeden umgeschrieben zu werden.

Schablonen sind vom großen Dienstprogramm Programmierern in C ++, besonders wenn verbunden, mit der Mehrfachvererbung und dem Maschinenbediener, der überlädt. Der C ++ Standardbibliothek stellt viele nützliche Funktionen innerhalb eines Fachwerks von verbundenen Schablonen zur Verfügung.

Hauptinspirationen für C ++ Schablonen waren die parametrisierten Module, die durch CLU und den von Ada zur Verfügung gestellten generics zur Verfügung gestellt sind.

Technische Übersicht

Es gibt zwei Arten von Schablonen: Funktionsschablonen und Klassenschablonen.

Funktionsschablonen

Eine Funktionsschablone benimmt sich wie eine Funktion, außer dass die Schablone Argumente von vielen verschiedenen Typen haben kann (sieh Beispiel). Mit anderen Worten vertritt eine Funktionsschablone eine Familie von Funktionen.

Das Format, um Funktionsschablonen mit Typ-Rahmen zu erklären, ist

Schablone

Schablone </Quelle>

Beide Ausdrücke haben genau dieselbe Bedeutung und benehmen sich genau derselbe Weg.

Zum Beispiel der C ++ enthält Standardbibliothek die Funktionsschablone, die entweder x oder y zurückgibt, welch auch immer größer ist. konnte wie das mit der folgenden Schablone definiert werden:

Schablone

Typ max (Typ a, Typ b) {\

geben Sie a> b zurück? a: b;

}\</Quelle>

Diese einzelne Funktionsdefinition arbeitet mit verschiedenen Arten von Datentypen. Eine Funktionsschablone besetzt Raum im Gedächtnis nicht. Die wirklichen Definitionen einer Funktionsschablone werden während der Übersetzung erzeugt, als der Bearbeiter das bestimmt hat, welche Typen die Funktion verlangt wird. Die Funktionsschablone spart Gedächtnis nicht.

1. einschließen

int Hauptsache

{\

//Das wird max nennen

std:: cout

std:: cout std:: cout

In den ersten zwei Fällen wird das Schablone-Argument T durch den Bearbeiter automatisch abgeleitet, um zu sein, und beziehungsweise. Im dritten Fall scheitert Abzug, weil der Typ der Rahmen im allgemeinen Match die Schablone-Argumente genau muss. Diese Funktionsschablone kann mit jedem Typ der Kopie-constructible für der der Ausdruck realisiert werden (y

</bezüglich> Der C ++ enthält Standardbibliothek viele Klassenschablonen, insbesondere die Behälter, die von der Standardschablone-Bibliothek, solcher als angepasst sind.

Ausführliche Schablone-Spezialisierung

Wenn eine Funktion oder Klasse von einer Schablone realisiert werden, wird eine Spezialisierung dieser Schablone durch den Bearbeiter für den Satz von Argumenten verwendet geschaffen (und die Spezialisierung wird genannt eine erzeugte Spezialisierung zu sein). Jedoch kann sich der Programmierer dafür entscheiden, eine spezielle Version einer Funktion (oder Klasse) für einen gegebenen Satz von Schablone-Argumenten durchzuführen, der eine ausführliche Spezialisierung genannt wird. Wenn eine Klassenschablone durch eine Teilmenge seiner Rahmen spezialisiert wird, wird es teilweise Schablone-Spezialisierung genannt. Wenn alle Rahmen spezialisiert werden, ist es eine volle Spezialisierung. Funktionsschablonen können nicht teilweise spezialisiert werden.

Ausführliche Spezialisierung wird verwendet, wenn das Verhalten einer Funktion oder Klasse für besondere Wahlen der Schablone-Rahmen vom allgemeinen Verhalten abgehen muss: D. h. aus dem Code, der durch die Hauptschablone oder Schablonen erzeugt ist.

Vorteile und Nachteile

Etwas Gebrauch von Schablonen, wie die Funktion, wurde vorher durch funktionsähnliche Vorverarbeiter-Makros erfüllt. Zum Beispiel ist der folgende ein C ++ Makro-:

#define Maximum (a, b) ((a)

Sowohl Makros als auch Schablonen werden während der Übersetzung ausgebreitet. Makros werden immer Reihen-ausgebreitet, wohingegen Schablonen nur Reihen-ausgebreitet werden, wenn der Bearbeiter es für passend hält. Wenn ausgebreitet, haben Reihen-, Makrofunktionen und Schablone-Funktionen keine fremde Durchlaufzeit oben. Schablone-Funktionen mit vielen Linien des Codes werden Durchlaufzeit oben übernehmen, wenn sie Reihen-nicht ausgebreitet werden, aber die Verminderung der Codegröße kann dem Code helfen, von der Platte schneller und/oder passend innerhalb von geheimen RAM-Lagern zu laden.

Schablonen werden "vor dem Typ sicher" betrachtet, d. h. sie verlangen Datentypprüfung während der Übersetzung. Folglich kann der Bearbeiter während der Übersetzung bestimmen, ob der mit einer Schablone-Definition vereinigte Typ alle durch diese Schablone-Definition erforderlichen Funktionen durchführen kann.

Durch das Design können Schablonen in sehr komplizierten Problem-Räumen verwertet werden, wohingegen Makros wesentlich mehr beschränkt werden.

Es gibt grundsätzliche Nachteile zum Gebrauch von Schablonen:

1. Historisch haben einige Bearbeiter schlechte Unterstützung für Schablonen ausgestellt. Also, der Gebrauch von Schablonen konnte Codebeweglichkeit vermindern.
2. Viele Bearbeiter haben an klaren Instruktionen Mangel, wenn sie einen Schablone-Definitionsfehler entdecken. Das kann die Anstrengung von sich entwickelnden Schablonen vergrößern, und hat die Entwicklung von Konzepten für die mögliche Einschließung in eine Zukunft C ++ Standard veranlasst.
3. Da der Bearbeiter zusätzlichen Code für jeden Schablone-Typ erzeugt, kann der unterschiedslose Gebrauch von Schablonen führen, um bloat zu codieren, auf größeren executables hinauslaufend.
4. Weil eine Schablone durch seine Natur seine Durchführung ausstellt, kann der unkluge Gebrauch in großen Systemen länger führen bauen Zeiten.
5. Es kann schwierig sein, bei Code die Fehler zu beseitigen, der mit Schablonen entwickelt wird. Da der Bearbeiter die Schablonen ersetzt, wird es schwierig für das Testhilfeprogramm, den Code an der Durchlaufzeit ausfindig zu machen.
6. Schablonen von Schablonen (Nisten) werden durch alle Bearbeiter nicht unterstützt, oder könnten ein max nistendes Niveau haben.
7. Schablonen sind in den Kopfbällen, die verlangen, dass ein ganzer von allen Projektstücken wieder aufbaut, wenn Änderungen vorgenommen werden.
8. Keine Informationsverheimlichung. Der ganze Code wird in der Kopfball-Datei ausgestellt. Keine Bibliothek kann allein den Code enthalten.

Zusätzlich ist der Gebrauch "weniger - als" und "größer - als" Zeichen als Begrenzungszeichen für Werkzeuge problematisch (wie Textaufbereiter), die Quellcode syntaktisch analysieren. Es ist schwierig, oder vielleicht für solche Werkzeuge unmöglich, um zu bestimmen, ob ein Gebrauch dieser Jetons als Vergleich-Maschinenbediener oder Schablone-Begrenzungszeichen ist. Zum Beispiel, diese Linie des Codes:

foo (a

</Quelle>

kann ein Funktionsanruf mit zwei Rahmen, jeder das Ergebnis eines Vergleich-Ausdrucks sein. Wechselweise konnte es eine Behauptung eines Konstrukteurs für die Klasse sein, die einen Parameter nimmt, "", wessen Typ das parametrisierte ist"

Allgemeine Programmierung zeigt auf anderen Sprachen

Am Anfang wurde das Konzept von Schablonen in einige Sprachen, wie Java und C# 1.0 nicht eingeschlossen. Javas Adoption von generics ahmt das Verhalten von Schablonen nach, aber ist technisch verschieden. C# hat generics (parametrisierte Typen) in.NET 2.0 hinzugefügt. Die generics in Ada datieren C ++ Schablonen zurück.

Obwohl C ++ Schablonen, Java generics und.NET generics häufig ähnlich betrachtet werden, generics ahmen nur das grundlegende Verhalten von C ++ Schablonen nach. Einige der fortgeschrittenen Schablone-Eigenschaften, die von Bibliotheken wie Zunahme und STLSoft und Durchführungen des STL selbst, für die Schablone metaprogramming (ausführliche oder teilweise Spezialisierung, Verzug-Schablone-Argumente, Schablone-Nichttyp-Argumente, Schablone-Schablone-Argumente...) verwertet sind, sind mit generics nicht verfügbar.

Die D Programmiersprache versucht, auf C ++ das neu Entwerfen eines besseren Schablone-Systems zu bauen. Eine bedeutende Hinzufügung ist die Einschließung der Behauptung, die bedingte Kompilation des Codes erlaubt, der auf jeder Information gestützt ist, bekannt während der Übersetzung. Zum Beispiel:

Schablone Factorial (ulong n)

{\

statisch wenn (n

Bemerken Sie auch, dass die Begrenzungszeichen aber nicht verwendet werden

Andere bedeutende Eigenschaften schließen typesafe variadic Schablone-Funktionen ein.

T [0] max (T...) (T args) {\

statisch behaupten (args.length> 1, "Ungenügende Argumente.");

//T [0] ist der Typ des ersten Arguments,

//args [0] ist das erste Argument.

T [0] max = args [0];

//Tupel kann wiederholt und wie eine Reihe aufgeschnitten werden.

foreach (arg; args [1.. $])

wenn (arg> max)

max = arg;

geben Sie max zurück;

} </Quelle>

Diese Funktion wird für jede Zahl von Argumenten, mit der Wiederholung über das Tupel von Argumenten ausgebreitet während der Übersetzung arbeiten.

D Schablonen erlauben eine einfache Form von Einschränkungen auch. Sie können als ein willkürlich kompliziertes Prädikat ausgedrückt werden, das während der Übersetzung bewerten muss. Wenn es wahr ist, dass die Schablone ein Match für die Argumente ist, sonst wird die Schablone während des Überlastungszusammenbringens ignoriert.

Schablone Foo (interne Nummer N) wenn (N & 1) {...}//Ein

Schablone Foo (interne Nummer N) wenn (! (N & 1)) {...}//B

Foo! (3)//Realisiert Einen

Foo! (64)//Realisiert B

Schablone-Bar (T) wenn (isFloatingPoint! T) {... }\

Bar! (3.5)//Realisiert Bar

Bar! (3)//Fehlt </Quelle>

Etwas Ähnliches kann in C ++ mit der Zunahme enable_if getan werden.

In C ++ Schablonen werden die Übersetzungszeit-Fälle durch das Muster durchgeführt, das über die Schablone-Argumente zusammenpasst, so wird der Grundfall der Schablone von Factorial durch das Zusammenbringen 0 aber nicht mit einem Ungleichheitstest durchgeführt, der nicht verfügbar ist:

//Induktion

Schablone

statischer const int Wert = N * Factorial

};

//Grundfall über die Schablone-Spezialisierung:

Schablone

struct Factorial

statischer const int Wert = 1;

};</Quelle>

Mit diesen Definitionen, man kann rechnen, 6 sagen! während der Übersetzung das Verwenden des Ausdrucks

Siehe auch

• Schablone metaprogramming
• Metaprogramming
• Allgemeine Programmierung