C++实验三：模板

最新推荐文章于 2024-07-11 22:03:57 发布
最新推荐文章于 2024-07-11 22:03:57 发布
阅读量564 收藏
点赞数
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45802659/article/details/121152077
版权

模板

一、模板函数（compare）

1. 一般模板函数

首先写一个判断是否相等的模板函数，注意声明和函数体都写在头文件中。

//模板函数需要将声明和函数体都放在头文件中
//一般模板函数
template<class T>
bool compare(const T& a, const T& b)
{
	return a == b;
}

2. 特化模板函数

使用模板时会遇到一些特殊的类型需要特殊处理，不能直接使用当前的模板函数，所以此时我们就需要对该类型特化出一个模板函数。
此处，该函数无法针对字符串类型使用，则需特化模板函数。

//上述模板函数对于字符串比较无法使用，所以需要特化
//格式：template<>不用写类型
//      函数名<特化类型>(特化类型 参数1, 特化类型 参数2,...)
//注意声明必须放在头文件中，实例化必须在cpp文件中
template<>
bool compare<const char*>(const char* const& a, const char* const& b);

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

3. 测试

#include<iostream>
#include"queue.h"
using namespace std;
int main()
{
	const int a = 1;
	const int b = 1;
	const char* c = "qwe", * d = "asd";
	cout << compare(a, b) << endl;
	cout << compare(c, d);
}

运行结果：
在这里插入图片描述

4. 小结

一般特化函数格式

template< 模板参数表>
类型名 参数名(参数表)
{
	函数体的定义
}

特化模板函数注意点

  1. 使用模板特化时，必须要先有基础的模板函数（就是上面第一个模板函数）
  2. 使用特换模板函数时格式有要求：
    2.1. template 后直接跟<> 里面不用写类型
    2.2. 函数名<特化类型>（特化类型 参数1， 特化类型 参数2 , …） 在函数名后跟<>其中写要特化的类型
  3. 特化的函数的函数名，参数列表要和原基础的模板函数想相同，避免不必要的错误
  4. 声明必须放在头文件中，实例化必须在cpp文件中

函数模板与函数的区别

  1. 函数模板本身在编译时不会生成任何目标代码，只有由模板生成的实例会生成目标代码。
  2. 被多个源文件引用的函数模板，应当连同函数体一同放在头文件中，而不能像普通函数那样只将声明放在头文件中。
  3. 函数指针也只能指向模板的实例，而不能指向模板本身。

二、模板类Queue或Stack

1. 模板类（Queue，Stack）

类模板格式：

template<模板参数表>
class 类名
{
	类成员声明
};

如类模板QueueItem

template<class Type> class QueueItem
{
	QueueItem(const Type &t) :item(t), next(0){}
	Type item;
	QueueItem * next;
	friend class Queue<Type>;
	friend ostream& operator<<(ostream& os，const Queue<Type> &q);
public:
	QueueItem<Type>* operator++()
	{
		return next;
	}
	Type & operator*()
	{
		return item;
	}
};

模板参数表中参数可以声明为该模板类的友元类
如以上代码第6，7行的友元类
可通过typedef或者using对实例化的类模板定义别名

2. 成员模板函数

  • 在类模板中直接声明然后实例化
  • 如果需要在类模板以外定义其成员函数，则要采用以下的形式（现在类模板中声明成员函数）：
template<模板参数表>
类型名 类名<模板参数标识符列表>::函数名(参数表){}

template<class Type> c1ass Queue
{
public:
	Queue():head(0),tail(0){}
	Queue(const Queue& q):head(0),tail(0)
	{
		copy_items(q);
	}
	template<class It>
	Queue(It beg, It end):head(0),tail(0)
	{
		copy_items(beg,end);
	}
	template<class It> void assign(It beg, It end);
};
template<class Type> template<class It> 
void Queue<Type>::assign(It beg,It end)
{
	destroy();
	copy_items(beg,end);
}

3. 模板特化：模板函数特化、模板成员函数特化、模板类特化

3.1. 模板函数特化

模板函数特化见目录一、模板函数 2.特化模板函数

3.2. 模板成员函数特化

头文件中声明

