C++学习笔记（11）

已于 2022-03-10 12:12:14 修改
阅读量1.5k 收藏 2
点赞数 5
分类专栏： C++学习 文章标签： 学习 c++ 经验分享 后端
于 2022-03-10 12:10:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60958852/article/details/123391996
版权

目录

一.函数模板

1.定义和声明

2.调用函数模版

3.函数模版在类中的应用

4.函数模板重载

二.类模板

1.声明语法

2.类模板的声明，实现和调用

3.模板类继承

4.自定义类型当模板参数

三.模板嵌套

1.函数模板嵌套

2.类模板嵌套

四.类模板特化

1.局部特化

2.完全特化 

一.函数模板

什么是模板？简单来说，就是一段任何类型都通用的代码，比如我们定义一个比较大小的函数，那这个函数可以适合整型数据，也可以适合浮点型，甚至可以适合string类型，这种把类型当作未知量，可以忽略类型影响的类或函数，我们称之为模版。先来了解函数模版。

1.定义和声明

如何声明和定义一个函数模版？下面以一个比较大小的函数为例：

template <typename _Ty>
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}

也可以同时定义多个未知类型：

template <typename _Ty1, typename _Ty2>
void print(_Ty1 a, _Ty2 b)
{
	cout << a << " " << b;
}

如果觉得typename太陌生的话，也可以将它换成class，这也是可以的。

template <class C>
void printC(C c)
{
	cout << c;
}

2.调用函数模版

调用函数模版有隐式调用和显式调用两种，先来看隐式调用：

template <typename _Ty>
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
int main()
{
	cout << Max(2, 6) << " " << Max(2.1, 2.2);
}

可以看到，隐式调用跟正常的函数传参没什么区别，它会自己识别你的类型，再来看看显式调用：

template <typename _Ty>
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
int main()
{
	cout << Max<int>(2, 6) << " " << Max<double>(2.1, 2.2);
}

可以看到，显示调用的格式是函数名<类型名>（参数）。同样，多个未知类型的调用也是如此：

template <typename _Ty1, typename _Ty2>
void print(_Ty1 a, _Ty2 b)
{
	cout << a<< " " << b;
}
int main()
{
	print(1, 1.2);
	print<int, double>(1, 2.1);
}

3.函数模版在类中的应用

class A
{
public:
	template <class _Ty1>
	void print(_Ty1 a)
	{
		cout << a;
	}
};
int main()
{
	A a;
	a.print<int>(2);
	a.print<string>("小蓝");
}

其实函数模版在类中跟普通函数差别不大，差别比较大的是类中声明类外实现的方式，函数模版不能省略template语句。

class A
{
public:
	template <class _Ty1>
	void print(_Ty1 a);
};
template <class _Ty1>
void A::print(_Ty1 a)
{
	cout << a;
}

普通函数有缺省的写法，同样的，函数模版也有缺省写法。

template <class _Ty1,class _Ty2 = int>
void print(_Ty1 a, _Ty2 b)
{
	cout << a << " " << b;
}
int main()
{
	print<string>("小蓝", 2);
}

函数模版存在传常量的写法：

template <class _Ty1,size_t size>
void printArr(_Ty1 arr)
{
	for (int i = 0;i < size;i ++)
	{
		cout << arr[i] << " ";
	}
}
int main()
{
	int arr[3] = { 1,2,3 };
	printArr<int*, 3>(arr);
}

其中的size_t是无符号整型的别称，这种写法只能显示调用，因为需要传入一个有关大小的常量，但是我们用缺省写法可以做到隐式调用：

template <class _Ty1,size_t size = 3>
void printArr(_Ty1 arr)
{
	for (int i = 0;i < size;i ++)
	{
		cout << arr[i] << " ";
	}
}
int main()
{
	int arr[3] = { 1,2,3 };
	printArr(arr);
}

4.函数模板重载

  • 模板和普通函数 ，调用函数函数类型一致情况 优先调用普通函数
  • 两个模板同时成立，优先调用类型相似度搞的那个
void print(int a, string b) 
{
    cout << "普通函数" << endl;
}
template <class _Ty1,class _Ty2>
void print(_Ty1 a, _Ty2 b) 
{
    cout << "两个类型" << endl;
}

