C++学习------模板

最新推荐文章于 2022-11-16 13:53:39 发布
最新推荐文章于 2022-11-16 13:53:39 发布
阅读量704 收藏 8
点赞数 2
分类专栏： C/C++ 文章标签： C++模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bitboss/article/details/52467651
版权

 模板<template>



 本篇博客阐述主要内容有：

 1.模板的定义
 2.模板函数
 3.模板类
 4.C++容器


-----------------------------------------------------


   模板：望文生义，就是一个模子，在C++中提供重用源代码的方法；

   函数的重载，就是解决函数接收不同类型的参数的问题而产生的，但是，我们往往是不愿意这样做的，因为这样的话，等于多写了一份代码，拉长了代码长度，于是，就有了模板的存在，模板只需要你写一份代码就可以实现不同类型数据的复；模板的一般使用方式是： template<class T,...>或者template<typename T,...> 尖括号里的模板参数；


例如下面这个简单的例子<函数模板>： 

#include<iostream>
#include<string>

using namespace std;

template<typename T>
bool Equal(const T& a,const T& b)
{
	return a==b;
}

int main()
{
	cout<<Equal<int>(1,2)<<endl;//注意使用的方式，<传参类型>
	cout<<Equal<int>(1.1,2)<<endl; //错误！ 注意模板参数的匹配
	cout<<Equal<string>("aaaaa","aaaaa")<<endl;//不同类型的参数

	system("pause");
	return 0;
}

 这样就实现了不同类型参数的函数调用，那么，模板函数实现的机制是什么呢？


其实，这些事情都是编译器在默默的帮你完成. 






 模板类


 我们知道类的实现也依赖于类成员的基本类型，那么模板是怎样实现类的呢？


 举个简单例子： 


#include<iostream>

using namespace std;

template<class T = int>// class 或者 typename 是一样的，类的模板参数可以有默认参数；
class Seqlist
{
	T _data;
	int _size;
	int _capacity;
public:
	Seqlist (const T& data,const int size,const int capacity)
		:_data(data)
		,_size(size)
		,_capacity(capacity );
	{}
};


  写过顺序表的同学都知道，顺序表中的数据类型我们一般写的都是int，或者宏定义一下数据类型，为了方便以后数


据类型的修改，但是其实还是很麻烦的，而我再上面简单的用模板参数实现了顺序表数据成员的定义，这样后面所有


的类型都是T类型的；这样，同学们也可以试着用模板参数实现顺序表和链表；


  模板的能力远不止这样，以后我会写关于类型萃取<模板的特化>的博客也是用的模板，还有已经写过的智能指针中


也用了模板！


  《浅析智能指针一》

  《浅析智能指针二》

 在C++中有容器这样一个概念，比如我们所知道的栈和队列，我在下面贴出模板参数实现栈和队列的模拟实现：

-------------------------------------------------------------------------------------

 模板参数实现栈

#include<iostream>
#include<string>
#include<cassert>

using namespace std;

template<class T>
class SeqList
{
public:
	SeqList ()
		:_pdata(NULL)
		,_size(0)
		,_capacity(3)
	{
		_pdata = new T[3];
	}
	~SeqList ()
	{
		if(_pdata != NULL)
		{
			delete[] _pdata;
			_size = 0;
			_capacity = 0;
		}
	}

	void Display()
	{
		for(int i = 0; i<_size; i++)
		{
			cout<<_pdata[i]<<" ";
		}
		cout<<endl;
	}

	void PushBack(const T& data);
	void PushFront(const T& data);
	void PopBack();
	void PopFront();
	void Sort();
	int Find(const T& P);
	void Intsert(const int& pos,const T& data);
	void Remove(const T& data);
	void RemoveAll(const T& data);


	T& operator[](int size)
	{
		assert(size<_size);
		assert(size>=0);

		return _pdata[size];
	}
	 
public:
	void CheckCapacity()
	{
		int NewCapacity = _capacity*2 + 3;
		if(_size == _capacity)
		{
			T* tmp = new T[NewCapacity];
			
			for(int i = 0; i<_size; i++)
			{
				tmp[i] = _pdata[i];
			}
			delete[] _pdata;
			_pdata = tmp;
			_capacity = NewCapacity ;

		}
	}

