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

A steria.

已于 2023-03-27 20:05:57 修改

阅读量2.7k

点赞数 4

分类专栏： C++笔记代码+运行结果新手入门文章标签： c++ 算法开发语言

于 2022-11-15 22:36:12 首次发布

本文链接：https://blog.csdn.net/m0_59052131/article/details/127822226

版权

代码+运行结果同时被 3 个专栏收录

40 篇文章 2 订阅

订阅专栏

新手入门

31 篇文章 0 订阅

订阅专栏

C++笔记

22 篇文章 2 订阅

订阅专栏

1.什么是模板？

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

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

2.类模板的定义如下：


template<类型模板参数表>
class 类名
{
	…… //类声明体
}; //再次指出分号不可少
template<类型模板参数表>
返回类型 类名<模板参数表>::成员函数名1(形参表)
{
	……；//成员函数定义体
}
……
template<类型模板参数表>
返回类型 类名<模板参数表>::成员函数名n(形参表)
{
	……；//成员函数n定义体
}
//类型替换的过程被称为模板实例化 template instantiation
1

3.模板分类？

1.模板参数有两种：

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

2.模板的类型

1.函数模板

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

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

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

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

int Max(int a, int b)
{
	return a > b ? a : b;
}

double Max(double a, double b)
{
	return a > b ? a : b;
}

char Max(char a, char b)
{
	return a > b ? a : b;
}

void main()
{
	cout << Max(5, 3) << endl;
	cout << Max(5.3, 7.3) << endl;
	cout << Max('C', 'c') << endl;
}

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

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

使用模板

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

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

template<>
const char* Max(const char* a, const char* b)
{
	cout << "const char* Max" << endl;
	return strcmp(a, b) > 0 ? a : b;
}

主函数

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

运行结果

2.类模板

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

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

类模板特化

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

特化的作用和好处

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

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

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

template<class T>
class A
{
public:
	A(T i) :m_i(i) {}
	void print()
	{
		cout << "m_i = " << m_i << endl;
	}
private:
	T m_i;
};
//vector  list stack  queue

template<>
class A<const char*>
{
public:
	A(const char* i)
	{
		cout << "A const char*" << endl;
		m_i = new char[strlen(i) + 1];
		strcpy_s(m_i, strlen(i) + 1, i);
	}
	void print()
	{
		cout << "A::m_i = " << m_i << endl;
	}
	~A()
	{
		delete[]m_i;
	}
private:
	char* m_i;
};
void main()
{
	A<int> a(4);  //将int当成参数传递给模板中的T--》模板类
	a.print();
	A<char> b('6');
	b.print();
	A<double> c(3.5);
	c.print();
	A<const char*> d("helloworld");
	d.print();
}

4.模板实例化

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

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

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

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

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


#include <algorithm>
bool great(char a, char b)
{
	return a > b;
}
class Great
{
public:
	bool operator()(char a, char b)
	{
		return a > b;
	}
};
template<class T>
class GREAT
{
public:
	bool operator()(T a, T b)
	{
		return a > b;
	}
};
void main()
{
	//int a[] = { 7,6,8,9,0,2,2,3,4,5,6,7 };
	char a[] = { '1','a','h','5','3','2','d','k','v','0','x' };
	int n = sizeof(a) / sizeof(a[0]);
	//sort(a, a + n); //将a到a+n从小到大进行排序---模板
	//sort(a, a + n, greater<int>());  //用的库中的greater
	//sort(a, a + n, great);
	//sort(a, a + n, Great()); //调用Great类中的()重载
	sort(a, a + n, GREAT<char>());
	for (int i = 0; i < n; i++)
		cout << a[i] << " ";
	cout << endl;
}

5.模板实现链栈

1.C语言版