template <class _Ty>
void print(_Ty a, _Ty b) 
{
    cout << "一个类型" << endl;
}

int main() 
{
    print<int, string>(12, "调用模板");
    print(12, string("优先调用适应的普通函数"));
    //两个模板同时成立，优先调用类型相似度搞的那个
    print(12, 12); // 
    return 0;
}

二.类模板

1.声明语法

template <class _Ty>
class A
{

};

2.类模板的声明，实现和调用

  • 多文件中，类模板 中的声明和实现一定在一起的，不能分开写

  • 必须采用显式调用
  • 类模板不是一个实际类型，所以所有用到类名的地方都需要使用: 类名<未知类型> 方式使用
template <class _Ty>
class A
{
public:
	A() {}
	A(string name) :name(name) {}
	void print(_Ty a);    //类中声明在类外实现
protected:
	string name;
};
template <class _Ty>
void A<_Ty>::print(_Ty a) //所有用到类名的地方:都需要用类名<类型>的方式使用   
{
	cout << a << endl;
}

int main()
{
	A<int>a;
	a.print(1);
	A<string>b;
	b.print("小蓝");
}

3.模板类继承

template <class _Ty>
class A
{
public:
	A() {}
	A(string name) :name(name) {}
	void print(_Ty a);    //类中声明在类外实现
protected:
	string name;
};
template <class _Ty>
void A<_Ty>::print(_Ty a) //所有用到类名的地方:都需要用类名<类型>的方式使用   
{
	cout << a << endl;
}
template <class _Ty>
class B :public A<_Ty>
{
public:
	B(string name):A<_Ty>(name){}
};
int main()
{
	B<int> b("小蓝");
	b.print(1);
}

总之，用到模板类的地方都要template修饰一下，继承也是一样。

4.自定义类型当模板参数

注意：模板传入自定义类型，关键在于重载运算符！

template <class _Ty>
void print(_Ty a)
{
	cout << a;
}
class A
{
public:
	A(string name,int age):name(name),age(age){}
	friend ostream& operator<<(ostream& out, A& a)
	{
		out << a.name << " " << a.age;
		return out;
	}
protected:
	string name;
	int age;
};
int main()
{
	print(A("小蓝", 18));
}

再来一个练练手：

template <class _Ty>
_Ty Max(_Ty a, _Ty b)
{
	return a > b ? a : b;
}
class A
{
public:
	A(string name,int age):name(name),age(age){}
	friend ostream& operator<<(ostream& out, A& a)
	{
		out << a.name << " " << a.age;
		return out;
	}
	friend bool operator>(A& a,A& b)
	{
		return a.age > b.age;
	}
protected:
	string name;
	int age;
};
int main()
{
	A a1("小蓝", 18);
	A a2("小红", 19);
	A a = Max(a1, a2);
	cout << a;
}

之前设计链表的时候总是感觉底层数据太多难以封装，现在可以试着写一个链表来管理模板类型的数据。

class A
{
public:
	A(string name,int age):name(name),age(age){}
	friend ostream& operator<<(ostream& out,const A& a)
	{
		out << a.name << " " << a.age;
		return out;
	}
protected:
	string name;
	int age;
};
template <class _Ty>
class Node
{
public:
	Node(){}
	Node(_Ty data,Node<_Ty>* next):data(data),next(next){}
	_Ty getData()
	{
		return data;
	}
	Node<_Ty>* getNext()
	{
		return next;
	}
protected:
	_Ty data;
	Node<_Ty>* next;
};
template <class _Ty> //因为用到了Node模板
class List
{
public:
	List()
	{
		headNode = nullptr;
	}
	void insertData(_Ty data)
	{
		headNode = new Node<_Ty>(data, headNode);
	}
	void printList()
	{
		Node<_Ty>* pMove = headNode;
		while (pMove)
		{
			cout << pMove->getData() << endl;
			pMove = pMove->getNext();
		}
	}
	~List()
	{
		Node<_Ty>* p = headNode, * q;
		while (p)
		{
			q = p;
			p = p->getNext();
			delete q;
		}
	}
protected:
	Node<_Ty>* headNode;
};
int main()
{
	List<int> list;
	list.insertData(1);
	list.insertData(2);
	list.printList();

	List<A> list2;
	list2.insertData(A("小蓝", 18));
	list2.insertData(A("小宏", 19));
	list2.printList();
}

