02c++模板部分讲解

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量121 收藏
点赞数 2
分类专栏： c++初级 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80434259/article/details/138681704
版权

1理解函数模板

#include<iostream>
using namespace std;

//函数模板
template<typename T> //定义一个模板参数列表
//模板类型参数 typename/class
bool compare(T a, T b)
{
	cout << "template compare: " << endl;
	return a > b;
}

template<>
bool compare(const char* a, const char* b)
{
	cout << "compare(char*)";
	return strcmp(a, b) > 0;
}

//非模板函数
bool compare(const char* a, const char* b)
{
	cout << "normal compare: " << endl;
	return strcmp(a, b) > 0;
}
/*函数调用点,编译器用用户指定的类型,从原来的模板实例化一份函数代码出来*/
int main()
{
	compare<int>(10, 20);
	compare(20, 30); //推导出来是整形 模板实参法推演

	//compare(30, 4.5);b报错,找不到
	compare<int>(30, 3.4); //这样子可以但是被会警告
	//对于某些类型来说,依赖编译器默认实例化的模板代码,代码处理逻辑是有错误的
	compare("aaa", "bbb"); //不能a>b来处理
	//模板的特例化,不是编译器提供的,而是用户提供的实例化
	return 0;
}
//份文件的时候 直接告诉编译器模板指定类型的模板实例化
template bool compare<int>(int, int);
template bool compare<double>(double, double);

2、理解类模板

#include<iostream>
using namespace std;