class MyStack
{
private:
	struct StackNode
	{
		int data;
		StackNode* next;
	public:
		StackNode(int val = 0, StackNode* p = nullptr)
			:data(val), next(p) {}
	};
private:
	StackNode* top; // heap;
	int cursize;
	void clone(const MyStack& s)
	{
		Clear();
		cursize = s.cursize;
		StackNode* p = s.top;
		if (p == nullptr) return;
		top = new StackNode(p->data); //
		StackNode* tail = top;
		p = p->next;
		while (p != nullptr)
		{
			tail = tail->next = new StackNode(p->data);
			p = p->next;
		}
	}
public:
	MyStack() :top(nullptr), cursize(0) {}
	MyStack(const MyStack& s)
		:top(nullptr), cursize(s.cursize)
	{
		clone(s);
	} // MyStack yous(mys);
	MyStack& operator=(const MyStack& s)
	{
		if (this != &s)
		{
			clone(s);
		}
		return *this;
	} // mys = hes;// top;
	~MyStack()
	{
		Clear();
	}
	void Clear()
	{
		while (top != nullptr)
		{
			StackNode* q = top;
			top = q->next;
			delete q;
		}
		cursize = 0;
	}
	int Size() const { return cursize; }
	bool Empty() const { return Size() == 0; }
	void Push(int val)
	{
		top = new StackNode(val, top); // 1 2 heap
		cursize += 1;
	}
	int& Top() { return top->data; }
	const int& Top()const { return top->data; }
	void Pop()
	{
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;
	}
	bool GetTop(int& val)
	{
		if (Empty()) return false;
		val = top->data;
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;
		return true;
	}
};
int main()
{
	MyStack mys;
	for (int i = 0; i < 10; ++i)
	{
		mys.Push(i);
	}
	MyStack ys(mys);
}

2.C++版本


template<class T> //
class MyStack
{
public:
	struct StackNode
	{
		T data; // int data;
		StackNode* next;
	public:
		StackNode(const T& val = T(), StackNode* p = nullptr)
			:data(val), next(p) {}
	};
private:
	StackNode* top; // heap;
	int cursize;
	void clone(const MyStack& s)
	{
		Clear();
		cursize = s.cursize;
		StackNode* p = s.top;
		if (p == nullptr) return;
		top = new StackNode(p->data); //
		StackNode* tail = top;
		p = p->next;
		while (p != nullptr)
		{
			tail = tail->next = new StackNode(p->data);
			p = p->next;
		}
	}
public:
	MyStack() :top(nullptr), cursize(0) {}
	MyStack(const MyStack<T>& s)
		:top(nullptr), cursize(s.cursize)
	{
		clone(s);
	} // MyStack yous(mys);
	MyStack<T>& operator=(const MyStack<T>& s)
	{
		if (this != &s)
		{
			clone(s);
		}
		return *this;
	} // mys = hes;// top;
	~MyStack()
	{
		Clear();
	}
	void Clear()
	{
		while (top != nullptr)
		{
			StackNode* q = top;
			top = q->next;
			delete q;
		}
		cursize = 0;
	}
	int Size() const { return cursize; }
	bool Empty() const { return Size() == 0; }
	void Push(const T& val) // T
	{
		top = new StackNode(val, top); // 1 2 heap
		cursize += 1;
	}
	T& Top() { return top->data; }
	const T& Top()const { return top->data; }
	void Pop()
	{
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;
	}
	bool GetTop(T& val);
};
template<class T>
bool MyStack<T>::GetTop(T& val)
{
	if (Empty()) return false;
	val = top->data;
	StackNode* q = top;
	top = q->next;
	delete q;
	cursize -= 1;
	return true;
}
int main()
{
	MyStack<int> imys;
	MyStack<char> cmys;
	MyStack<Point> pmys;
	MyStack<int>::StackNode x;
	for (int i = 0; i < 3; ++i)
	{
		pmys.Push(Point(i, i + 10));
	}
	Point px;
	while (pmys.GetTop(px))
	{
		cout << px.PointX() << " : " << px.PointY() << endl;
	}
}

A steria.

关注

4
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
C++之函数模板、类模板、模板的特化

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

扫一扫