1. テンプレート

テンプレートは一般的な型を確立するもので、再利用性が大幅に向上します。C++ では、関数テンプレートとクラステンプレートの 2 つのテンプレート機構が提供されます。

1.1 関数テンプレート

関数テンプレートとは、関数の戻り値の型や仮引数の型を特に指定せず、仮想型で表現した汎用関数を作成するものです。

1.1.1 関数テンプレートの構文

// 函数模板利用关键字template
template<Typename T>
// 函数声明或定义

// template -- 声明创建模板
// Typename -- 表明其后的符号是一种数据类型,可以用class代替
// T -- 通用的数据类型,名称可以替换,通常为大写字母

コード例

#include<iostream>
using namespace std;

template<typename T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}

void test()
{
    
    
	int a = 10;
	int b = 20;
	mySwap<int>(a, b);
	cout << "a = " << a　<< endl;
	cout << "b = " << b  << endl;
}

int main()
{
    
    
	test();
	system("pause");
	return 0;
}

1.1.2 関数テンプレートに関する注意事項

関数テンプレートを使用するには、自動型推論と明示的な型割り当ての 2 つの方法があります。

テンプレートを使用する場合、一般的なデータ型 T を決定する必要があり、一貫した型を推定できます。

// 利用模板提供通用的交换函数
template<class T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}

// 1. 自动类型推导.必须推导出一致的数据类型T,才可以使用
void test01()
{
    
    
	int a = 10;
	int b = 20;
	char c = 'c';
	mySwap(a, b); // 正确, 可以推导出一致的T
	// mySwap(a, c); // 错误, 推导不出一致的T类型
}
// 2. 模板必须要确定出T的数据类型才可以使用
template<class T>
void func()
{
    
    
	cout << "func 调用" << endl;
}
void test02()
{
    
    
	// func(); // 错误, 模板不能独立使用,必须确定出T的类型
	func<int>(); // 利用显示指定类型的方式,给T一个类型,才可以使用该模板
}

1.1.3 関数テンプレートの場合

ケースの説明:

関数テンプレートを使用して、さまざまなデータ型の配列を並べ替えることができる並べ替え関数をカプセル化します。
ソートルールは大から小まであり、ソートアルゴリズムは選択ソートです。
char 配列と int 配列をそれぞれ使用してテストする

// 交换的函数模板
template<typename T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a; 
	a = b;
	b = temp;
}

template<class T>
// 利用选择排序,进行数组从大到小排序
void mySort(T arr[], int len)
{
    
    
	for(int i = 0;, i < len; i++)
	{
    
    
		max = i;
		for(int j = i+1; j < len; j++)
		{
    
    
			if(arr[max] < arr[j])
			{
    
    
				max = j;
			}
		}
		if(max != i)
		{
    
    
			mySort(arr[i], arr[max]);  // 如果最大数的下标不是i,交换两者
		}
	}
}

template<typename T>
void printArray(T arr[], int len)
{
    
    
	for(int i = 0; i < len; i++)
	{
    
    
		cout << arr[i] <<" ";
	}
	cout << endl;
}