template<typename T, const int SIZE>
void sort(T* arr)
{
	for (int i = 0; i < SIZE - 1; i++)
	{
		for (int j = 0; j < SIZE - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
//类模板
int main()
{
	int arr[] = { 12,2,2,2,2,2 };
	const int size = sizeof(arr) / sizeof(arr[0]);
	sort<int, size>(arr);
	for (int val : arr)
	{
		cout << val << " ";
	}
	cout << endl;
}

#include<iostream>
using namespace std;
#include<time.h>
template<typename T> //模板+参数列表 = 类名称
class SeqStack
{
public:
	//构造函数和析构函数不要加模板类型参数列表
	SeqStack(int size = 10)
		:_stack(new T[size]),
		_top(0),
		_size(size)
	{}
	~SeqStack()
	{
		delete[]_stack;
		_stack = nullptr;
	}
	SeqStack<T>(const SeqStack<T>& stack)
		:_top(stack._top),
		_size(stack._size)
	{
		_stack = new T[_size];
		//不要用memcopy进行拷贝
		for (int i = 0; i < _top; i++)
		{
			_stack[i] = stack._stack[i];
		}
	}
	SeqStack<T>& operator = (const SeqStack<T>& stack)
	{

		if (this == &stack)return *this;
		delete[] _stack;
		_top = stack._top;
		_size = stack._size;
		_stack = new T[_size];
		//不要用memcopy进行拷贝
		for (int i = 0; i < _top; i++)
		{
			_stack[i] = stack._stack[i];
		}
		return *this;
	}

	void push(const T& val)
	{
		if (full())expand();
		_stack[_top++] = val;
	}
	void pop()
	{
		if (empty())
		{
			return;
		}
		--_top;
	}
	T top() const
	{
		if ((empty()))throw "stack is empty()"; //抛出异常结束
		return _stack[_top - 1];
	}
	bool full()const
	{
		return _top == _size;
	}
	bool empty()const
	{
		return _top == 0;
	}
private:
	T* _stack;
	int _top;
	int _size;
	//顺序栈底层数
	void expand()
	{
		T* ptmp = new T[_size * 2];
		for (int i = 0; i < _top; i++)
		{
			ptmp[i] = _stack[i];
		}
		delete[]_stack;
		_stack = ptmp;
		ptmp = nullptr;
		_size *= 2;
	}
};
int main()
{
	SeqStack<int>stack(4);
	for (int i = 0; i < 20; i++)
	{
		stack.push(rand() % 100);
	}
	while (!stack.empty())
	{
		cout << stack.top() << " ";
		stack.pop();
	}

	cout << endl;
	SeqStack<int>stack1(2);
	stack1.push(1);
	stack1.push(2);
	stack1.push(3);
	stack1.push(4);
	stack1.pop();
	cout << stack1.top();

	return 0;
}

3、SLT实现Vector类

#include<iostream>
using namespace std;

template<class T>
class Vector
{
public:
	Vector(int size = 10)
	{
		_first = new T[size];
		_last = _first;
		_end = _first + size;
	}

	~Vector()
	{
		delete[]_first;
		_first = _last = _end = nullptr;
	}

	Vector(const Vector<T>& rhs)
	{
		int size = rhs._end - rhs._first;
		_first = new T[size]; //空间大小
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; i++)
		{
			_first[i] = rhs._first[i];
		}
		_last = _first + len;
		_end = _first + size;
	}
	Vector<T>& operator=(const Vector<T>& rhs) //拷贝构造
	{
		if (this == &rhs)return *this;
		delete[] _first;
		int size = rhs._end - rhs._first;
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; i++)
		{
			_first[i] = rhs._first[i];
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}

	void push_back(const T& val)
	{
		if (full())
		{
			expand();
		}
		*_last = val;
		_last++;
	}

	void pop_back()
	{
		if (empty())
		{
			return;
		}
		--_last;
	}
	T back()const //返回容器末尾的元素值
	{
		return *(_last - 1);
	}

	bool full()const { return _last == _end; }
	bool empty()const { return _first == _last; }
	int size()const { return _last - _first; }

private:

	void expand()
	{
		int _size = _end - _first;
		T* tmp = new T[_size * 2];
		for (int i = 0; i < _size; i++)
		{
			tmp[i] = _first[i];
		}
		delete[]_first;
		_first = tmp;
		_last = _first + _size;
		_size *= 2;
		_end = _first + _size;
	}
	T* _first; //指向数组的起始的位置
	T* _last; //指向数组有效元素的后继位置
	T* _end; //指向数组空间的后继位置

};
//容器空间分配器
class Test
{
public:
	Test() { cout << "test()" << endl; }
	~Test() { cout << "~test()" << endl; }
};

int main()
{/*
	Vector<int>vec;
	for (int i = 0; i < 20; i++)
	{
		vec.push_back(rand() % 100);
	}
	while (!vec.empty())
	{
		cout << vec.back() << " ";
		vec.pop_back();
	}
	cout << endl;
	vec.push_back(10);
	cout << vec.back() << endl;
	cout << endl;*/
	Vector<Test>vec;
	return 0;
}

6、容器空间配置

#include<iostream>
using namespace std;



/*
template <class _Ty,
	class _Alloc = allocator<_Ty>>
	class Vector
	容器的空间配置器allocator做四件事情 内存开辟 内存释放 对象构造 对象析构
*/

//定义容器的空间配置器，和c++标准库的allocator实现一样
template<typename T>
class Allocator
{
public:
	T* allocate(size_t size) //负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);

	}

	void deallocate(void* p) //负责内存释放
	{
		free(p);
	}

	void construct(T* p, const T& val) //负责对象构造
	{
		new (p) T(val);//定位new
	}
	void destroy(T* p)//负责对象析构
	{
		p->~T();//代表了T类型的析构函数
	}
};
template<typename T, typename Alloc = Allocator<T>>
class Vector
{
public:
	Vector(int size = 10)
	{
		//需要把内存开辟和对象构造分开处理
		//_first = new T[size];
		_first = _allocator.allocate(size);

		_last = _first;
		_end = _first + size;
	}

	~Vector()
	{
		//delete[]_first;
		//析构有效的元素，然后释放_first指针指向的堆内存
		for (T* p = _first; p != _last; p++)
		{
			_allocator.destroy(p); //把first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);//释放堆上的数组内存
		_first = _last = _end = nullptr;
	}

	Vector(const Vector<T>& rhs)
	{
		int size = rhs._end - rhs._first;
		//_first = new T[size]; //空间大小
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; i++)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}

		_last = _first + len;
		_end = _first + size;
	}
	Vector<T>& operator=(const Vector<T>& rhs) //拷贝构造
	{
		if (this == &rhs)return *this;
		//delete[] _first;
		for (T* p = _first; p != _last; p++)
		{
			_allocator.destroy(p); //把first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);//释放堆上的数组内存

		int size = rhs._end - rhs._first;
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; i++)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}

	void push_back(const T& val)
	{
		if (full())
		{
			expand();
		}
		//*_last = val;
		_allocator.construct(_last, val);
		_last++;
	}

	void pop_back()
	{
		if (empty())
		{
			return;
		}
		//--_last;
		--_last;
		_allocator.destroy(_last);
	}
	T back()const //返回容器末尾的元素值
	{
		return *(_last - 1);
	}

	bool full()const { return _last == _end; }
	bool empty()const { return _first == _last; }
	int size()const { return _last - _first; }

private:

	void expand()
	{
		int _size = _end - _first;
		//T* tmp = new T[_size * 2];
		T* tmp = _allocator.allocate(2 * _size);
		for (int i = 0; i < _size; i++)
		{
			//tmp[i] = _first[i];
			_allocator.construct(tmp + i, _first[i]);
		}
		//delete[]_first;
		for (T* p = _first; p != _last; p++)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = tmp;
		_last = _first + _size;
		_end = _first + 2 * _size;
	}
	T* _first; //指向数组的起始的位置
	T* _last; //指向数组有效元素的后继位置
	T* _end; //指向数组空间的后继位置

	Alloc _allocator;//定义i容器中的空间配置项

};
//容器空间分配器
class Test
{
public:
	Test() { cout << "test()" << endl; }
	~Test() { cout << "~test()" << endl; }
	Test(const Test&) { cout << "Test(const Test&)" << endl; }
};