	T* _pdata;
	int _size;
	int _capacity;
};

template<typename T>
int SeqList <T>::Find(const T& data)
{
		int i = 0;

		for(i= 0 ; i < _sz; i++)
		{
			if(_pdata[i] == data)//注意这里的等号，千万别写成赋值等；
				return i;
		}
		return -1;
}

template<typename T>
void SeqList<T>:: PushBack(const T& data)
	{
		CheckCapacity ();
		_pdata[_size] = data;
		_size++;
	}

template<class T>
void SeqList<T>::PushFront(const T& data)
{
	    CheckCapacity();
		int length =  _size;
		while(length)
		{
			_pdata[length]=_pdata[length-1];
			length--;
		}
		_pdata[0] = data;
		_size++;
}

template<typename T>
void SeqList <T>::PopBack ()
{
			if(_size>=1)
		{
			_size-=1;
		}
}

template<typename T>
void SeqList <T>::PopFront()
{
			int len = 0;
		while(len<_size-1)
		{
			_pdata[len] = _pdata[len+1];
			len++;
		}
		_size--;
}

template<typename T>
void SeqList <T>::Intsert(const int& pos, const T& data)
{
		CheckCapacity ();

		int index = Find(pos);
		if(index>=0)
		{
			int length = _size;
		while(length > index)
		{
			_pdata[length]=_pdata[length-1];
			length--;
		}
		_pdata[index] = data;
		_size++;
		}
}

template<typename T>
void SeqList <T>::Remove(const T& data)
{
			int index = Find(data);

		if(index>=0)
		{
		while(index<_size-1)
		{
			_pdata[index] = _pdata[index+1];
			index++;
		 }
		}
		_size--;
}

template<typename T>
void SeqList <T>::RemoveAll (const T& data)
{
		while(Find(data)>=0)
		{
			Remove(data);
		}
}

template<typename T>
void SeqList <T>::Sort ()
{
	for(int i = 0; i<_size-1; i++)
	{
		for(int j = 0; j < _size-i-1; j++)
		{
			if(_pdata[j]<_pdata[j+1])
			{
				T tmp = _pdata [j];
				_pdata [j] = _pdata [j+1];
				_pdata [j+1] = tmp;
			}
		}
	}
}

template<typename T, typename Container>
class Stack
{
public:
	void Push(const T& data)
	{
		_con.PushBack(data);
	}
	T& Top()
	{
		int sz = _con._size - 1;
		return _con._pdata[sz];
	}
	bool Empty()
	{
		return _con._size == 0;
	}
	void Pop()
	{
		_con.PopBack();
	}
	void Display()
	{
		while(!Empty())
		{
			cout<<Top()<<"  ";
			Pop();
		}
	}
private:
	Container _con;
};

void test()
{
	SeqList<string> s;
	SeqList<int> s1;
	s1.PushBack(2);
	s1.PushBack(5);
	s1.PushBack(4);
	s1.PushBack(6);
	s.PushBack ("aaaaaaaaaaaaaa");
	s.PushBack ("dsadsas");
	s.PushBack ("ssssssssssss");
	s.PushBack ("sdasadadafffffffffffffffffffffffffffffffffff");
	s.PushBack ("sdasdas");
	s1.Sort ();
	s1.Display ();
}

void test1()
{
	Stack<int , SeqList<int>> s;
	s.Push (1);
	s.Push (1);
	s.Push (3);
	s.Push (4);
	s.Push (2);
	s.Display ();
}
int main()
{
	test1();
	system("pause");
	return 0;
}


-----------------------------------------------------------------------------------------------------

模板参数实现队列


// 模板参数模拟实现队列

#include<iostream>

using namespace std;

template<typename T>
struct Node
{
	Node(const T& d)
		:_next(NULL)
		,_prev(NULL)
		,_data(d)
	{}

	T _data;
	Node<T>* _next;
	Node<T>* _prev;
};

template<typename T>
class LinkList
{
public:
	LinkList ()
		:_head(NULL)
		,_tail(NULL)
	{}

	~LinkList ()
	{
		Node<T>* cur =_head;

		while(cur)
		{
			Node<T>* tmp = cur;
			cur = cur->_next ;
			delete tmp;
		}

		_head = _tail = NULL;
	}

