C++模板笔记

模板

c++另一种编程思想机制为泛型编程，主要利用的技术就是模板

分为两种模板机制:函数模板和类模板

函数模板

语法：

template<typename T>
函数申明或定义

template —— 申明创建模板

typename —— 表面其后面的符号是一种数据类型，可以用class代替

T —— 通用的数据类型，名称可以换

交换模板解释

#include<iostream>

using namespace std;

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

int main()
{
	int a, b;
	cin >> a >> b;
	aswap(a, b);//自动类型推导
	aswap<int>(a, b);//显示指定类型
	cout << a << b;
}

模板注意事项

1.自动类型推导，需要推导出一致的类型T才可以使用

int main()
{
	int a;
	char b;
	cin >> a >> b;
	aswap(a, b);//错误，推导不出一致的T
	cout << a << b;
}

2.模板必须确定出T的数据类型，才可以使用

template<class T>
void func() {
	cout << "YES" << endl;
}

int main()
{
	func();//错误
	 
}

实用样例 排序模板

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

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

template<class T>
void ssort(T a[], int len) {
    for (int i = 0; i < len; i++) {
        int max = i;
        for (int j = i + 1; j < len; j++) {
            if (a[max] < a[j]) {
                max = j;
            }
        }
        if (max != i) {
            sswap(a[max], a[i]);
        }
    }
}

template<class T>
void pprintf(T a[], int len) {
    for (int i = 0; i < len; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{

    int a[] = { 1,2,3,4,5,6,7 };
    int intlen = sizeof(a) / sizeof(int);//计算数组的长度

    char b[] = "abcdef";
    int csize = sizeof(b) / sizeof(char);
    ssort(a, intlen);
    ssort(b, csize);
    pprintf(a, intlen);
    pprintf(b, csize);
}

普通函数和函数模板的区别

1.普通函数调用可以发生隐式类型转换

2.函数模板 用自动类型推导，不可以发生隐式类型转换

3.函数模板 用显示指定类型，可以发生隐式类型转换 把传入的转为指定类型

普通函数和函数模板的调用规则

1.如果函数模板和普通模板都可以实现，优先普通模板

2.可以通过空模板参数列表来强制调用函数模板 （指定类型推导的方式，但不指定） sort< >(a,b)

3.函数模板可以重载

4.如果函数模板可以产生更好匹配，优先函数模板

模板的局限性

模板的通用性不是万能的，如数组的赋值和类内数据大小比较等…

C++为了解决这种情况提供了可具体化的实现

类内的比较：

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

class p {
public:
	p(string name, int age) {
		this->name = name;
		this->age = age;
	}
	string name;
	int age;
};
template <class T> 
bool bijiao(T& a, T& b)
{
	if (a == b) return true;
	else return false;
}

template <> bool bijiao(p& a, p& b)
{
	if (a.age == b.age) return true;
	else return false;
}

int main()
{
	p p1("make", 18);
	p p2("jett", 16);
	if (bijiao(p1,p2))cout << "相等";
	else cout << "不相等";
}

学习模板不是为了写模板，而是为了可以运用STL里提供的模板

类模板

语法：

template<class T>
类

举例

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


template <class nameT,class ageT> 
class p{
public:
	p(nameT name, ageT age) {
		this->name = name;
		this->age = age;
	}
 
	void show() {
		cout << this->name << ' ' << this->age;
	}

	nameT name;
	ageT age;
};


int main()
{
	p<string,int> p1("小溪",17);
	p1.show();
}

模板和函数模板的区别

1.类模板没有自动类型推导使用方式

p<> p1("小溪",17);错误
p<string,int> p1("小溪",17);正确

2.类模板在模板参数列表中可以有默认参数

template <class nameT,class ageT = int>
p<string> p1("小溪",17);

类模板中成员函数创建时间

1.普通类中的成员函数一开始就可以创建

2.类模板中的成员函数在调用时才可以创建

类模板对象做函数参数

三种传入方式

1.指定传入的类型 2.参数模板化 3.整个类模板化

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


template<class T1,class T2>
class p {
public:
	p(T1 name, T2 age) {
		this->name = name;
		this->age = age;
	}

	string name;
	int age;

	void show() {
		cout << name << ' ' << age;
	}
};

//1.指定传入类型
void printfp1(p<string, int>& p1) {
	p1.show();
}

//2.参数模板化
template<class T1,class T2>
void printfp2(p<T1,T2>& p1)
{
	p1.show();
}

//3.整个模板化
template<class T>
void printfp3(T &p1)
{
	p1.show();
	cout << "T的数据类型" << typeid(T).name();//看看T的类型
}
int main()
{
	p<string,int> p1("小溪",17);
	printfp1(p1);
	printfp2(p1);
	printfp3(p1);
}

类模板与继承

如果父类是类模板，子类需要指定父类T的数据类型

template<class T>
class base {
public:
	T a;
};

//class son:public base 错误，需要指定父类T的类型，才可以继承给子类
class son:public base<int> 
{

};

template<class T>
class base {
public:
	T a;
};

//想灵活指定父类中T的类型，子类也需要变成模板
template<class T1,class T2>
class son:public base<T2> 
{
	T1 ojb;
};

int main()
{
	son<int, char> S1;
}

类模板的类外实现

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


template<class T1, class T2>
class p {
public:
	p(T1 name, T2 age);

	string name;
	int age;

	void show();
};

template<class T1,class T2>
p<T1, T2>::p(T1 name, T2 age) {
	this->name = name;
	this->age = age;
}

template<class T1,class T2>
void p<T1, T2>::show() {
	cout << this->name << ' ' << this->age;
}

int main() {
	p<string,int> p1("小李", 17);
	p1.show();
}

类模板的分文件编写的解决方法

1.将头文件改为.cpp直接读源代码(不常用)

2.申明和实现写入同一个文件 文件后缀.hpp(主流)

类模板和友元

类内实现-直接在类内申明友元即可

类外实现-需要让编译器提前知道全局变量的存在

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

template<class T1, class T2>//类外实现要让编译器提前知道
class p;

template<class T1, class T2>
void showname(p<T1, T2> p) {
	cout << p.name;
}


template<class T1, class T2>
class p {
	//全局函数类内实现
	friend void show(p<T1,T2> p) {
		cout << p.name << ' ' << p.age;
	}

	//全局函数类外实现
	friend void showname <>(p<T1, T2> p);//需要加空模板的参数列表，类外实现要让编译器提前知道

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

	string name;
	int age;
};


int main() {
	p<string,int> p1("小李", 17);
	show(p1);
	showname(p1);
}