需要注意的是：提供的接口是返回值，是一个const类型的对象(常属性) 需要把A的重载函数改为const A& a，返回值是值，不可以成为左值 ---> 返回值充当函数参数，需要加const修饰 ，加const是为了传入const 对象的时候这个重载函数也能用。

三.模板嵌套

1.函数模板嵌套

template <class _Ty>
void print(_Ty a)
{
	cout << a;
}
template <class _Ty1,class _Ty2>
class A
{
public:
	A(_Ty1 name,_Ty2 age):age(age),name(name){}
	friend ostream& operator<<(ostream& out, const A& a)
	{
		out << a.name << " " << a.age << endl;
		return out;
	}
protected:
	_Ty1 name;
	_Ty2 age;
};
int main()
{
	print<A<string, int>>(A<string, int>("小蓝",18));
	print(A<string,int>("小红", 19));
	//起别名简化代码
	using AType = A<string,int>;
	print<AType>(AType("小绿", 20));
}

无论外层是隐式调用还是显式调用，里层必须显式调用。

2.类模板嵌套

template <class _Ty1,class _Ty2>
class A
{
public:
	A(_Ty1 name,_Ty2 age):age(age),name(name){}
	friend ostream& operator<<(ostream& out, const A& a)
	{
		out << a.name << " " << a.age ;
		return out;
	}
protected:
	_Ty1 name;
	_Ty2 age;
};
template <class _Ty1,class _Ty2>
class Data
{
public:
	Data(_Ty1 one,_Ty2 two):one(one),two(two){}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	_Ty1 one;
	_Ty2 two;
};
int main()
{
	A<string, int> a("小蓝", 19);
	A<double, double> b(11.1, 12.1);
	Data<A<string, int>, A<double, double>> d(a, b);
	d.print();
	//上面四行等效于
	Data<A<string, int>, A<double, double>> d2(A<string, int>("小蓝", 19), A<double, double>(11.1, 12.1));
	d2.print();
}

其实嵌套就是每一层剥洋葱，没有什么特别的。

四.类模板特化

为啥要特化？因为有些数据是特殊形式的，特殊形式的数据在调用原模板时候可能不兼容，可以把它特殊化到一个单独的类中去实现，针对这种独立的数据类型去做处理

1.局部特化

template <class _Ty1, class _Ty2>
class A
{
public:
	A(_Ty1 one, _Ty2 two) :one(one), two(two) {}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	_Ty1 one;
	_Ty2 two;
};
class Data
{
public:
	Data(int one,int two):one(one),two(two){}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	int one;
	int two;
};
//局部特化,将两种未知类型特化为一种
template <class _Ty>
class A<_Ty,_Ty>
{
public:
	A(_Ty one, _Ty two) :one(one), two(two) {}
	void print()
	{
		one.print();
		two.print();//可以传两个类的对象类型进来 调用各自类对象的方法去打印数据
		cout << "局部特化" << endl;
	}
protected:
	_Ty one;
	_Ty two;
};
int main()
{
	//调用原模板
	A<string, int> a("小蓝", 18);
	a.print();

	//调用局部特化模板
	A<Data, Data> d(Data(1, 2), Data(3, 4));
	d.print();
}

2.完全特化 

 局部特化升级版，传入已知类型。

template <class _Ty1, class _Ty2>
class A
{
public:
	A(_Ty1 one, _Ty2 two) :one(one), two(two) {}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	_Ty1 one;
	_Ty2 two;
};
class Data
{
public:
	Data(int one,int two):one(one),two(two){}
	void print()
	{
		cout << one << " " << two << endl;
	}
protected:
	int one;
	int two;
};
//完全特化,传入指定类型
template <>
class A<Data, Data>
{
public:
	A(Data one, Data two) :one(one), two(two) {}
	void print()
	{
		one.print();
		two.print();//可以传两个类的对象类型进来 调用各自类对象的方法去打印数据
		cout << "完全特化" << endl;
	}
protected:
	Data one;
	Data two;
};
int main()
{
	//调用完全特化模板
	A<Data, Data> d(Data(1, 2), Data(3, 4));
	d.print();
}

 