	void PushBack(const T& data);
	void PushFront(const T& data);
	void PopBack();
	void PopFront();
	void Remove(const T& data);
	void RemoveAll(const T& data);
	void Sort();
	void Display();
	Node<T>* GetHead()
	{
		return _head;
	}
private:

	Node<T>* _head;
	Node<T>* _tail;
};

template<typename T>
void LinkList<T>::PushBack(const T& data)
{
	Node<T>* pNode = new Node<T>(data);
	if(_head==NULL)
	{
		_head = _tail = pNode; 
	}
	else
	{
		_tail->_next = pNode;
		pNode->_prev = _tail;
		_tail = pNode ;
	}
}

template<typename T>
void LinkList <T>::PushFront(const T& data)
{
	Node<T>* pNode = new Node<T>(data);

	if(_head==NULL)
	{
		_head = _tail = pNode;
	}
	else
	{
		pNode->_next = _head;
		_head->_prev = pNode;
		_head = pNode;
	}
}

template<typename T>
void LinkList <T>::PopBack ()
{
	if(_head==NULL)
		return;
	else if(_head->_next == NULL)
	{
		delete _head;
		_head = _tail = NULL;
	}
	else
	{
		Node<T>* tmp = _tail;
	    _tail = _tail->_prev ;
	    _tail->_next = NULL;
	    delete tmp;
	}
}

template<typename T>
void LinkList <T>::PopFront ()
{
	if(_head==NULL)
		return;
	Node<T>* tmp = _head;
	_head->_prev = NULL;
	_head = _head->_next ;
	delete tmp;
}

template<typename T>
void LinkList <T>::Remove (const T& data)
{
	Node<T>* cur = _head;

	while(cur)
	{
		if(cur->_data == data)
		{
			if(cur->_prev == NULL)
			{
				PopFront ();
			}
			else if(cur->_next == NULL)
			{
				PopBack ();
			}
			else
			{
				Node<T>* t = cur;
				cur->_next ->_prev = cur->_prev ;
				cur->_prev ->_next = cur->_next ;
				delete t;
			}
			return;
		}
		cur = cur->_next ;
	}
}

template<typename T>
void LinkList<T>::RemoveAll (const T& data)
{
	Node<T>* cur = _head;

	while(cur)
	{

		if(cur->_data == data)
		{
			if(cur == _head)
			{
				cur = cur->_next ;
				PopFront ();
				
			}
			else if(cur->_next == NULL)
			{
				PopBack ();
				cur = NULL;
				break;
			}
			else
			{

				/*Node<T>* t = cur->_next;
				cur->_next ->_prev = cur->_prev ;
				cur->_prev ->_next = cur->_next ;
				delete cur;
				cur = t;*/
				cur->_data = _tail->_data ;
				PopBack();
			}
		}
		else
			cur = cur->_next ;
	}
}

template<typename T>
void LinkList <T>::Sort ()
{
	//链表的冒泡排序；

   Node<T>* cur = NULL;
   Node<T>* teil = NULL;

	cur = _head ;

	while(cur != teil)
	{
		while(cur->_next != teil)
		{
			if(cur->_data > cur->_next ->_data )
			{
				T tmp = cur->_data ;
				cur->_data = cur->_next ->_data ;
				cur->_next ->_data = tmp;
			}
			cur = cur->_next ;
		}
		teil = cur;
		cur = _head;
	}
	return ;
}

template<typename T>
void LinkList<T>::Display()
{
	Node<T>* tmp = _head;

	while(tmp)
	{
		cout<<tmp->_data<<"  ";
		tmp = tmp->_next;
	}
	cout<<endl;
}

template<typename T,typename Container>
class Queue
{
public:
	bool Empty()
	{
		return _con.GetHead() == NULL;
	}
	Node<T>& Front()
	{
		return *_con.GetHead();  
	}
	void Back(const T& data)
	{
		
	}
	void Push(const T& data)
	{
		_con.PushBack(data);
	}
	void Pop()
	{
		_con.PopFront();
	}
	void Dispaly()
	{
		while(!Empty())
		{
			cout<<Front()._data<<endl;
			Pop(); 
		}
	}
private:
	Container _con;
};

