C++笔记--模板

最近在复习C++的基础知识，这一节主要是模板，模板是自动生成新类型的一种机制，也是泛型编程的基础，模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如向量，我们可以定义许多不同类型的向量，比如 vector 或 vector 。

1 函数模板基本使用:

1.1 template 告诉编译器1紧跟的代码出现T不要报错。

1.2 mySwap(T &a,T &b) 类型也需要传入，类型参数化

1.3 myswap(a,b)自动类型推导按照a b的类型来替换 T

1.4 myswap(a,b) 显示指定类型

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

//交换int类型两个数字
void mySwapInt( int & a, int & b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

//交换double数据
void mySwapDouble(double &a, double &b)
{
	double tmp = a;
	a = b;
	b = tmp;
}

//类型，逻辑又非常相似
//类型参数化  泛型编程 -- 模板技术
template // 告诉编译器 下面如果出现T不要报错，T是一个通用的类型
void mySwap(T &a, T &b)
{
	T tmp = a;
	a = b; 
	b = tmp;
}
// template  等价于 template
template
void mySwap2(){}

void test01()
{
	int a = 10;
	int b = 20;
	char c1 = 'c';
//	mySwapInt(a, b);
	//1 自动类型推导,必须有参数类型才可以推导
	//mySwap(a, c1); 推导不出来T，所以不能运行
	mySwap(a, b);
	//2 显示指定类型
	mySwap(a, b);
	//模板必须要指定出T才可以使用
	mySwap2();
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	double c = 3.14;
	double d = 1.1;
	//mySwapDouble(c, d);
	mySwap(c, d);
}

int main(){
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

2 函数模板与普通函数的区别以及调用规则

2.1 区别普通函数可以进行隐式类型转换模板不可以

2.2 调用规则

2.2.1 c++编译器优先考虑普通函数

2.2.2 可以通过空模板实参列表的语法限定编译器只能通过模板匹配

2.2.3 函数模板可以像普通函数那样可以被重载

2.2.4 如果函数模板可以产生一个更好的匹配，那么选择模板

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
//1 普通函数与函数模板区别
template
T myPlus(T a, T b)
{
	return a + b;
}

int myPlus2(int a, int b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c'; // a = 97 
//	myPlus(a, c); //类型推导不出来 ,函数模板不可以进行隐式类型转换
	cout << myPlus2(a, c) <
void myPrint(T a ,T b)
{
	cout << "模板调用的myPrint" << endl;
}

template
void myPrint(T a, T b ,T c)
{
	cout << "模板调用的myPrint(a,b,c)" << endl;
}
通过模板生成的函数  叫模板函数
//void myPrint(int a, int b, int c)
//{
//
//}

void myPrint(int a, int  b)
{
	cout << "普通函数调用 myPrint" << endl;
}

void test02()
{
	int a = 10;
	int b = 20;
	//1 、如果出现重载  优先使用普通函数调用,如果没有实现，出现错误
	//myPrint(a, b);
	//2、 如果想强制调用模板 ，那么可以使用空参数列表
	myPrint<>(a, b);
	//3、 函数模板可以发生重载
	int c = 30;
	myPrint(a, b, c);
	//4、 如果函数模板可以产生更好的匹配，那么优先调用函数模板
	char c1 = 'c';
	char d = 'd';
	myPrint(c1, d);

}
int main(){
	//test01();
	test02();
    system("pause");
	return EXIT_SUCCESS;
}

2.3 模板的机制

2.3.1 模板不是万能的，不能通用所有的数据类型

2.3.2 模板不能直接调用，生成后的模板函数才可以调用

2.3.3二次编译，第一次对模板进行编译，第二次对替换T类型后编译

3 模板的局限性

3.1 模板不能解决所有的类型

3.2 如果出现不能解决的类型，可以通过第三具体化来解决问题。

3.3 template<>返回值函数名<具体类型>(参数)

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

//对char和int数组进行排序  排序规则 从大到小  利用选择排序
template 
void mySwap( T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
template
void mySort( T arr[], int len )
{
	for (int i = 0; i < len;i++)
	{
		int max = i;
		for (int j = i + 1; j < len;j++)
		{
			if (arr[max] < arr[j])
			{
				//交换 下标
				max = j;
			}
		}
		if (max != i)
		{
			//交换数据
			mySwap(arr[max], arr[i]);
		}
	}
}

//输出数组元素的模板
template
void printArray( T arr[], int len)
{
	for (int i = 0; i < len;i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

void test01()
{
	char charArr[] = "helloworld";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
	int intArr[] = { 1, 4, 100, 34, 55 };
	int num2 = sizeof(intArr) / sizeof (int);
	mySort(intArr, num2);
	printArray(intArr, num2);

}
int main(){
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

局限性:

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

template
bool myCompare( T &a , T &b )
{
	if ( a == b)
	{
		return true;
	}
	return false;
}

// 通过第三代具体化自定义数据类型，解决上述问题
// 如果具体化能够优先匹配，那么就选择具体化
// 语法  template<> 返回值  函数名<具体类型>(参数) 
template<> bool myCompare(Person &a, Person &b)
{
	if ( a.m_Age  == b.m_Age)
	{
		return true;
	}
	return false;
}

void test01()
{
	int a = 10;
	int b = 20;
	int ret = myCompare(a, b);
	cout << "ret = " << ret << endl;
	Person p1("Tom", 10);
	Person p2("Jerry", 10);
	int ret2 = myCompare(p1, p2);
	cout << "ret2 = " << ret2 << endl;

}

int main(){
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

4 类模板

4.1 写法template 紧跟着是类

4.2 与函数模板区别，可以有默认类型参数

4.3 函数模板可以进行自动类型推导，而类模板不可以

4.4 类模板中的成员函数一开始不会创建出来，而是在运行时去创建。

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
using namespace std;
//类模板
template  //类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson()
	{
		cout << "姓名：" << this->m_Name << " 年龄： " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
void test01()
{
	//自动类型推导 ，类模板 不支持
	//Person p("孙悟空", 100);
	//显示指定类型
	Person p("孙悟空", 100);
	p.showPerson();
}
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1的调用" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2的调用" << endl;
	}
};

template
class myClass
{
public:
	T obj;
	void func1()
	{
		obj.showPerson1();
	}
	void func2()
	{
		obj.showPerson2();
	}
};
//类模板中成员函数 一开始不会创建出来，而是在运行时才去创建

void test02()
{
	myClassm;
	m.func1();
	//m.func2();
}

int main(){
//	test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

类模板作为参数:

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
using namespace std;
//类模板
template  //类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "姓名：" << this->m_Name << " 年龄： " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

//1  指定传入类型
void doWork( Person & p ) 
{
	p.showPerson();
}
void test01()
{
	Person  p("MT",10);
	doWork(p);
}
//2 参数模板化
template
void doWork2(Person & p)
{
	//如何查看类型
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	p.showPerson();
}
void test02()
{
	Person  p("呆贼", 18);
	doWork2(p);
}
//3 整体模板化
template
void doWork3(T&p)
{
	cout << typeid(T).name() << endl;
	p.showPerson();
}
void test03()
{
	Person  p("劣人", 18);
	doWork3(p);
}
int main(){
//	test01();
	test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

C++笔记--模板

C/C++/C#相关栏目本月热门文章