void test01()
{
    
    
	// 测试char数组
	char charArr[] = "defgabc";
	int num = sizeof(charArr)/sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02()
{
    
    
	// 测试int数组
	int intArr = {
    
    7, 5, 8, 1, 3, 4,, 6, 2}
	int num = sizeof(charArr)/sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

void main()
{
    
    
	system("pause");
	return 0;
}
// h g f e d c b a
// 8 7 6 5 4 3 2 1

1.1.4 通常関数と関数テンプレートの違い

通常の関数と関数テンプレートの違いは次のとおりです。

通常の関数呼び出し時に自動型変換 (暗黙的な型変換) が発生する可能性があります

関数テンプレートが呼び出されたときに、自動型推論が使用されている場合、暗黙的な型変換 (文字列から ASII コードへなど) は発生しません。

明示的な型が使用されている場合、暗黙的な型変換が発生する可能性があります

#include<iostream>
using namespace std;

// 普通函数
int myAdd01(int a , int b) 
{
    
    
	return a + b;
}

// 函数模板
template<class T>
T myAdd02(T a, T b) 
{
    
    
	return a + b;
}

// 使用函数模板时，如果用自动类型推导，不会发生自动类型转换，即隐式类型转换
void test_01()
{
    
    
	int a = 10;
	int b = 20;
	char c = 'c';

	cout << myAdd01(a, c) << endl;       // 正确, 将char类型'c'隐式转换为int类型 ASII码  c -- 99
	// cout << myAdd02(a, c) << endl;    // 报错,使用自动类型推导时,不会发生隐式类型转换 
	cout << myAdd02<int>(a, c) << endl; // 正确，如果用显示指定类型，可以发生隐式类型转换
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}	
// 109
// 109

1.1.5 通常関数および関数テンプレートの呼び出し規則

呼び出しルールは次のとおりです

関数テンプレートと通常の関数の両方を実装できる場合は、通常の関数が最初に呼び出されます。

空のテンプレートパラメータリストを使用して関数テンプレートを強制的に呼び出すことができます

関数テンプレートはオーバーロードすることもできます

関数テンプレートの方がより適切な一致を生成できる場合、関数テンプレートが最初に呼び出されます。

コード例

#include<iostream>;
using namespace std;

// 普通函数与函数模板的调用规则
void myPrint(int a, int b)
{
    
    
	cout << "调用普通函数" << endl;
}

template<typename T>
void myPrint(T a, T b)
{
    
    
	cout << "调用模板" << endl;
}

template<class T>
void myPrint(T a, T b, T c)
{
    
    
	cout << "调用重载的模板" << endl;
}

void test_01() 
{
    
    
	// 1. 如果函数模板和普通函数都能实现，优先调用普通函数
	int a = 10;
	int b = 10;
	myPrint(a, b); // 调用普通函数

	// 2. 可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b);

	// 3. 函数模板也可以发生重载
	int c = 30;
	myPrint(a, b, c);

	// 4. 如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2);
}

int main() 
{
    
     
	test_01();
	system("pause");
	return 0;
}
// 调用普通函数
// 调用模板
// 调用重载的模板
// 调用模板

1.2 クラステンプレート

クラステンプレートの役割: 一般的なクラスを作成する場合、クラス内のメンバーのデータ型を指定することはできず、仮想型を使用して表現することができます。

1.2.1 クラステンプレートの構文

// 类模板和函数模板语法极为相似,在声明模板template后面加类,此类称为类模板
template<typename T>
// 类

コード例

#include<iostream>
using namespace std;
#include <string>

// 类模板
template<class NameType, class AgeType>
class Person
{
    
    
public:
	Person(NameType name, AgeType age)
	{
    
    
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() 
	{
    
    
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

void test_01() 
{
    
    
	// 指定NameType为string 类型 AgeType 为int 类型
	Person<string, int>P1("孙悟空", 999);
	P1.showPerson();
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 999

1.2.2 クラステンプレートと関数テンプレートの違い

クラステンプレートと関数テンプレートの間には、主に 2 つの違いがあります。

米国およびヨーロッパでクラステンプレートの自動型推論を使用する方法

クラステンプレートには、テンプレートパラメータリストにデフォルトパラメータを含めることができます

コード例:

#include<iostream>
using namespace std;
#include<string>

// 类模板和函数模板的区别主要有两点
// 1. 类模板没有自动类型推导的使用方式
// 2. 类模板在模板参数列表众可以有默认参数

// 类模板
template<class NameType, class AgeType=int>
class Person
{
    
    
public:
	Person(NameType name, AgeType age)
	{
    
    
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() 
	{
    
    
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

// 1. 类模板没有自动类型推导的使用方式
void test_01() 
{
    
    
	// Person132 p('孙悟空', 1000); // 错误，类模板使用时，不可以用自动类型推导
	Person132<string, int> p("孙悟空", 1000); // 必须使用显示指定类型的方式，使用类模板
	p.showPerson();
}

// 2. 类模板在模板参数列表中可以有默认参数
void test_02() 
{
    
    
	Person132<string> p2("猪八戒", 999); // 可以制定默认参数
	p2.showPerson();
}
int main()
{
    
    
	test_01();
	test02();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 1000
// name: 猪八戒 age: 999

1.2.3 クラステンプレートでメンバー関数を作成する場合

クラステンプレートのメンバー関数と通常の関数のメンバー関数の作成タイミングには次のような違いがあります。

通常クラスのメンバー関数は最初から作成可能

クラステンプレート内のメンバー関数は、呼び出されたときに作成されます。

コード例:

#include<iostream>
using namespace std;

class Person_01 
{
    
    
public:
	void showPerson_01() 
	{
    
    
		cout << "Person1 show" << endl;
	}
};

class Person_02
{
    
    
public:
	void showPerson_02()
	{
    
    
		cout << "Person2 show" << endl;
	}
};

template<class T>
class MyClass
{
    
    
public:
	T obj;
	// 类模板中的成员函数，并不是一开始就创建，而是在模板调用时在生成
	void fun1() {
    
     obj.showPerson_01(); }
	void fun2() {
    
     obj.showPerson_02(); }
};

void test_01()
{
    
    
	MyClass<Person_01> m;
	m.fun1();
	// m.fun2();  // 编译会出错,说明函数调用才会创建成员函数
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}
// Person1 show

1.2.4 関数パラメータとしてのクラステンプレートオブジェクト

クラステンプレートによってインスタンス化されたオブジェクトの関数にパラメータを渡すには 3 つの方法があります

受信タイプを指定します - オブジェクトのデータタイプを直接表示します

パラメータのテンプレート化 - オブジェクト内のパラメータを渡すためのテンプレートに変換します。

クラス全体をテンプレート化 — このオブジェクトタイプを渡すためにテンプレート化します

コード例:

#include<iostream>
using namespace std;

// 类模板对象做函数参数，共有三种传入方式
// 1. 指定传入的类型  --- 直接显示对象的数据类型
// 2. 参数模板化      --- 将对象中参数变为模板进行传递
// 3. 整个类模板化    --- 将这个对象类型模板化进行传递

// 类模板
template<class NameType, class AgeType = int>
class Person
{
    
    
public:
	Person(NameType name , AgeType age) 
	{
    
    
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() 
	{
    
    
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};


// 1. 传入指定的类型
void printPerson1(Person<string, int> &p) 
{
    
    
	p.showPerson();
}
void test_01() 
{
    
    
	Person<string, int> p("孙悟空", 100);
	printPerson1(p);
}

// 2. 参数模板化
template<class T1, class T2>
void printPerson2(Person<T1 , T2> &p) 
{
    
    
	p.showPerson();
	cout << "T1的类型为： " << typeid(T1).name() << endl;
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test_02() 
{
    
    
	Person<string, int> p("孙悟空", 100);
	printPerson2(p);
}

// 3. 整个类模板化
template<class T>
void printPerson3(T& p) 
{
    
    
	cout << "T的类型为： " << typeid(T).name() << endl;
	p.showPerson();
}
void test_03()
{
    
    
	Person<string, int> p("唐僧", 100);
	printPerson3(p);
}

int main()
{
    
    
	test_01();
	test_02();
	test_03();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 100
// name: 孙悟空 age: 100
// T1的类型为： class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
// T2的类型为： int
// T的类型为： class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
// name: 唐僧 age: 100

1.2.5 クラステンプレートと継承

クラステンプレートで継承が発生した場合は、次の点に注意する必要があります。

親クラスがクラステンプレートの場合、サブクラスは親クラスの T のデータ型を指定する必要があります。

指定しない場合、コンパイラはサブクラスにメモリを割り当てることができません。

親クラスでTの型を柔軟に指定したい場合は、サブクラスもクラステンプレートにする必要があります

コード例:

#include<iostream>
using namespace std;

template<class T>
class Base
{
    
    
	T m;
};

// class Son :public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> // 必须指定一个类型
{
    
    
};

void test_01()
{
    
    
	Son c;
}

// 类模板继承类模板，可以用T2指定父类中T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
    
    
public:
	Son2()
	{
    
    
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
};
void test_02()
{
    
    
	Son2<int, char> c;
}

int main()
{
    
    
	test_01();
	test_02();
	system("pause");
	return 0;
}
// int
// char

1.2.6 クラステンプレートメンバー関数のクラス外実装

クラステンプレートのメンバー関数がクラスの外部で実装される場合、テンプレートパラメーターリストを追加する必要があります

コード例:

#include<iostream>
using namespace std;
#include<string>

// 类模板中成员函数类外实现
template<class T1, class T2>
class Person
{
    
    
public:
	// 成员函数类内声明
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};

// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) 
{
    
    
	this->m_Name = name;
	this->m_Age = age;
}

// 成员函数，类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    
    
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}

void test_01() 
{
    
    
	Person<string, int>p("Tom", 20);
	p.showPerson();
}

int main()
{
    
    
	test_01();
	system("pause");
	return 0;
}
// name: Tom age: 20

1.2.7 クラステンプレートファイルのコンパイル

既存の問題: クラステンプレートでのメンバー関数の作成タイミングが呼び出しフェーズであり、別ファイルを記述するとリンクに失敗する解決策: 解決策 1: .cpp ソースファイルを直接インクルードする解決策 2: .cpp ソースファイルを直接インクルードする解決策 2: .cpp ソースファイルを直接
インクルード
する
同じファイルを作成し、名前を .hpp に変更します。hpp は合意された名前であり、必須ではありません (主流の慣行)

コード例、person.hpp 内のコード:

#pragma once
#include<iostream>
using namespace std;
#include<string>

template<class T1, class T2>
class Person 
{
    
    
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};
// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) 
{
    
    
	this->m_Name = name;
	this->m_Age = age;
}
// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    
    
	cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}

クラステンプレートファイルの.cppのコード記述

#include<iostream>
using namespace std;
// 方案一 包含cpp源文件
// include "person.cpp" // 在person.h中声明, person.cpp中实现
// 方案二 将声明和实现写到一起,文件后缀名改为.hpp
#include "person.hpp"
void test_01() 
{
    
    
	Person<string, int> p("Tom", 10);
	p.showPerson();
}
int main()
{
    
    
	test_01();
	system("pause");
	return 0;
}
// 姓名： Tom 年龄： 10

1.2.8 クラステンプレートと友達

グローバル関数はクラス内に実装されます - クラス内で直接フレンドを宣言するだけです
グローバル関数はクラスの外に実装されます - コンパイラはグローバル関数の存在を事前に知る必要があります

コード例:

#include<iostream>
using namespace std;
#include<string>

// 全局函数类内实现 - 直接在类内声明友元即可
// 全局函数类外实现 - 需要提前让编译器知道全局函数的存在
template<class T1, class T2> class Person138;

template<class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{
    
    
	cout << "类外实现 --- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    
    
	// 1. 全局函数配合友元  类内实现
	friend void printPerson(Person<T1, T2> &p)
	{
    
    
		cout << " 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
	}
	// 2. 全局函数配合友元 类外实现
	// 需要加空模板参数列表
	// 类外实现需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2>& p);

public:
	Person(T1 name, T2 age)
	{
    
    
		this->m_Name = name;
		this->m_Age = age;
	};
public:
	T1 m_Name;
	T2 m_Age;
};

// 1. 全局函数在类内实现
void test_01()
{
    
    
	Person<string, int> p("Tom", 20);
	printPerson(p);
}

// 2. 全局函数在类外实现
void test_02()
{
    
    
	Person<string, int> p("Jerry", 30);
	printPerson2(p);
}

int  main()
{
    
    
	test_01();
	test_02();
	system("pause");
	return 0;
}
//  姓名： Tom 年龄：20
//  类外实现 --- 姓名： Jerry 年龄：30

地図

ここに画像の説明を挿入

3.1 C++ テンプレート

1. テンプレート

1.1 関数テンプレート

1.1.1 関数テンプレートの構文

1.1.2 関数テンプレートに関する注意事項

1.1.3 関数テンプレートの場合

1.1.4 通常関数と関数テンプレートの違い

1.1.5 通常関数および関数テンプレートの呼び出し規則

1.2 クラステンプレート

1.2.1 クラステンプレートの構文

1.2.2 クラステンプレートと関数テンプレートの違い

1.2.3 クラステンプレートでメンバー関数を作成する場合

1.2.4 関数パラメータとしてのクラステンプレートオブジェクト

1.2.5 クラステンプレートと継承

1.2.6 クラステンプレートメンバー関数のクラス外実装

1.2.7 クラステンプレートファイルのコンパイル

1.2.8 クラステンプレートと友達

地図

おすすめ

3.1 C++ テンプレート

1. テンプレート

1.1 関数テンプレート

1.1.1 関数テンプレートの構文

1.1.2 関数テンプレートに関する注意事項

1.1.3 関数テンプレートの場合

1.1.4 通常関数と関数テンプレートの違い

1.1.5 通常関数および関数テンプレートの呼び出し規則

1.2 クラステンプレート

1.2.1 クラステンプレートの構文

1.2.2 クラステンプレートと関数テンプレートの違い

1.2.3 クラス テンプレートでメンバー関数を作成する場合

1.2.4 関数パラメータとしてのクラステンプレートオブジェクト

1.2.5 クラステンプレートと継承

1.2.6 クラステンプレートメンバー関数のクラス外実装

1.2.7 クラステンプレートファイルのコンパイル

1.2.8 クラステンプレートと友達

地図

おすすめ

1.2.3 クラステンプレートでメンバー関数を作成する場合