Inhaltsverzeichnis
Vorwort
Durch Vererbung und andere Funktionen in der objektorientierten Programmierung können wir viel Code wiederverwenden, aber in der eigentlichen Programmierung gibt es immer noch viele Stellen, die wiederholt werden müssen.Beispielsweise müssen wir die Funktion Swap implementieren, die die Funktion von hat Austausch.
Wir wollen zwei ganze Zahlen austauschen, also müssen wir schreiben:
void Swap(int&a,int &b)
{
int c=a;
a=b;
b=c;
}
Wenn wir trotzdem zwei Fließkommazahlen austauschen wollen, müssen wir noch eine überladen:
void Swap(float&a,float&b)
{
float c=a;
a=b;
b=c;
}
Wenn wir andere Typen austauschen wollen, müssen wir erneut überladen, jeder Typ muss einmal überladen werden, aber die Struktur der Funktion ist jedes Mal ähnlich, was sehr mühsam ist.
Daher bietet C++ Template- und generische Funktionen.Mit derselben Funktion können nach dem Schreiben eines Templates alle Typen angewendet werden.
Funktionsvorlage
Mit Templates und Generika in C++ können wir schreiben:
//也可以写成template <class T> 在C++98标准添加关键字typename前，都是用的class，C++98之后推荐使用typename关键字
template <typename T>//template关键字声明这是个模板，typename关键字后写入类型名的代称,可以指代任何类型，也就是说T是一种泛型
void Swap(T& a, T& b)//T类型的a，T类型的b
{
T c = a;
a = b;
b = c;
}
Dann kann jeder Typ ausgetauscht werden.
Die Vorlagenfunktion ist eigentlich ein Funktionstyp, keine Funktionsinstanz.Während der Kompilierung instanziiert der Compiler sie in eine Funktionsinstanz des entsprechenden Parametertyps entsprechend dem Typ, den die Vorlagenfunktion verwenden wird.
Vorlagenfunktionen überladen
Vorlagenfunktionen können auch wie folgt überladen werden:
template <typename T>
void Swap(T& a, T& b)//这个交换函数，只能交换单个元素
{
T c = a;
a = b;
b = c;
}
template <typename T>
void Swap(T&a[],T&b[],int n)//让我们重载个两个数组之间的交换函数
{
T c;
for(int i=0;i<n;++i)
{
c=a[i];
a=b[i];
b[i]=c;
}
}
Einschränkungen von Vorlagen
Hier finde ich "C++ Primer Plus" gut, also lass mich direkt einen Screenshot machen. (Ich möchte die Rad-QAQ nicht wiederholen)
explizite Verdinglichung
Die explizite Verdinglichung dient dazu, mit einigen speziellen Typen umzugehen, die von generischen Templates nicht behandelt werden können. Wir können Funktionen dieses speziellen Typs schreiben und sie separat handhaben.
Zum Beispiel haben wir eine neue Struktur geschaffen, um Studenten zu vertreten. Ich möchte nur ihre Namen austauschen. Wenn der Rest nicht ausgetauscht wird, benötigen wir Folgendes:
#include<iostream>
struct Student
{
std::string name;
float score;
};
template <typename T>//template关键字声明这是个模板，typename关键字后写入类型名的代称,可以指代任何类型，也就是说T是一种泛型
void Swap(T& a, T& b)//T类型的a，T类型的b
{
T c = a;
a = b;
b = c;
}
template <>//template这里不能填入泛型
void Swap<Student>(Student& a, Student& b)//显式定义Student的处理办法
{
std::string c = b.name;
b.name = a.name;
a.name = c.name;
}
int main()
{
Student a, b;
a.name = "A";
a.score = 1;
b.name = "B";
b.score = 0;
Swap<Student>(a, b);
std::cout << a.name << " " << a.score << std::endl;
std::cout << b.name << " " << b.score << std::endl;
}
Ausgabeergebnis:
B 1
A 0
implizite Verdinglichung
Wenn Sie die Funktion nicht explizit definieren, sucht der Compiler nach dem am besten passenden Parameter aus der überladenen Vorlage, um die Funktion zu instanziieren. In diesem Tutorial wird nicht im Detail erläutert, welche Gruppe von Funktionen der Compiler basierend auf den Kriterien zur Instanziierung auswählt, weil Dieser Teil des Inhalts ist für Anfänger ausführlicher, also bitte Baidu ...
Klasse Vorlage
Sehen Sie sich direkt die Code-Implementierung an:
#include <iostream>
using namespace std;
template <typename T>//声明模板和泛型名称
class A
{
public:
//函数的参数列表使用模板类型
A(T t = 0)
{
this->t = t;
}
//成员函数返回值使用模板类型
T& getT()
{
return t;
}
private:
//成员变量使用模板类型
T t;
};
int main(void) {
//1.模板类定义类对象，必须显示指定类型
//2.模板种如果使用了构造函数，则遵守以前的类的构造函数的调用规则
A<int> a(211); // 构造函数仅在创建对象时使用 类名<参数类型> 对象名;
A<char> b('a');
cout << a.getT() << endl;
cout << b.getT() << endl;
return 0;
}
Ausgabeergebnis:
211
a
Im obigen Code haben wir zwei Klasseninstanzen erstellt, eine vom Typ int und die andere vom Typ char.
Inhalte erweitern
Neue Funktionen von C++11: Detaillierte Erläuterung von Parametervorlagen mit variabler Länge
Nachschrift
Tatsächlich haben Templates und Generika in C++ immer noch viel esoterischen Inhalt, aber diese Reihe von Tutorials richtet sich an Anfänger, sodass nur die grundlegenden Inhalte behandelt werden.In der eigentlichen C++-Template-Metaprogrammierung gibt es auch Parameter mit variabler Länge und Switch-Zweige , Template-Programmierung realisiert Rekursion, Template-Metaprogrammierung realisiert Heap-Sortierung zur Kompilierzeit usw. Viele Bonzen geben vor, Template-Metaprogrammierung zu verwenden, also ist C++ eine Sprache, von der man nicht sagen kann, dass sie ein Leben lang Schreiben beherrscht, und Templates berücksichtigen zu einem großen Teil der Grund.