template<>
void Queue<const char*>::push(const char * const &val) ;
template<>
void Queue<const char*>::pop();

cpp文件中实现

template<>
void Queue<const char*>::push(const char * const &val)
{
	char* new_item = new char[str1en(va1)+1];
	strncpy(new_item, val, strlen(va1)+1);
	QueueItem<const char*> * pt = new QueueItem<const char*>(new_item);
	if(empty())
	{
		head=tail=pt;
	}
	else
	{
		tail->next = pt;
		tail = pt;
	}
}
template<>
void Queue<const char*>::pop()
{
	QueueItem<const char*> * p = head;
	delete head->item;
	head = head- >next;
	delete p;
}

3.3. 模板类特化

//普通类模板
template<模板参数表>
class 类名
{
	类成员声明
};

//模板类特化
template<> 			//<>里为空
class 类名<特化类型> //<>里指明具体类型
{
	类成员声明
};

4. 代码：

queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
//模板函数需要将声明和函数体都放在头文件中
//一般模板函数
template<class T>
bool compare(const T& a, const T& b)
{
	return a == b;
}
//上述模板函数对于字符串比较无法使用，所以需要特化
//格式：template<>不用写类型
//      函数名<特化类型>(特化类型 参数1, 特化类型 参数2,...)
//注意声明必须放在头文件中，实例化必须在cpp文件中
template<>
bool compare<const char*>(const char* const& a, const char* const& b);

template<class Type> class Queue;
template<class Type> class QueueItem
{
	QueueItem(const Type &t) :item(t), next(0){}
	Type item;
	QueueItem * next;
	friend class Queue<Type>;
	friend ostream& operator<<(ostream& os，const Queue<Type> &q);
public:
	QueueItem<Type>* operator++()
	{
		return next;
	}
	Type & operator*()
	{
		return item;
	}
};

template<class Type> 
class Queue
{
public:
	Queue():head(0),tail(0){}
	Queue(const Queue& q):head(0),tail(0)
	{
		copy_items(q);
	}
	template<class It>
	Queue(It beg, It end):head(0),tail(0)
	{
		copy_items(beg,end);
	}
	template<class It> 
	void assign(It beg, It end);
	Queue& operator=(const Queue&);
	~Queue()
	{
		destroy();
	}
	Type& front()
	{
		return head->item; 
	}
	const Type& front() const
	{
		return head->item;
	}
	void push(const Type &) ;
	void pop();
	bool empty() const
	{
		return head==0;
	}
	friend ostream& operator<<(ostream& os, const Queue<Type> &q)
	{
		os<<"< ";
		QueueItem<Type>* p;
		for(p=q.head;p;p=p->next)
		{
			os<<p->item<<" ";
		}
		os<<">";return os;
	}
	const QueueItem<Type>* Head() const
	{
		return head;
	}
	const QueueItem<Type>*End() const
	{
		return (tail==NULL)?NULL:tail->next;
	}
private:
	QueueItem<Type>* head;
	QueueItem<Type>* tail;
	void destroy();
	void copy_items(const Queue &);
	template<class It> 
	void copy_items(It beg,It end);
};

template<class Type>void Queue<Type>::destroy()
{
	while (!empty())
	{
		pop();
	}
}

template<class Type> void Queue<Type>::pop()
{
	QueueItem<Type> * p = head;
	head = head->next;
	delete p;
}
	
template<class Type> void Queue<Type>::push(const Type& val)
{
	QueueItem<Type> * pt = new QueueItem<Type>(val);
	if(empty())
	{
		head = tail = pt;
	}
	else
	{
		tail->next = pt;
		tail = pt;
	}
}
template<>
void Queue<const char*>::push(const char * const &val) ;
template<>
void Queue<const char*>::pop();

template<class Type>
void Queue<Type>::copy_items(const Queue &orig)
{
	for(QueueItem<Type> *pt = orig.head;pt;pt=pt->next)
	{
		push(pt->item);
	}
}

template<class Type>
Queue<Type>& Queue<Type>::operator=(const Queue& q)
{
	destroy();
	copy_items(q);
}

template<class Type> template<class It> 
void Queue<Type>::assign(It beg,It end)
{
	destroy();
	copy_items(beg,end);
}