int main()
{
	Test t1, t2, t3;
	cout << "----------" << endl;
	Vector<Test>vec;

	vec.push_back(t1);
	vec.push_back(t2);
	vec.push_back(t3);
	cout << "----------" << endl;
	vec.pop_back(); //只需要析构
	cout << "----------" << endl;


	return 0;
}

在这里插入图片描述

编程小公举
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 模板函数 讲解及实现
AKGWSB 's blog
06-04 1457
目录模板函数：机制介绍模板函数：实现代码 模板函数：机制介绍 在很多时候，我们需要对不同的数据类型做一些操作，但是这些操作是相同的，比如求取一个数组中的最大元素，我们只需： for(int i=0; i<arr.size(); i++) if(arr[i] > max_val) max_val = arr[i]; 可是面对不同的数据类型，我们需要实现不同的函数，比如下面我们需要实现两个函数来选择int或者double数组中的最大值，非常麻烦 int array_max(vector<i
C++ 模板的简易讲解
sfornyu的博客
05-12 1482
C++模板的简易讲解模板的概念模板分类（包含实例化）函数模板类模板 模板的概念 模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 模板的原理是什么：编译器根据调用的函数模板和类模板的类型实例化出对应的函数和类 简而言之一句话，模板就
C++模板详解（函数模板、类模板）
bang___bang_的博客
05-13 2323
本文详细讲解模板：函数模板，类模板，模板特化，非特性模板参数，详细得当适合初学者学习。
C++类模板详解
weixin_44115575的博客
03-27 1240
类模板是一种用来生成类定义的模板，其中可以包含一个或多个类型参数。这些类型参数可以在定义类的时候替换为任意类型，从而使得我们能够创建适用于多种数据类型的通用类定义。类模板的定义使用 template或来声明一个类型参数。
c++模板的讲解
06-02
本文将详细讲解C++模板的概念、声明、使用方法和优点。 一、为什么需要模板？ 在C++中，我们可以使用函数重载来实现不同类型的参数处理。但是，这种方法会导致代码臃肿，难以维护和修改。例如，在上面的代码中，...
C++模板讲解习题及答案
05-08
C++ 模板讲解习题及答案 C++ 模板是 C++ 编程语言中的一种非常重要的概念，它可以实现代码的复用和泛型编程。下面是 C++ 模板的主要知识点和考点： 1. 模板的概念 模板是指可以根据需要实例化出多种类型的函数或类...
如何理解c++模板
05-17
对类模板比较系统的讲解
C++STL标准模板库讲解PPT
10-07
• 容器container：可容纳各种数据类型的数据结构。 • 迭代器：可依次存取容器中元素的东西 • 算法：用来操作容器中的元素的函数模板。
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 399
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C++初探究（2）
Frenemy__的博客
07-09 1275
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 938
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 607
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
[c++] 可变参数模版
l23456789mmmmm的博客
07-07 483
可变参数模板是C++11及之后才开始使用,学校的老古董编译器不一定能用相信大家在刚入门c/c++时都接触过printf函数printf用于将数据格式化输出到屏幕上,它的参数非常有意思,可以支持任意数量,任意类型的多参数.而如果我们想实现类似这种的传参,在C里似乎并不支持c++11提出了可变模板参数来解决这一问题。
C++数据的高效传递--左值引用和右值引用
CHNIM的博客
07-05 378
右值引用主要用于实现移动语义和完美转发。左值引用和右值引用是C++中的两个重要概念。左值引用引用持久存在的对象，而右值引用引用临时对象。通过右值引用，C++实现了移动语义和完美转发，从而提高了程序的效率和灵活性。理解和正确使用它们，对于编写现代、高效的C++代码非常重要。
C-10 凸包
qq_46348003的博客
07-08 203
计算凸包的代码
【LinuxC语言】手撕Http协议之accept_request函数实现(一)
m0_62599305的博客
07-05 739
在计算机网络中，HTTP协议是一种常见的应用层协议，它定义了客户端和服务器之间如何进行数据交换。在这篇文章中，我们将深入探讨Linux C语言中实现HTTP协议的关键部分——accept_request函数。这个函数是服务器处理客户端请求的核心，它负责接收客户端的连接，读取HTTP请求，解析请求内容，并根据请求类型（GET或POST）调用相应的处理函数。我们将详细分析accept_request函数的实现，包括套接字的创建和绑定，监听客户端的连接，接收和解析HTTP请求，以及调用处理函数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值