• C++模板与STL（一）：模板基础与STL仿真复现

    注：本文仅作个人做笔记复习用，不具有教学意义！ 

    目录

    模板的定义

    函数模板和模板函数

    函数模板不提供隐式类型转换 

    当函数模板和普通函数都符合调用规则时，优先使用普通函数

    hpp：h+cpp的结合体，声明与实现结合

     类模板

    类模板应用：Array容器的仿真复现

    模板类继承：

    模板类的嵌套

    左值与右值简介 

    转移函数和完美转发模板

    STL模板技术

    C++泛型机制的基石-数据类型表

    Traits1：利用typedef：类型萃取器

    Traits2：如果一个类模板中，全部的成员都是公有数据类型，这个模板就是一个独立的数据类型表，用来规范数据

    Traits3：非侵入式STL类型设计与数据类型

    Traits4：Traits的原理及应用：Iterator

    shared_ptr的仿真实现Shared_ptr:

    模板的定义

    • 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，称为类属
    • 模板用于表达逻辑结构相同，但具体数据类型元素不同的数据
    • 对象的通用行为

    函数模板和模板函数

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. //函数模板
    6. template<typename T>
    7. void myswap(T &a,T &b) {
    8. 	T temp;
    9. 	temp = a;
    10. 	a = b; 
    11. 	b = temp;
    12. }
    13.  
    14. int main() {
    15.  
    16. 	int a = 1, b = 2;
    17. 	//模板函数，编译器根据传入参数生成的模板特例
    18. 	myswap(a, b);
    19. 	cout << a << " " << b << endl;
    20.  
    21. 	double c = 2.2, d = 3.3;
    22. 	//模板函数，编译器根据传入参数生成的模板特例
    23. 	myswap(c, d);
    24. 	cout << c << " " << d << endl;
    25.  
    26. 	return 0;
    27. }

     

    函数模板不提供隐式类型转换 

    1. template<typename T>
    2. void fun(T& a,T& b) {
    3. 	cout << "template被调用" << endl;
    4. }
    5.  
    6. void fun(char c,int y) {
    7. 	cout << "普通函数被调用" << endl;
    8. }
    9.  
    10. int main() {
    11. 	char ch = 'a';
    12. 	int data = 23;
    13. 	fun<int>(ch, data);//❌，函数模板不提供隐式类型转化，必须严格遵守T的类型定义
    14.     fun(ch, data);//✔，调用普通函数
    15. 	return 0;
    16. }

    当函数模板和普通函数都符合调用规则时，优先使用普通函数

    • 因为普通函数在编译的期间就生成了函数体
    • 而模板函数的生成在调用的时候，编译器才会编译
    1. template<typename T>
    2. void fun(T& a,T& b) {
    3. 	cout << "template被调用" << endl;
    4. }
    5.  
    6. void fun(int &a,int &b) {
    7. 	cout << "普通函数被调用" << endl;
    8. }
    9.  
    10. int main() {
    11. 	int data1 = 32;
    12. 	int data2 = 23;
    13. 	fun<int>(data1, data2);//template被调用
    14. 	fun(data1, data2);//普通函数被调用
    15. 	return 0;
    16. }

    编译器在处理函数模板的时候能够生成任意类型的函数

    根据调用的实际产生不同的函数：

    编译器会对函数模板进行二次编译：这是参数化的基础，也是成为编译时多态的由来。

    在声明的地方对模板代码本身进行编译，在调用的地方对参数化以后的具体调用进行编译

    hpp：h+cpp的结合体，声明与实现结合

    【C++】模板声明与定义不分离_Yngz_Miao的博客-CSDN博客_c++模板声明

     

     类模板

    • 类模板用于实现类所需数据的类型参数化
    • 类模板在表示如数组、表、图等数据结构显得特别重要
    • 这些数据结构的表示和算法不受所包含的元素类型影响
    1. #include 
    2. using namespace std;
    3.  
    4. template<class T1,class T2>
    5. class MyClass {
    6. public:
    7. 	T1 _t1;
    8. 	T2 _t2;
    9. 	MyClass(T1 t1, T2 t2) :_t1(t1), _t2(t2) {}
    10. 	void print() {
    11. 		cout << _t1 << "," << _t2 << endl;
    12. 	}
    13. };
    14.  
    15. int main() {
    16.  
    17. 	MyClass<int, int>mc(1, 2);
    18. 	mc.print();
    19. 	
    20. 	return 0;
    21. }

    类模板应用：Array容器的仿真复现

    MyArray.hpp:

    1. #pragma once
    2.  
    3. template<class T,int n>
    4. class MyArray {
    5. public:
    6. 	MyArray();
    7. 	MyArray(int length);
    8. 	~MyArray();
    9. 	
    10. 	int size();
    11. 	T get(int num);
    12. 	T& operator[](int num);
    13. 	void set(T data, int num);
    14. public:
    15. 	T* pt;
    16. 	
    17. };
    18.  
    19. template<class T, int n>
    20. inline MyArray::MyArray()
    21. {
    22. 	this->pt = new T[n];
    23. }
    24.  
    25. template<class T, int n>
    26. inline MyArray::MyArray(int length)
    27. {
    28. 	this->pt = new T[length];
    29. }
    30.  
    31. template<class T, int n>
    32. inline MyArray::~MyArray()
    33. {
    34. 	delete[]this->pt;
    35. }
    36.  
    37. template<class T, int n>
    38. inline int MyArray::size()
    39. {
    40. 	return n;
    41. }
    42.  
    43. template<class T, int n>
    44. inline T MyArray::get(int num)
    45. {
    46. 	if (num >= n || num < 0) {
    47. 		//exception;
    48. 	}
    49. 	else {
    50. 		return *(this->pt + num);
    51. 	}
    52. }
    53.  
    54. template<class T, int n>
    55. inline T& MyArray::operator[](int num)
    56. {
    57. 	if (num >= n || num < 0) {
    58.  
    59. 	}
    60. 	else {
    61. 		return *(pt + num);
    62. 	}
    63. }
    64.  
    65. template<class T, int n>
    66. inline void MyArray::set(T data, int num)
    67. {
    68. 	if (num >= n || num < 0) {
    69. 		//
    70. 	}
    71. 	else {
    72. 		*(pt + num) = data;
    73. 	}
    74. }
    75.  
    76.  
    77.  
    78.  
    79.  
    80.  
    81.

    MyArray.cpp

    1. #include 
    2. #include "MyArray.hpp"
    3. using namespace std;
    4.  
    5. int main() {
    6. 	MyArray<int, 5>arr;
    7. 	for (int i = 0; i < arr.size(); i++) {
    8. 		arr.set(i * 10, i);
    9. 		cout << arr[i] << endl;
    10. 	}
    11. 	return 0;
    12. }

    模板类继承：

    模板类继承模板类：

    1. #include 
    2. #include 	
    3. using namespace std;
    4.  
    5. template<class T>
    6. class MyClass {
    7. public:
    8. 	T x;
    9. 	MyClass(T t) :x(t) {}
    10. 	virtual void print() = 0;
    11. };
    12.  
    13. template<class T>
    14. class NewClass :public MyClass {
    15. public:
    16. 	T y;
    17. 	NewClass(T t1, T t2) :MyClass(t1), y(t2) {}
    18. 	void print() {
    19. 		cout << "x=" << x << " y=" << y << endl;
    20. 	}
    21. };
    22.  
    23. int main() {
    24. 	MyClass<int>* p = new NewClass<int>(10, 8);
    25. 	p->print();
    26. 	return 0;
    27. }

     

    模板类继承普通类：

    1. class XYZ {
    2. public:
    3. 	int x, y, z;
    4. 	XYZ(int a, int b, int c) :x(a), y(b), z(c) {}
    5. 	virtual void print() {
    6. 		cout << x << " " << y << " " << z << " " << endl;
    7. 	}
    8. };
    9.  
    10. template<class T>
    11. class GoodsXYZ :public XYZ {
    12. public:
    13. 	int t;
    14. 	GoodsXYZ(int t1, int a, int b, int c) :XYZ(a, b, c), t(t1) {}
    15. 	void print() {
    16. 		cout << "T 类型的值" << t << endl;
    17. 		cout << x << " " << y << " " << z << endl;
    18. 	}
    19. };

    普通类继承模板类

    1. class RunClass :public GoodsXYZ<int> {
    2. public:
    3. 	int dd = 1000;
    4. 	RunClass(int a2, int b2, int c2, int d2) :GoodsXYZ<int>(a2, b2, c2, d2) {}
    5. 	void print() {
    6. 		cout << dd << x << y << z;
    7. 	}
    8. };

    模板类的嵌套

    1. #include 
    2. using namespace std;
    3.  
    4. template<class T>
    5. class MyTestNestClass {
    6. public:
    7. 	class nClass {
    8. 	public:
    9. 		int num;
    10. 	};
    11. 	nClass nObj1, nObj2;
    12.  
    13. 	template<class V>
    14. 	class RunClass {
    15. 	public:
    16. 		V v1;
    17. 	};//嵌套类模板，不能直接初始化
    18. 	RunClasst1;
    19. 	RunClass<double>t2;
    20. };
    21.  
    22. int main() {
    23. 	MyTestNestClass<int>myObj1;
    24. 	myObj1.nObj1.num = 10;
    25. 	myObj1.t1.v1 = 13;
    26. 	myObj1.t2.v1 = 6.18;
    27. 	cout << myObj1.nObj1.num<< endl;
    28. 	cout << myObj1.t1.v1 << endl;
    29. 	cout << myObj1.t2.v1 << endl;
    30. 	return 0;
    31. }

    左值与右值：

    1. 	int a = 10;
    2. 	int b = 20;
    3. 	int c = a + b;
    4.  
    5. 	__asm {
    6. 		mov eax,a
    7. 		mov ebx,b
    8. 		add eax,ebx
    9. 		mov c,eax
    10. 	}

    左值与右值简介 

    左值：

    • 可以出现在赋值运算符左边
    • 往往代表一个存储空间
    • 左值是一个有名字，有固定地址的表达式

    右值：

    • 所谓的数据
    • 由于计算式涉及到了计算机空间，仅仅在表达式运行过程中存在
    • 右值是一个与运算过程相匹配的临时对象，在对应语句执行完毕之后就销毁了
    • 所以无法从语法上取到右值地址
    • 右值仅仅是一个匿名，没有固定地址的对象

    右值引用：使得右值变成一个与左值完全相同的持久对象

    1. 	int x = 10, y = 20;
    2. 	int&& right = x + y;

     

    如果有一个临时对象，那么使用浅拷贝会有巨大的意义

    当我们需要具有”转移语意“的拷贝构造函数时，浅拷贝的意义就凸显了。

    1. #include 
    2. using namespace std;
    3.  
    4. class Foo {
    5. public:
    6. 	Foo(int x) {
    7.  
    8. 	}
    9.  
    10. 	Foo(const Foo& r) {
    11. 		//this->p = r.p;//浅拷贝，p和r.p指向了同一个地址
    12. 		p = new int;
    13. 		*p = *(r.p);//深拷贝
    14. 	}
    15.  
    16. 	Foo(Foo&& r) {
    17. 		cout << "Foo(Foo&&)" << endl;
    18. 		p = r.p;//p和r.p指向了同一个地址
    19. 		r.p = nullptr;//源对象r放弃资源所有权
    20. 	}
    21.  
    22. private:
    23. 	int* p;
    24. };
    25.  
    26. Foo func() {
    27. 	Foo foo(100);
    28. 	return foo;
    29. }
    30.  
    31. int main() {
    32. 	Foo f(func());//资源所有权发生转移，资源位置没有改变而所属对象变化
    33.  
    34. 	return 0;
    35. }

     

    转移函数和完美转发模板

    1. #include 
    2. using namespace std;
    3.  
    4. void Func(int& x) {
    5. 	cout << "左值引用" << endl;
    6. }
    7.  
    8. void Func(int&& x) {
    9. 	cout << "右值引用" << endl;
    10. }
    11.  
    12. void Func(const int& x) {
    13. 	cout << "左值常引用" << endl;
    14. }
    15.  
    16. void Func(const int&& x) {
    17. 	cout << "右值常引用" << endl;
    18. }
    19.  
    20. template<typename T>
    21. void FuncT(T&& a) {
    22. 	Func(std::forward(a));//使用std::forward进行类型推导
    23. }
    24.  
    25. int main() {
    26. 	FuncT(10);
    27.  
    28. 	int a;
    29. 	FuncT(a);
    30. 	
    31. 	FuncT(std::move(a));
    32.  
    33. 	const int b = 10;
    34. 	FuncT(b);
    35.  
    36. 	FuncT(std::move(b));
    37.  
    38. 	return 0;
    39. }

    STL模板技术

    C++泛型机制的基石-数据类型表

    Traits1：利用typedef：类型萃取器

    实现内嵌数据类型->从模板传入类型

    1. template<typename T>
    2. struct map {
    3. 	typedef T value_type;
    4. 	typedef T& reference;
    5. 	typedef T* pointer;
    6. };
    7.  
    8. template<typename T,typename U>
    9. class A :public TypeTb1 {
    10.  
    11. };
    12.  
    13. int main() {
    14.  
    15. 	map<int>::value_type a = 100;
    16. 	map<int>::reference b = a;
    17. 	map<int>::pointer c = &a;
    18. 		
    19. 	return 0;
    20. }

    Traits2：如果一个类模板中，全部的成员都是公有数据类型，这个模板就是一个独立的数据类型表，用来规范数据

    ①定义一个规范类模板类型的基类模板

    ②凡是继承了这个类型表的模板，它的访问类型就被确定

    STL库中，设计人员经常使用这种技巧：

    1. template<class _A1m,class _A2, class R>
    2. class binary
    3. {
    4. 	typedef _A1 Arg1;//第一个形参类型
    5. 	typedef _A2 Arg2;//第二个形参类型
    6. 	typedef R Rtn;//返回值类型
    7. };

    举例：

    1. template<typename TR,typename T1,typename T2>
    2. class Add :public binary {
    3. public:
    4. 	TR bFunction(const T1& x, const T2& y)const {
    5. 		return x + y;
    6. 	}
    7. };
    8.  
    9. int main() {
    10.  
    11. 	double a = 100.01, b = 20.2;
    12. 	Add<double, double, double>addObj;
    13. 	cout << addObj.bFunction(a, b) << endl;
    14. 	
    15. 		
    16. 	return 0;
    17. }

    因为Add包含了binary的类型数据表，因此系统中的其他模块就可以使用Add::Arg1,Add::Arg2,Add::Rtn这种方式和Add本身进行对接。

    这种数据类型的抽象，达到了多个系统模块之间的类型统一。

    Traits3：非侵入式STL类型设计与数据类型

    1. #include 
    2. using namespace std;
    3.  
    4. class Test1;
    5. class Test2;
    6. //两个类模板规范一个统一的接口
    7. template <typename T>
    8. class TypeTb1 {
    9.  
    10. };
    11.  
    12. //特化模板1
    13. template<>
    14. class TypeTb1 {
    15. public:
    16. 	typedef char ret_type;
    17. 	typedef int par1_type;
    18. 	typedef double par2_type;
    19. };
    20.  
    21. //特化模板2
    22. template<>
    23. class TypeTb1 {
    24. public:
    25. 	typedef double ret_type;
    26. 	typedef double par1_type;
    27. 	typedef int par2_type;
    28. };
    29.  
    30. template<typename T>
    31. class Test {
    32. public:
    33. 	typename TypeTb1::ret_type compute
    34. 	(
    35. 		typename TypeTb1::par1_type x,
    36. 		typename TypeTb1::par2_type y
    37. 	)
    38. 	{
    39. 		return x;
    40. 	}
    41. };
    42.  
    43. int main() {
    44. 	Testt1;
    45. 	cout << t1.compute(65, 6.18) << endl;
    46. 	return 0;
    47. }

    Traits4：Traits的原理及应用：Iterator

    1. template<typename T>
    2. struct Traits{
    3.  
    4. };
    5.  
    6. template<typename T>
    7. struct Traits {
    8. 	typedef T value_type;
    9. 	typedef value_type* pointer;
    10. 	typedef value_type& reference;
    11. };
    12.  
    13. int main() {
    14. 	Traits<double*>::value_type t2 = 4.44;
    15. 	cout << t2 << endl;
    16. 	return 0;
    17. }

    shared_ptr的仿真实现Shared_ptr:

    1. #include
    2. using namespace std;
    3.  
    4. template<typename T>
    5. class Shared_ptr;
    6.  
    7. template<typename T>
    8. class Res_ptr {
    9. private:
    10. 	T* res_p;
    11. 	int use_num;
    12. 	Res_ptr(T* p) :res_p(p), use_num(1) {
    13. 		cout << "res 构造函数" << endl;
    14. 	}
    15. 	~Res_ptr() {
    16. 		cout << "res 析构函数" << endl;
    17. 	}
    18. 	friend class Shared_ptr;
    19. };
    20.  
    21. template<typename T>
    22. class Shared_ptr {
    23. public:
    24. 	Shared_ptr(T* p) :ptr(new Res_ptr(p)) {
    25. 		cout << "Shared_ptr的构造函数 " << " use_num=" << ptr->use_num << endl;
    26. 	}
    27.  
    28. 	Shared_ptr(const Shared_ptr& origin) :ptr(origin.ptr) {
    29. 		++ptr->use_num;
    30. 		cout << "Shared_ptr的拷贝构造函数" << " use_num=" << ptr->use_num << endl;
    31. 	}
    32.  
    33. 	~Shared_ptr() {
    34. 		cout<<"Shared_ptr的析构函数"<< " use_num=" << ptr->use_num << endl;
    35. 		if (--ptr->use_num == 0) {
    36. 			delete ptr;
    37. 		}
    38. 	}
    39.  
    40. private:
    41. 	Res_ptr* ptr;//指向计数类Res_ptr
    42. };
    43.  
    44. int main() {
    45. 	
    46. 	{
    47. 		Shared_ptr<int>hpA = Shared_ptr<int>(new int(42));
    48. 		{
    49. 			Shared_ptr<int>hpB(hpA);
    50. 			Shared_ptr<int>hpC(hpB);
    51. 			Shared_ptr<int>hpD = hpA;
    52. 		}
    53. 		cout << "内层括号结束！" << endl;
    54. 	}
    55. 	cout << "中层括号结束！" << endl;
    56. 	return 0;
    57. }

     

  • 相关阅读:
    001 Creating your first app with PySide6
    轻游戏风格虚拟资源付费下载模板Discuz论坛模板
    HTML做一个简单的页面（纯html代码）地球专题学习网站
    AI内容生成时代：该如何和AI对话？
    选择器汇总
    SpringSecurity自定义多Provider时提示No AuthenticationProvider found for问题的解决方案与原理（四）
    FlyBird
    【学习笔记】CF1784F Minimums or Medians
    动态代理解决方案
    端到端图像压缩《Checkerboard Context Model for Efficient Learned Image Compression》
  • 原文地址：https://blog.csdn.net/Jason6620/article/details/126223543