【C++核心编程】一、模板

最新推荐文章于 2024-09-11 15:28:58 发布

GGGGBond

最新推荐文章于 2024-09-11 15:28:58 发布

阅读量87

点赞数

分类专栏： C++学习文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/GGGGBond/article/details/128988924

版权

C++学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章详细介绍了C++中的模板机制，包括函数模板和类模板的语法、使用方法、注意事项以及与普通函数的区别。函数模板允许创建通用函数，类模板则用于创建可应用于不同数据类型的类。同时，文章提到了模板的局限性，如不能进行隐式类型转换，以及类模板成员函数的创建时机和对象作为函数参数的传递方式。最后，讨论了类模板与继承的关系以及成员函数的类外实现和分文件编写问题。

摘要由CSDN通过智能技术生成

1.模板的概念

模板就是建立通用的模具，大大提高复用性

2.函数模板

C++的另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制 函数模板 和 类模板

1.函数模板语法

函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不确定制定，用一个虚拟的类型来代表

语法：

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

解释：
template — 声明创建模板
typename — 表面其后面的符号时一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include<iostream>
using namespace std;

//函数模板  

template<typename T>

//两个整型交换函数
void sswap(T& a, T& b) {
	T temp;
	temp = a;
	a = b;
	b = temp;
}


int main() {




	int a = 1;
	int b = 0;
	//自动类型推导
	sswap(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	//显式指定类型
	sswap<int>(a, b);

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;





	return 0;
}

函数模板注意事项

自动类型推导，必须推出一致的数据类型T才可以使用
模板必须确定出T的数据类型，才可以使用

普通函数和函数模板区别

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

#include<iostream>
using namespace std;

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

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

template<typename T>
T myadd2(T a, T b)
{
	return a + b;
}


void test1() {
	int a = 11;
	int b = 22;
	char c = 'c';
	cout << myadd(a, b) << endl;
	cout << myadd(a, c) << endl;

	//自动类型转换
	//cout << myadd2(a, c) << endl;//报错，不会发生隐式类型转换
	//显示指定类型
	cout << myadd2<int>(a, c) << endl;

}

int main() {

	test1();
	 



	return 0;
}

模板的局限性

模板的通用性不是万能的
利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

3.类模板

类模板语法

template<typename T>
类

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

//类模板
template<class nametype,class agetype>
class Person
{
public:
	nametype name;
	agetype age;
	Person(nametype n, agetype a) {
		name = n;
		age = a;
	}
};

int main() {

	Person<string,int> p("liu", 18);
	cout << p.name << endl;
	cout << p.age << endl;
	 



	return 0;
}

类模板与函数模板的区别

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

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

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

类模板对象做函数参数

类模板实例化出的对象，像函数传参的方式

一共有三种传参方式：

指定传入的类型 —— 直接显示对象的数据类型
参数模板化 —— 将对象中的参数变为模板进行传递
整个类模板化 —— 将这个对象类型模板化进行传递

#include<iostream>
#include<string>
using namespace std;
//类模板对象做函数参数

template<class T1,class T2>
class Person
{
public:
	Person(T1 n, T2 a) {
		name = n;
		age = a;

	}
	
	T1 name;
	T2 age;

};

//1.指定传入的类型
void showPerson1(Person<string, int>& p) {
	cout << "名字 ： " << p.name << endl;
	cout << "年龄 ： " << p.age << endl;
}
void test1() {
	Person<string, int> p("liu", 18);
	showPerson1(p);

}

//2.参数模板化
template<class T1,class T2>
void showPerson2(Person<T1, T2>& p) {
	cout << "名字 ： " << p.name << endl;
	cout << "年龄 ： " << p.age << endl;
	cout << "T1的类型 ： " << typeid(T1).name() << endl;
	cout << "T2的类型 ： " << typeid(T2).name() << endl;
}
void test2() {
	Person<string, int> p("shao", 18);
	showPerson2(p);

}

//3.将整个类模板化
template<class T>
void showPerson3(T & p) {
	cout << "名字 ： " << p.name << endl;
	cout << "年龄 ： " << p.age << endl;
	cout << "T的类型 ： " << typeid(T).name() << endl;

}
void test3() {
	Person<string, int> p("D", 20);
	showPerson2(p);

}

int main() {

	test1();
	test2();
	test3();


	return 0;
}

类模板与继承
当类模板碰到继承时，需要注意以下几点：

当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需要变为类模板

#include<iostream>
#include<string>
using namespace std;
//类模板与继承

template<class T>
class Base
{
	T name;
};
 
// 当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中T的类型
class Son :public Base<int>
{

};

//如果想灵活指定出父类中T的类型，子类也需要变为类模板
template<class T1,class T2>
class Son2 :public Base<T1>
{
	T2 n;
};

int main() {
	 


	return 0;
}

类模板成员函数类外实现

#include<iostream>
#include<string>
using namespace std;
//类模板成员函数类外实现
template<class T1,class T2>
class Person
{
public:
	Person(T1 n, T2 a);
	void showPerson();
	T1 name;
	T2 age;
};

//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 n, T2 a) {
	name = n;
	age = a;

}

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


int main() {
	 
	Person<string, int> p("liu", 18);
	p.showPerson();

	return 0;
}

类模板分文件编写
问题：

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp时约定的名称，并不是强制的

类模板与友元

全局函数类内实现——直接在类内声明友元即可

#include<iostream>
#include<string>
 
using namespace std;
//类模板分文件编写问题以及解决


template<class T1, class T2>
class Person
{
	//全局函数类内实现
	friend void showPerson(Person<T1,T2> p) {
		cout << "姓名：  " << p.name << endl;
		cout << "年龄：  " << p.age << endl;
	}
public:
	Person(T1 n, T2 a) {
		name = n;
		age = a;
	}


private:
	T1 name;
	T2 age;
};

 

 


int main() {

	Person<string, int> p("liu", 18);
	showPerson(p);

	return 0;
}

全局函数类外实现——需要提前让编译器知道全局函数的存在

#include<iostream>
#include<string>
 
using namespace std;
//类模板分文件编写问题以及解决


template<class T1, class T2>
class Person;
template<class T1, class T2>
void showPerson(Person<T1, T2> p) {
	cout << "姓名：  " << p.name << endl;
	cout << "年龄：  " << p.age << endl;
}
template<class T1, class T2>
class Person
{
	//全局函数类内实现
	friend void showPerson<>(Person<T1, T2> p);
	 
public:
	Person(T1 n, T2 a) {
		name = n;
		age = a;
	}


private:
	T1 name;
	T2 age;
};

 

 


int main() {

	Person<string, int> p("liu", 18);
	showPerson(p);

	return 0;
}