template<class Type> template<class It> 
void Queue<Type>::copy_items(It beg,It end)
{
	while(beg!=end)
	{
		push(*beg);
		++beg;
	}
}

#endif // QUEUE_H

queue.cpp

#include "queue.h"
#include <string.h>
template<>
bool compare<const char*>(const char * const &a, const char * const &b)
{
	return strcmp(a,b) == 0;
}

template<>
void Queue<const char*>::push(const char * const &val)
{
	char* new_item = new char[strlen(val)+1];
	strncpy(new_item, val, strlen(val)+1);
	QueueItem<const char*> * pt = new QueueItem<const char*>(new_item);
	if(empty())
	{
		head=tail=pt;
	}
	else
	{
		tail->next = pt;
		tail = pt;
	}
}
template<>
void Queue<const char*>::pop()
{
	QueueItem<const char*> * p = head;
	delete head->item;
	head = head- >next;
	delete p;
}

Test.cpp

#include<iostream>
#include"queue.h"
#include <vector>
#include "autoptr.h"
#include "CMatrix.h"
using namespace std;
int main()
{
	//const int a = 1;
	//const int b = 1;
	//const char* c = "qwe", * d = "asd";
	//cout << compare(a, b) << endl;
	//cout << compare(c, d);


	Queue<int> qt;
	double d = 3.3;
	qt.push(1);
	qt.push(d);
	qt.push(10); 
	cout << endl;
	cout << qt;

	short a[5] = { 0,3,6,9 };
	Queue<int> qi(a, a + 5);
	cout << endl;
	cout << qi;
	cout << endl;
	while (!qi.empty())
	{
		cout << qi.front() << " ";
		qi.pop();
	}
	vector<int> vi(a, a + 5);
	qi.assign(vi.begin(), vi.end());
	cout << endl;
	cout << qi;
	cout << endl;

	Queue<const char*> q1;
	q1.push("hi");
	q1.push("I'm");
	q1.push("Jerry");
	cout << q1;
	cout << endl;
	Queue<const char*> q2(q1);
	cout << q2;


    //AutoPtr<CMatrix> h1;
    //double data[6] = {1,2,3,4,5,6};
    //h1->Create(2,3,data);
    //AutoPtr<CMatrix> h2(h1);
    //(*h2).Set(0,1,10);
    //cout<<*h1<<*h2;
}

运行结果：
在这里插入图片描述

三、模板类AutoPtr

1. 构造函数

函数声明

AutoPtr(T* pData);

函数实例化

template<class T>
AutoPtr<T>::AutoPtr(T* pData)
{
	m_pData = pData;
	m_nUser = new int(1);
}

2. 析构函数

~AutoPtr()
	{
		decrUser();
	}
void decrUser();
template<class T>
void AutoPtr<T>::decrUser()
{
	--(*m_nUser);
	if ((*m_nUser) == 0)
	{
		delete m_pData;
		m_pData = 0;
		delete m_nUser;
		m_nUser = 0;
	}
}

3. 拷贝构造函数

函数声明

AutoPtr(const AutoPtr<T>& h);

函数实例化

template<class T>
AutoPtr<T>::AutoPtr(const AutoPtr<T>& h)
{
	m_pData = h.m_pData;
	m_nUser = h.m_nUser;
	(*m_nUser)++;
}

4. 等号、->、*等运算符重载

AutoPtr<T>& operator=(const AutoPtr<T>& h);
T* operator->()
{
	return m_pData;
}
T& operator*()
{
	return *m_pData;
}
const T& operator *()const
{
	return *m_pData;
}
const T* operator ->()const
{
	return m_pData;
}
template<class T>
AutoPtr<T>& AutoPtr<T>::operator=(const AutoPtr<T>& h)
{
	decrUser();
	m_pData = h.m_pData;
	m_nUser = h.m_nUser;
	(*m_nUser)++;
}

5. 主函数调用AutoPtr