bluestar啦啦
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
模板类的声明和定义
maple的博客
07-16 2044
模板的声明和定义
c++模板 --- 模板的嵌套
路过的熊的博客
04-23 1030
c++模板 --- 模板的嵌套
C++模板(template)详解教程（很多代码示例）
最新发布
a6484594的博客
06-04 1986
C++模板快速上手
类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离时，在主函数的实现文件(.cpp)中应该包含的是类模板的实现(.cpp 或.hpp文件)
weixin_46060711的博客
05-01 694
注意：当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离，因为类模板的特殊实现，我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件。 demo.h： #pragma once template <typename T> class A { public: A(T t=0); T &getT(); A operator +(const A &other); void print(); private: T t;
C++类模板——嵌套使用
Crush_66的博客
05-17 2343
C++类模板的嵌套使用
C++ 模板类的嵌套
man_skill的博客
04-10 3150
模板类的嵌套 使用函数模板，当参数是自定义数据类型（如结构体，类）时，需要通过第三代具体化自定义数据类型来解决问题。 那么对于类模板中的成员对象的数据类型也是自定义数据类型呢。 实际上，只要类中包括了某个类型的成员或者方法，在实例化对象的时候就要声明数据类型。 那么如果类的成员也是模板类呢。 就出现了如下的嵌套： template<class T> class Nm { T a; }; template<class T> class Mn { T find() { T p
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记
04-01
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。
c++学习笔记精华版
08-27
c++学习笔记／知识要点精华版
C++(17)：模板嵌套类的.template及::template
风静如云的博客
11-24 1158
告诉编译器后面的符号是一个嵌套类模板。告诉编译器后面的符号是一个模板成员。对象.template。类::template。
c++中模板类的声明与实现写在同一文件中
weixin_45022086的博客
12-09 1216
模板类是一个特殊的类，不能像普通的类那样，声明与实现分别放在.h和.cpp文件 模板类需要将声明和实现的函数都写在.h文件里面，否则会在编译完成链接的时候会出现问题（我记得是当我new一个模板类的对象的时候，找不到构造函数的实现） 具体解释说明：模板类的声明与实现要放在同一文件中 ...
模板（Template）/ typename 嵌套依赖类型
Jeff_的博客
07-11 8883
C++模板的语法 一、函数模板和类模板 函数模板（function template）和类模板（class template）的简单示例如下(参考：传送门)： #include <iostream> // 函数模板 template<typename T> bool equivalent(const T& a, const T& b) { ret...
C++ 模板类的声明与实现分离问题
kaimMarch的博客
07-05 764
C++ 模板类的声明与实现分离会出现链接问题，出现此问题的原因涉及到程序的编译过程，本文探讨如何实现优雅地分离，并提供几种解决方案。本文转载自其他平台，用于自存。
【C++】模板声明与定义不分离
Yngz_Miao的博客
12-30 1万+
一般在写C++相关代码的时候，我们总习惯于将类声明和类实现进行分离。也就是说，类的声明一般写在.h文件中，而它的实现一般写在.cpp文件中。但是，在模板类中，这个习惯却要恰恰相反。即：要求模板类的类声明和类实现要都放在头文件，而不能分离。 本文就对模板的这个奇特习惯进行分析。 本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q4/20201230。 分离式编译模式 在进行模板特性的讲解之前，首先需要了解一下
C++模板类的声明与实现分离
only_a_Heroic_car的博客
12-31 851
1、我们在写类的时候一般通常将声明放到.h文件，函数实现放入.cpp，如下： //.h class Mystring{ public: Mystring(const char* str = "empty"); Mystring(const char* data, int len); ... ... ~Mystring(); int myRe...
C++ 模板类定义与声明
热门推荐
02-07 2万+
声明和使用类模板： 如果在类模板外定义成员函数，应写成类模板形式： template函数类型 类模板名∷成员函数名(函数形参表列) {…}测试的模板类，如下：//Compare.h#ifndef _COMPARE_H#define _COMPARE_Htemplate class Compare{public: ~Compare(void); Compare(T,T); T max()
《C++从入门到精通》笔记
11-06
"《C++从入门到精通》笔记涵盖了C++编程的基础...通过学习这些笔记，读者不仅可以了解C++的基础知识，还能掌握编写简单程序的基本技能。对于打算深入研究C++或者准备相关考试的人来说，这份笔记是一个很好的参考资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值