• C++之函数模板、类模板、模板的特化

    目录

    1.什么是模板？

    2.类模板的定义如下：

    3.模板分类？

    1.模板参数有两种：

    2.模板的类型

    1.函数模板

     2.类模板

    4.模板实例化

     5.模板实现链栈

    1.C语言版

    2.C++版本                         

    1.什么是模板？

    模板是c++的一种特性，允许函数或者类（对象）通过泛型（generic types）的形式表现或者运行模板可以使得函数或类在对应不同的类型（types）的时候正常工作，而无需为每一种类型分别写一份代码。

    为了代码重用，代码就必须是通用的；通用的代码就必须不受数据类型的限制。那么我们可以把数 据类型改为一个设计参数。这种类型的程序设计称为参数化(parameterize) 程序设计。软件模块由模板 (template) 构造。 包括函数模板(function template)和类模板(class template)。

    2.类模板的定义如下：

    1.  
    2. template<类型模板参数表>
    3. class 类名
    4. {
    5. 	…… //类声明体
    6. }; //再次指出分号不可少
    7. template<类型模板参数表>
    8. 返回类型 类名<模板参数表>::成员函数名1(形参表)
    9. {
    10. 	……；//成员函数定义体
    11. }
    12. ……
    13. template<类型模板参数表>
    14. 返回类型 类名<模板参数表>::成员函数名n(形参表)
    15. {
    16. 	……；//成员函数n定义体
    17. }
    18. //类型替换的过程被称为模板实例化 template instantiation
    19. 1

    3.模板分类？

    1.模板参数有两种：

    模板类型参数和模板非类型参数

    2.模板的类型

    1.函数模板

    函数模板是参数化的一族函数（a famliy of functions）

    通过函数模板，可以实例化一系类函数，这些函数都给予同一套模板框架，但是作用在不通类型的参数上

    示例 ：（针对不同的数据类型 比较两个数据的大小）

    求最大值：int型、char型。double型等等

    1. int Max(int a, int b)
    2. {
    3. 	return a > b ? a : b;
    4. }
    5.  
    6. double Max(double a, double b)
    7. {
    8. 	return a > b ? a : b;
    9. }
    10.  
    11. char Max(char a, char b)
    12. {
    13. 	return a > b ? a : b;
    14. }
    15.  
    16. void main()
    17. {
    18. 	cout << Max(5, 3) << endl;
    19. 	cout << Max(5.3, 7.3) << endl;
    20. 	cout << Max('C', 'c') << endl;
    21. }

    模板参数是由传递给模板函数的实参决定的

    不允许自动类型转换：每个T必须严格匹配

    使用模板

    1. template<class T>             //函数模板--经过类型参数化--->模板函数
    2. T Max(T a, T b)
    3. {
    4. 	return a > b ? a : b;
    5. }

     //模板的特化--具体化

    1. template<>
    2. const char* Max(const char* a, const char* b)
    3. {
    4. 	cout << "const char* Max" << endl;
    5. 	return strcmp(a, b) > 0 ? a : b;
    6. }

    主函数

    1. void main()
    2. {
    3. 	cout << Max(4, 6) << endl;  //类型参数化 int
    4. 	cout << Max(3.4, 1.2) << endl; //double
    5. 	cout << Max('a', '1') << endl; //char
    6. 	cout << Max("333", "555") << endl; //const char*
    7. }

    运行结果

     2.类模板

    与函数模板类似，类也可以通过参数泛化，从而可以构建出一族不同的类实例（对象）

    类模板实参可以是某一类型或常量（仅限int或enum）

    类模板特化

    允许对一个类模板的某些模板参数类型做特化

    特化的作用和好处

    对于某种特殊的类型，可能可以做些特别的优化或提供不同的实现

    避免在实例化的时候引起一些可能不好的行为

    特化一个类模板的时候也意味着需要特化其所有参数化的成员函数

    1. template<class T>
    2. class A
    3. {
    4. public:
    5. 	A(T i) :m_i(i) {}
    6. 	void print()
    7. 	{
    8. 		cout << "m_i = " << m_i << endl;
    9. 	}
    10. private:
    11. 	T m_i;
    12. };
    13. //vector  list stack  queue
    14.  
    15. template<>
    16. class A<const char*>
    17. {
    18. public:
    19. 	A(const char* i)
    20. 	{
    21. 		cout << "A const char*" << endl;
    22. 		m_i = new char[strlen(i) + 1];
    23. 		strcpy_s(m_i, strlen(i) + 1, i);
    24. 	}
    25. 	void print()
    26. 	{
    27. 		cout << "A::m_i = " << m_i << endl;
    28. 	}
    29. 	~A()
    30. 	{
    31. 		delete[]m_i;
    32. 	}
    33. private:
    34. 	char* m_i;
    35. };
    36. void main()
    37. {
    38. 	A<int> a(4);  //将int当成参数传递给模板中的T--》模板类
    39. 	a.print();
    40. 	A<char> b('6');
    41. 	b.print();
    42. 	A<double> c(3.5);
    43. 	c.print();
    44. 	A<const char*> d("helloworld");
    45. 	d.print();
    46. }

    4.模板实例化

    模板的声明（declaration）其实并未给出一个函数或者类的完全定义（definition），只是提供了一个函数或者类的语法框架（syntactical skeleton）

    实例化是指从模板构建出一个真正的函数或者类的过程。用具体类型代替模板参数的过程叫做实例化；从而产生一个模板实例。

    如果实例化一种类型，而该类型并不支持函数所使用的操作，那么就会导致一个编译错误。

    实例化有两种类型
    1：显示实例化-在代码中明确指定要针对哪种类型进行实例化

    2：隐式实例化-在首次使用时根据具体情况使用一种合适的类型进行实例化

    1.  
    2. #include 
    3. bool great(char a, char b)
    4. {
    5. 	return a > b;
    6. }
    7. class Great
    8. {
    9. public:
    10. 	bool operator()(char a, char b)
    11. 	{
    12. 		return a > b;
    13. 	}
    14. };
    15. template<class T>
    16. class GREAT
    17. {
    18. public:
    19. 	bool operator()(T a, T b)
    20. 	{
    21. 		return a > b;
    22. 	}
    23. };
    24. void main()
    25. {
    26. 	//int a[] = { 7,6,8,9,0,2,2,3,4,5,6,7 };
    27. 	char a[] = { '1','a','h','5','3','2','d','k','v','0','x' };
    28. 	int n = sizeof(a) / sizeof(a[0]);
    29. 	//sort(a, a + n); //将a到a+n从小到大进行排序---模板
    30. 	//sort(a, a + n, greater());  //用的库中的greater
    31. 	//sort(a, a + n, great);
    32. 	//sort(a, a + n, Great()); //调用Great类中的()重载
    33. 	sort(a, a + n, GREAT<char>());
    34. 	for (int i = 0; i < n; i++)
    35. 		cout << a[i] << " ";
    36. 	cout << endl;
    37. }

     5.模板实现链栈

    1.C语言版

    1.  
    2. class MyStack
    3. {
    4. private:
    5. 	struct StackNode
    6. 	{
    7. 		int data;
    8. 		StackNode* next;
    9. 	public:
    10. 		StackNode(int val = 0, StackNode* p = nullptr)
    11. 			:data(val), next(p) {}
    12. 	};
    13. private:
    14. 	StackNode* top; // heap;
    15. 	int cursize;
    16. 	void clone(const MyStack& s)
    17. 	{
    18. 		Clear();
    19. 		cursize = s.cursize;
    20. 		StackNode* p = s.top;
    21. 		if (p == nullptr) return;
    22. 		top = new StackNode(p->data); //
    23. 		StackNode* tail = top;
    24. 		p = p->next;
    25. 		while (p != nullptr)
    26. 		{
    27. 			tail = tail->next = new StackNode(p->data);
    28. 			p = p->next;
    29. 		}
    30. 	}
    31. public:
    32. 	MyStack() :top(nullptr), cursize(0) {}
    33. 	MyStack(const MyStack& s)
    34. 		:top(nullptr), cursize(s.cursize)
    35. 	{
    36. 		clone(s);
    37. 	} // MyStack yous(mys);
    38. 	MyStack& operator=(const MyStack& s)
    39. 	{
    40. 		if (this != &s)
    41. 		{
    42. 			clone(s);
    43. 		}
    44. 		return *this;
    45. 	} // mys = hes;// top;
    46. 	~MyStack()
    47. 	{
    48. 		Clear();
    49. 	}
    50. 	void Clear()
    51. 	{
    52. 		while (top != nullptr)
    53. 		{
    54. 			StackNode* q = top;
    55. 			top = q->next;
    56. 			delete q;
    57. 		}
    58. 		cursize = 0;
    59. 	}
    60. 	int Size() const { return cursize; }
    61. 	bool Empty() const { return Size() == 0; }
    62. 	void Push(int val)
    63. 	{
    64. 		top = new StackNode(val, top); // 1 2 heap
    65. 		cursize += 1;
    66. 	}
    67. 	int& Top() { return top->data; }
    68. 	const int& Top()const { return top->data; }
    69. 	void Pop()
    70. 	{
    71. 		StackNode* q = top;
    72. 		top = q->next;
    73. 		delete q;
    74. 		cursize -= 1;
    75. 	}
    76. 	bool GetTop(int& val)
    77. 	{
    78. 		if (Empty()) return false;
    79. 		val = top->data;
    80. 		StackNode* q = top;
    81. 		top = q->next;
    82. 		delete q;
    83. 		cursize -= 1;
    84. 		return true;
    85. 	}
    86. };
    87. int main()
    88. {
    89. 	MyStack mys;
    90. 	for (int i = 0; i < 10; ++i)
    91. 	{
    92. 		mys.Push(i);
    93. 	}
    94. 	MyStack ys(mys);
    95. }

    2.C++版本                         

    1.  
    2. template<class T> //
    3. class MyStack
    4. {
    5. public:
    6. 	struct StackNode
    7. 	{
    8. 		T data; // int data;
    9. 		StackNode* next;
    10. 	public:
    11. 		StackNode(const T& val = T(), StackNode* p = nullptr)
    12. 			:data(val), next(p) {}
    13. 	};
    14. private:
    15. 	StackNode* top; // heap;
    16. 	int cursize;
    17. 	void clone(const MyStack& s)
    18. 	{
    19. 		Clear();
    20. 		cursize = s.cursize;
    21. 		StackNode* p = s.top;
    22. 		if (p == nullptr) return;
    23. 		top = new StackNode(p->data); //
    24. 		StackNode* tail = top;
    25. 		p = p->next;
    26. 		while (p != nullptr)
    27. 		{
    28. 			tail = tail->next = new StackNode(p->data);
    29. 			p = p->next;
    30. 		}
    31. 	}
    32. public:
    33. 	MyStack() :top(nullptr), cursize(0) {}
    34. 	MyStack(const MyStack& s)
    35. 		:top(nullptr), cursize(s.cursize)
    36. 	{
    37. 		clone(s);
    38. 	} // MyStack yous(mys);
    39. 	MyStack& operator=(const MyStack& s)
    40. 	{
    41. 		if (this != &s)
    42. 		{
    43. 			clone(s);
    44. 		}
    45. 		return *this;
    46. 	} // mys = hes;// top;
    47. 	~MyStack()
    48. 	{
    49. 		Clear();
    50. 	}
    51. 	void Clear()
    52. 	{
    53. 		while (top != nullptr)
    54. 		{
    55. 			StackNode* q = top;
    56. 			top = q->next;
    57. 			delete q;
    58. 		}
    59. 		cursize = 0;
    60. 	}
    61. 	int Size() const { return cursize; }
    62. 	bool Empty() const { return Size() == 0; }
    63. 	void Push(const T& val) // T
    64. 	{
    65. 		top = new StackNode(val, top); // 1 2 heap
    66. 		cursize += 1;
    67. 	}
    68. 	T& Top() { return top->data; }
    69. 	const T& Top()const { return top->data; }
    70. 	void Pop()
    71. 	{
    72. 		StackNode* q = top;
    73. 		top = q->next;
    74. 		delete q;
    75. 		cursize -= 1;
    76. 	}
    77. 	bool GetTop(T& val);
    78. };
    79. template<class T>
    80. bool MyStack::GetTop(T& val)
    81. {
    82. 	if (Empty()) return false;
    83. 	val = top->data;
    84. 	StackNode* q = top;
    85. 	top = q->next;
    86. 	delete q;
    87. 	cursize -= 1;
    88. 	return true;
    89. }
    90. int main()
    91. {
    92. 	MyStack<int> imys;
    93. 	MyStack<char> cmys;
    94. 	MyStack pmys;
    95. 	MyStack<int>::StackNode x;
    96. 	for (int i = 0; i < 3; ++i)
    97. 	{
    98. 		pmys.Push(Point(i, i + 10));
    99. 	}
    100. 	Point px;
    101. 	while (pmys.GetTop(px))
    102. 	{
    103. 		cout << px.PointX() << " : " << px.PointY() << endl;
    104. 	}
    105. }

  • 相关阅读:
    零基础自学javase黑马课程第七天
    时间序列预测(9) — Informer源码详解与运行
    linux 配置静态IPv6地址
    实现最简的内核模块
    HTML基础知识
    柯桥英语口语学校，商务英语BEC考前须知
    【LeetCode-简单题KMP】459. 重复的子字符串
    反弹Shell
    dp线段树优化-最大子段和
    Cadence IC618使用
  • 原文地址：https://blog.csdn.net/m0_59052131/article/details/127822226