#include<iostream>
#include"queue.h"
#include <vector>
#include "autoptr.h"
#include "CMatrix.h"
using namespace std;
int main()
{
	//const int a = 1;
	//const int b = 1;
	//const char* c = "qwe", * d = "asd";
	//cout << compare(a, b) << endl;
	//cout << compare(c, d);


	//Queue<int> qt;
	//double d = 3.3;
	//qt.push(1);
	//qt.push(d);
	//qt.push(10); 
	//cout << endl;
	//cout << qt;

	//short a[5] = { 0,3,6,9 };
	//Queue<int> qi(a, a + 5);
	//cout << endl;
	//cout << qi;
	//cout << endl;
	//while (!qi.empty())
	//{
	//	cout << qi.front() << " ";
	//	qi.pop();
	//}
	//vector<int> vi(a, a + 5);
	//qi.assign(vi.begin(), vi.end());
	//cout << endl;
	//cout << qi;
	//cout << endl;

	//Queue<const char*> q1;
	//q1.push("hi");
	//q1.push("I'm");
	//q1.push("Jerry");
	//cout << q1;
	//cout << endl;
	//Queue<const char*> q2(q1);
	//cout << q2;


    AutoPtr<CMatrix> h1;
    double data[6] = {1,2,3,4,5,6};
    h1->Create(2,3,data);
    cout << *h1 << endl;
    AutoPtr<CMatrix> h2(h1);
    (*h2).Set(0,1,10);
    cout << *h1 << endl << *h2;
}

运行结果如下：h2通过拷贝构造函数创建（拷贝h1），则h2调用Set方法后改变的是同一个地址的值，所以最后h1改变了，h1和h2输出结果相同。
在这里插入图片描述

6. 总结

在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。

动态内存管理经常会出现两种问题：一种是忘记释放内存，会造成内存泄漏；一种是尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。

为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。