void test1()
{
	Queue<int , LinkList<int> > s;
	s.Push (1);
	s.Push (1);
	s.Push (1);
	s.Push (2);
	s.Dispaly ();
}

void  test()
{
	LinkList<int> l;
	l.PushBack (1);
	l.PushBack (4);
	l.PushBack (2);
	l.PushBack (1);
	l.PushBack (2);
	l.PushBack (6);
	l.PushFront (4);
	l.Sort ();
	//l.Remove (1);
	//l.RemoveAll (3);
	//l.PopBack ();
	/*l.PopBack ();
	l.PushFront (4);
	l.PopFront ();*/
	l.Display ();

}

int main()
{
	test1();
	system("pause");
	return 0;
}


John__xs
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模板关键字-template
DrCHENJI的博客
12-29 1386
学习如何定义模板
C++ - SGI 版本 STL源码
10-25
通过研究SGI版STL源码，开发者不仅可以深入理解C++ STL的工作原理，还能学习如何设计高效的数据结构和算法。这对于提升C++编程技能，优化代码性能，以及自定义STL容器和算法都大有裨益。在实际项目中，理解和利用STL...
顺序表(SeqList)
aghe452077的博客
12-16 533
---恢复内容开始--- 　　数据结构在上周结课，接下来就是为期几周的上机实验，说是实验课我感觉还不如不上。几乎每个人都是按着老师的要求把书上的代码打一遍，变都不变。一遍以后连自己打的什么都不知道。 与其说是实验课，我感觉不如叫它打字练习课。 　　老师做的并没错，错的是学生对于这节课的态度，老师已经把该讲的讲过了，而上机就是学生们自己领悟的过程，对于代码不能打一遍就是一遍过去了。要...
C++实验三 模板
Keiji582的博客
11-16 676
模板函数与模板类实验环境模板概念特化模板函数模板类队列类 实验环境 操作系统：win10 gcc：8.1.0 开发软件：qt5.14.2 模板概念 在C++的相关代码开发中，我们常常会遇到的是关于代码通用性的问题；模板就是C++支持参数化程序设计的工具，通过它可以实现参数化多态性。这里可以看一下两个例子。 int sum(int x,int y) { return x+y; } double sum(double x,double y) { return x+y; } 事实上两个函数除了数据类型以外进
数据结构——线性表
minyuanxiani的专栏
09-05 578
#include using namespace std; #define Listsize 100 //表空间的大小可根据实际需要而定，这里假设为100 typedef int DataType; //DataType的类型可根据实际情况而定，这里假设为int typedef struct { DataType data[Listsize]
《Effect C++》学习------基本知识
冬之晓
08-10 3804
术语我觉得C++里面比较重要的基础就是一些术语。 - 首先较为重要的术语就是声明式，它是用来告诉编译器某个东西的名称和类型，但略去细节。如下面几个例子：extern int x; //对象声明式 std::size_t numDigits(int number); //函数声明式 class Widget; //类声明式 //下面的一个声明式我也不熟，从没用过！ template<ty
C++-模板及智能指针实现链表
mounmory的博客
10-13 853
深入学习C++，练习使用模板和智能指针，实现了几个链表功能
C++学习--侯捷，黑马
Chasing的博客
10-30 4085
C++ STL 六大板块 容器 分配器 算法 迭代器 适配器 仿函式 vector<int, allocator> 其中尖括号表示模板 vector.begin() 表示容器中的第一个元素，而vector.end()表示容器中的最后一个元素的后面一个位置。称为前闭后开区间 容器 结构与分类 序列容器 关联容器 ...
Opencv (C++)系列学习---模板匹配
qiaodahua的博客
11-16 3990
文章介绍了opencv(c++)中模板匹配算法cv::matchTemplate的具体参数含义和用法的实例，尤其对其匹配方法进行了具体介绍，以及在匹配后对结果的处理，通过minMaxLoc算子提取出匹配结果最好的点。
s-function的介绍
weixin_42736130的博客
04-07 1万+
先占个坑，好督促自己认真学习，及时更新博客。
CCF-CSP认证备考要点
热门推荐
海岛Blog
11-02 7万+
1.注意事项 　　报名时考试语言选择ALL。编程语言可以选C/C++、Java或Python，不同题可以选用不同语言。 　　考试时允许携带纸质的书籍和资料，携带纸质资料有助于提高考试成绩。 ２.考前准备 　　(1)不裸考 　　了解历年考题，了解考题的题型、内容和难度，并且逐题做过。 　　官方网站：CCF计算机职业资格认证。 　　在官方网站上注册用户，登录官方网站，逐题练习历年考题。 　　(2)阅读题解 　　通过阅读历年题解是一种快速学习的好方法，可以了解解题方法，积累解题经验。 ..
基于C++的ACM-ICPC模板
02-22
【标题】：“基于C++的ACM-ICPC模板...通过学习和使用这套模板，选手可以提升自己的编程效率，提高在比赛中的竞争力。同时，对于初学者，也能更好地理解和掌握C++在实际问题中的应用，为未来的编程之路打下坚实的基础。
Dev-c++ 5.9.2
最新发布
06-22
Dev-C++ 5.9.2 是一个轻量级且免费的集成开发环境（IDE），专为C和C++编程语言设计。它以其简洁的界面和易于使用的特性深受初学...总体来说，Dev-C++ 5.9.2是一个适合初学者和专业人士学习及实践C/C++语言的优秀选择。
Dev-C++ 6.2.zip
01-30
对于C++编程，Dev-C++支持标准模板库（STL），这是C++的一个重要部分，包含了容器、算法和迭代器等组件，极大地丰富了编程的可能性。此外，IDE还可能提供了对C++11、C++14乃至C++17新标准的支持，包括lambda表达式、...
C-C++资料集
03-28
它们可能还会包含更高级的主题，如面向对象编程（C++中的类、继承、多态）、模板、STL（标准模板库）等。学习者可以通过这些教程系统地了解C-C++语言，并通过实践项目进行巩固。 【C.福利：还在为自学编程头痛吗？...
编译错误类型： 必须定义入口点
John的博客
05-12 5万+
LINK : fatal error LNK1561: 必须定义入口点 #   经常有同学写完程序编译时会发现有这样的错误： LINK : fatal error LNK1561: 必须定义入口点； #   我发现有这样两种情况下会发生这样的错误（都是自己犯过的）； @  主函数  int  main() 写成了  int mian();    都是粗心惹的祸；这
C和C++的区别和联系（扩展知识）
John的博客
03-17 4万+
2017/3/17 复习整理：C/C++区别与联系； 关于C和C++的区别是面试中经常会被问到的问题，本着即将面试的心态，进行知识整理，并对小知识点进行扩展； C/C++的联系： C++是C的超集，兼容大部分C的语法的结构； 联系嘛我只能想到这个，毕竟cplusplus嘛！ C/C++区别： 第一点就应该想到C是面向过程的语言，而C++是面向对象的语言，一般简历上第一条都
单链表排序之冒泡排序
John的博客
06-07 3万+
***单链表排序之冒泡排序*** /* 前段时间刚学会几种排序方法，最近学习了单链表，就用来试试，本篇链表的排序方法讲述的是 单链表的冒泡排序；（注意：请仔细看准节点结构体的包装和头指针的包装再阅读以下代码）； 冒泡排序的思想和冒泡排序数组的方法以及冒泡排序的优化，我都已经在冒泡排序的文章中介绍了； 冒泡排序链接：http://blog.csdn.
单链表排序之选择排序
John的博客
06-07 1万+
***单链表排序之选择排序*** /* 前段时间刚学会几种排序方法，最近学习了单链表，就用来试试，本篇链表的排序方法讲述的是 单链表的选择排序；（注意：请仔细看准节点结构体的包装和头指针的包装再阅读以下代码）； 选择排序的基本思想：对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则 用一个变量k来记住他的位置，接着第二次比较，前面“后一个元素”
基于Simulink的S-Function建模PPT课件（MATLAB学习资料）.pptx
01-13
Simulink S-Function是Simulink模块的计算机语言描述，可以使用M、C/C++、Ada、Fortran语言以MEX文件的形式编写。S-Function以特殊的方式与Simulink方程求解器交互，这种交互与Simulink内部的运算有着密切的关系。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值