JRWu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 实验3 模板
qq_48864962的博客
11-17 559
目录 实验内容： 一、模板函数（compare）： 1.一般模板函数： 2.特化模板函数： 二、模板类Queue： 1.模板类（Queue）： 2.成员模板函数： 3.模板特化：模板函数特化、模板成员函数特化、模板类特化： 3.1.模板函数特化: 3.2.模板类特化: 三、模板类AutoPtr： 1.构造函数： 2.析构函数： 3.拷贝构造函数： 4.等号、->、*等运算符重载： 5.主函数调用AutoPtr： 总结： 实验内容： 1、模板函数（comp...
c++（实验三）模板学习总结与模板栈的实现以及auto_ptr
m0_61829968的博客
11-17 421
模板的简单讲解与特化的理解 范式的定义 所谓泛型，实质上就是不使用具体数据类型（例如 int、double、float 等），而是使用一种通用类型来进行程序设计的方法，该方法可以大规模的减少程序代码的编写量，让程序员可以集中精力用于业务逻辑的实现。 模板 泛型编程的主要技术，即模板，其旨在最大程度上减少代码重复，减轻猿类生物的脱发问题。（所以和继承一样，要学好）然后，本章学习最重要的是要为了在stl能运行系统给的模板（听大佬说的），而不是简单的学会写模板。 格式 ...
C++模板总结
Sun_student的博客
05-17 450
1.泛型编程 理解：就是编写与类型无关的通用代码，是代码复用的一种手段。 为什么要实现泛型编程？ 我们已经知道在C++中函数可重载，在函数重载有些地方不好使用：代码的复用率比较低；代码的可维护性比较低。因为C++中有模板，所以采用模板可以实现泛型编程，从而生成代码，这样就不需要我们去一个一个重载一些通用的函数。（比如：交换函数） 从这里我们引出模板...
C++实验06(01)类模板
多学习
04-11 2888
题目描述 编写一个使用类模板对数组进行排序、查找和显示所有元素值的程序，数组中元素个数3≤n≤15 说明：设计一个类模板 template class Array，用于对T类型的数组进行排序、查找、显示所有元素，构造函数有两个参数：传递数组首地址和数组元素个数。 主函数中实例化Array产生模板类Array和Array，输入两个数组的长度，再依次输入各元素的值，调用相应的成员函数完成：输出数组的原...
西南科技大学C++程序设计实验十（函数模板与类模板）
Welcome To Myon'Blog !
12-08 3302
类模板是一种特殊的模板，它可以让我们定义一个通用的类，其中某些成员变量或成员函数的数据类型不必指定，而是可以在使用该类时根据需要指定。在类模板的定义中，我们使用类型参数（例如template ）来表示通用类型，这样可以让类模板适用于不同的数据类型。类型参数：动态数组的元素类型应该作为类模板的一个类型参数来表示，这样可以让我们在使用该类时根据需要指定元素类型。类型参数：链表节点的数据类型应该作为类模板的一个类型参数来表示，这样可以让我们在使用该类时根据需要指定元素类型。
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; } 事实上两个函数除了数据类型以外进
C++面向对象实验三：模板与STL
重口味码农
11-24 2348
C++面向对象实验三：模板与STL一、实验目的 掌握模板函数和模板类的定义、实例化，学会应用模板来处理函数调用面临的不同的数据类型。 理解模板类的定义和实例化时的方法。 复习栈的出栈和入栈的相关操作。 二、实验要求 内容1： 使用函数模板，求两个数的最大值。 例如：max（3,5）则输出5 max（’3’,’5’）则输出‘5’ max（3.0,5.0）则输出5.0 max（”3”,”5”）
川北医学院C++实验报告模板.doc
02-10
川北医学院C++预习/实验报告模板，供在校学生使用，且作为备份。
c++上机实验报告模板
10-31
实验报告模板c++上机可以方便大家认真总结每一次的上机情况
青岛科技大学C++实验
12-18
青岛科技大学C++实验是面向学生进行深入学习和实践C++编程的重要课程，旨在提升学生的编程能力，理解面向对象编程的核心概念，并熟练掌握C++的关键特性。 在C++实验中，学生会接触到以下几个关键知识点： 1. **...
C++实验模板和文件
07-03
C++模板和文件学习的实验书，内有详细的程序，以及课后习题供参考。
C++课程实验：学生管理程序的
03-15
9. **标准模板库（STL）**：C++的STL包括容器（如vector、list、map）、算法和迭代器，这些工具可以帮助高效地管理和操作数据集合，可能在这个程序中用于存储和操作学生对象。 10. **设计模式**：高级的实现可能...
C++ Primer 4 第十六章 模板和泛型编程
我的读书笔记（2011-2013）
02-29 535
第十六章 模板和泛型编程 1. 模板定义 定义函数模板：函数模板是一个独立于类型的函数，可作为一种方式，产生函数的特定类型版本。模板定义以关键字 template 开始，后接模板形参表，模板形参表是用尖括号括住的一个或多个模板形参的列表，形参之间以逗号分隔。模板形参表不能为空。           // implement strcmp-like generic compare functi
python-torch加载c++与内核函数
weixin_40777649的博客
07-11 293
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
初始C++
2302_81016149的博客
07-08 779
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++ 多态
wxk2227814847的博客
07-10 621
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++|智能指针
最新发布
weixin_68201503的博客
07-11 579
1.每个shared_ptr对象，其都包含着一个指针，该指针所指向空间内容用来计数有多少个指针指向该空间，即有多少个对象管理同一份资源，当多个对象管理同一份资源，那么他们的指针就会指向同一份空间，空间内容记录着这些数量，每增加一个对象管理相同资源，则计数也会加1。那么weak_ptr是怎样解决问题的了，其实很简单，weak_ptr不在对引用计数进行管理了，所以shared_ptr对象初始化时的引用计数都是为1，在进行析构的时候，引用计数都会减到0，然后释放对应的_ptr,_pcount。
C语言-动态内存管理
m0_73605503的博客
07-07 1148
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++ 入门08：运算符重载
LF__plus的博客
07-11 602
在前面的文章学习中，我们学习了类和对象的基础知识以及构造函数、拷贝构造函数、静态成员和常量成员。今天，我们将深入学习运算符重载。运算符重载是 C++ 的一大特色，它使得我们可以对类对象使用类似于基本数据类型的运算符，从而使代码更加简洁和易读。
C++《STL》讲义.pdf
07-22
在C++编程中，STL是一个不可或缺的部分，它由惠普实验室开发，现已成为C++标准库的核心。STL的主要组成部分包括容器、算法和迭代器，它们之间通过迭代器紧密相连，提供了一种高效、灵活的方式来处理和操作数据。 1....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值