函数模板在c++动态顺序表中的大作用

C++ 顺序表的基本操作(使用模版类) 一、遇到问题:        原因:类的函数定义不能放在SeqList.cpp中,必须放在Seqlist.h(类的函数声明和定义放在同一个文件下)中,否则        会出现以下问题。         二、实现程序:    1.SeqList.h #ifndef SeqList_h #define SeqList_h #include <iostream> using ... 阅读详情

函数模板提供了一种机制通过它我们可以保留函数定义和函数调用的语义在一个程序位置上封装了一段代码确保在函数调用之前实参只被计算一次.

函数模板提供一个种用来自动生成各种类型函数实例的算法程序员对于函数接口参数和返回类型中的全部或者部分类型进行参数化(parameterize)而函数体保持不变.

函数模板使用注意事项:

1、每个函数模板前边都需要添加模板声明例如:template<typename T>

2、在模板类的使用时,注意其类型改变,例如:

template<typename T>
class SeqList
{};
该模板类的类型为SeqList<T> ,SeqList仅为一个类名

3、函数模板不能在.h文件和.cpp文件中分开编译


在实现顺序表的时候我们需要其可以存储任何类型的数据。但是对于string类型对象要特别考虑。下面我们来分析一下常用的拷贝的方法。

1)逐个对象的复制

优点:对于数据的类型无需特别考虑

缺点:拷贝的效率比较低

2)memcpy()复制

优点:拷贝的效率比较高

缺点:在涉及指针的复制时,可能出现多个指针指向同一份空间,导致内存释放多次引起程序崩溃。


string类深度剖析

在不同的编译器中string类的空间大小不同,但是可以确定的是,string类存在一个16个字节大小的buffer空间用于存放长度较短的字符来提高效率,还有一个4字节的——ptr用于指向当字符长度大于15时的字符串空间,还有两个4字节的_size和_capacity用来表示大小和容量。总共28个字节。

wKioL1b0AILCwoBaAAA0WGdy8ks871.png

这里就需要考虑在扩容和拷贝构造时的复制了,如果字符串的长度大于15个,则使用memcpy()仅仅是数值的拷贝,并不会为_ptr申请空间会导致多个指针同时指向同一份空间,使得该空间在释放时释放多次导致程序崩溃。


解决方法一:

统统采用单个赋值的,但是效率比较低。

解决方法二(最优解):

类型萃取,将内置类型和非内置类型分开copy的效率比较高。

void Copy(T* dest, const T* src, size_t size)
	{
		if (TypeTraits<T>::IsPoodType().Get())//类型萃取,内置类型
		{
			memcpy(dest, src, sizeof(T)*size);
		}
		else//非内置类型
		{
			for (size_t i = 0; i < size; i++)
			{
				dest[i] = src[i];
			}
		}
	}
struct TrueType
{
	bool Get()
	{
		return true;
	}
};

struct FalseType
{
	bool Get()
	{
		return false;
	}
};

template<typename T>
struct TypeTraits
{
	typedef FalseType IsPoodType;//内嵌型别
};

//特化
template<>
struct TypeTraits<int>
{
	typedef TrueType IsPoodType;
};

template<>
struct TypeTraits<unsigned int>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<char>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<unsigned char>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<double>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<bool>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<float>
{
	typedef TrueType IsPoodType;
};

template<>
struct TypeTraits<short>
{
	typedef TrueType IsPoodType;
};

template<>
struct TypeTraits<unsigned short>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<long long>
{
	typedef TrueType IsPoodType;
};
template<>
struct TypeTraits<long double>
{
	typedef TrueType IsPoodType;
};
#include <iostream>
#include<string>
using namespace std;

const int SIZE = 3;//构造对象的默认大小
const int DEAFAULT = 3;//每次扩容的大小
template<typename T>
class SeqList
{
public:
	//构造函数
	SeqList();
	//拷贝构造函数
	SeqList(const SeqList& l);
	//赋值
	SeqList<T> operator=(SeqList l);
	//析构函数
	~SeqList();
public:
	void PushBack(const T& d);
	void PopBack();
	void PushFront(const T& d);
	void PopFront();
	void SortList();
	void Reverse();
	T* Find(const T& d);
	void Insert(int pos, const T& x);
	void Remove(T x);
	void RemoveAll(T x);
	void CheckCapacity();
	void Print();
private:
	T* _data;
	int _size;
	int _capacity;
	
};
template<typename T>
void SeqList<T>::Print()
{
	int i = 0;
	for (i = 0; i < _size; i++)
	{
		cout << _data[i] << " ";
	}
	cout << endl;
}
template<typename T>
//构造函数
SeqList<T>::SeqList()
	:_data(new T[SIZE])
	, _size(0)
	, _capacity(SIZE)
{}
template<typename T>
//拷贝构造函数
SeqList<T>::SeqList(const SeqList& l)
{
	_data = new T[l._size];
	//int i = 0;
	//for (i = 0; i < l._size; i++)//逐个拷贝
	//{
	//	_data[i] = l._data[i];
	//}
	Copy(_data, l._data, l._size);
	_size = l._size;
	_capacity = _size;
}
template<typename T>
//赋值
SeqList<T> SeqList<T>:: operator=(SeqList l)
{
	swap(_data, l._data);
	_size = l._size;
	_capacity = l._capacity;
	return *this;
}
template<typename T>
//析构函数
SeqList<T>::~SeqList()
{
	if (_data != NULL)
	{
		delete[] _data;
		_data = NULL;
	}
}

template<typename T>
void SeqList<T>::CheckCapacity()//检测容量
{
	if (_size == _capacity)//扩容
	{
		T* tmp = new T[_capacity + DEAFAULT];
		//memcpy(tmp, _data, sizeof(T)*_size);浅拷贝,导致程序崩溃
		//int i = 0;
		//for (i = 0; i < _size; i++)//逐个拷贝
		//{
		//	tmp[i] = _data[i];
		//}
		Copy(tmp, _data, _size);
		delete[] _data;
		_data = tmp;
		_capacity += DEAFAULT;
	}	
}
template<typename T>
void SeqList<T>::PushBack(const T& d)
{
	CheckCapacity();
	_data[_size] = d;
	_size++;
}
template<typename T>
void SeqList<T>::PopBack()
{
	if (_size == 0)
	{
		return;
	}
	_size--;
}
template<typename T>
void SeqList<T>::PushFront(const T& d)
{
	CheckCapacity();
	int i = 0;
	for (i = _size-1; i >= 0; i--)
	{
		_data[i + 1] = _data[i];
	}
	_data[0] = d;
	_size++;
}
template<typename T>
void SeqList<T>::PopFront()
{
	if (_size == 0)
	{
		return;
	}
	int i = 0;
	for (i = 1; i < _size; i++)
	{
		_data[i - 1] = _data[i];
	}
	_size--;
}
template<typename T>
void SeqList<T>::SortList()
{
	int i = _size;
	bool flag = true;//标志位,当顺序表已经是有序的时候则不需要再排序提高效率
	for (i = 1; i < _size && flag; i++)
	{
		int j = 0;
		flag = false;
		for (j = 0; j < _size - i; j++)
		{
			if (_data[j] > _data[j + 1])
			{
				flag = true;
				swap(_data[j], _data[j + 1]);
			}
		}
	}
}
template<typename T>
void SeqList<T>::Reverse()
{
	int left = 0;
	int right = _size;
	while (left < right)
	{
		swap(_data[left++], _data[right--]);
	}
}
template<typename T>
T* SeqList<T>::Find(const T& d)
{
	int i = 0;
	for (i = 0; i < _size; i++)
	{
		if (_data[i] == d)
		{
			return &_data[i];//找到返回地址
		}
	}
	return NULL;//没有找到
}
template<typename T>
void SeqList<T>::Insert(int pos, const T& x)
{
	if (pos > 0 && pos <= _size)//判断位置的正确性
	{
		CheckCapacity();
		int i = 0;
		for (i = _size - 1; i >pos-2; i--)
		{
			_data[i + 1] = _data[i];
		}
		_data[pos - 1] = x;
		_size++;
	}
}
template<typename T>
void SeqList<T>::Remove(T x)
{
	int i = 0;
	for (i = 0; i < _size; i++)
	{
		if (x == _data[i])
		{
			for (int j = i; j < _size-1; j++)
			{
				_data[j] = _data[j + 1];
			}
			_size--;
			return;
		}
	}
}
template<typename T>
void SeqList<T>::RemoveAll(T x)
{
	int i = 0;
	for (i = 0; i < _size; i++)
	{
		if (x == _data[i])
		{
			Remove(x);
			i--;//保留下标,删除之后从当前继续寻找,以免顺序表遍历漏掉。
		}
	}
}

void test1()
{
	SeqList<string> l;
	//l.PushBack(1);
	//l.PushBack(2);
	//l.PushBack(3);
	//l.PushBack(4);
	//l.Print();
	//l.PopBack();
	//l.Print();
	//l.PopBack();
	//l.Print();
	//l.PopBack();
	//l.Print();
	l.PushFront("11111");
	l.PushFront("22222");
	//l.PushFront("333333333333333333333333333333333333");
	l.PushFront("33333");
    l.PushFront("44444");
	//l.PushFront("11111");
	l.Print();
	cout << sizeof(string) << endl;
	//cout << l.Find("11111") << endl;
	////cout << l.Find(0) << endl;
	//l.Insert(4, "00000");
	//l.Print();
	//l.RemoveAll("11111");
	//l.Print();
	//l.SortList();
	////l.PopBack();
	//l.Print();
	//l.PopBack();
	//l.Print();
	//l.PopBack();
	//l.Print();
}
int main()
{
	test1();
	getchar();
	return 0;
}

当使用memcpy()时

测试代码

        l.PushFront("11111");
	l.PushFront("22222");
	//l.PushFront("333333333333333333333333333333333333");
	l.PushFront("33333");
    l.PushFront("44444");

结果可以正常运行

wKioL1b0BN3TVzvyAAAa2BvvFO8349.png

但是在字符串长度比较长时

        l.PushFront("11111");
	l.PushFront("22222");
	l.PushFront("333333333333333333333333333333333333");
	//l.PushFront("33333");
    l.PushFront("44444");

wKiom1b0BICBLXsmAAAfjWbrsnU907.png

程序崩溃

【动态顺序表实现-C++】 阅读详情

相关推荐

Versal ACAP NoC实战:像理解计算机网络一样配置AXI NoC,打通PS与PL数据通路

本文深入探讨了Versal ACAP NoC的配置与优化,通过计算机网络类比解析NoC架构,详细介绍了在VD100开发板上配置AXI NoC实现PS与PL数据交互的实战步骤。文章涵盖NoC组件功能、Vivado配置技巧、性能优化方法及常见问题解决方案,帮助开发者高效打通Versal芯片的数据通路。

weixin_42665255的博客 294

5.1.1 C++函数模板和类模板注意事项

2.将声明和实现写到同一个文件中,并更改后缀名为.hpp,hpp是约定的名称,并不是强制。·1.当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类中T的类型。·2.2函数模板调用时,如果利用“显示指定类型”的方式,可以发生隐式类型转换。·2.1函数模板调用时,如果利用“自动类型推导”,不会发生隐式类型转换。·1.自动类型推导,必须推导出一致的数据类型T,才可以用。·1.如果函数模板和普通函数都可以实现,优先调用普通函数。·3.如果想灵活指定出父类中T的类型,子类也需变为类模板。

wgf350357114的博客 449

泛微OA E9文档管理优化:临时文件清理与存储配置指南

本文深入解析了泛微OA E9系统性能下降的常见原因——临时文件堆积,并提供了完整的优化配置指南。文章详细介绍了临时文件的产生机制,并手把手指导管理员如何通过修改存储路径、调整保留时间、设置白名单等关键配置,有效清理与管理系统临时文件,从而释放存储空间,提升系统运行效率与稳定性。

tree8的博客 432

函数模板的注意事项

这个示例代码展示了如何创建模板类及其成员函数、函数模板的使用和重载,以及多个通用数据类型参数的处理。)使用函数模板时,如果是自动类型推导,不会发生隐式类型转换,如果显式指定了函数模板的数据类型,可以发生隐式类型转换。)使用函数模板时,必须明确数据类型,确保实参与函数模板能匹配上。)使用函数模板时,推导的数据类型必须适应函数模板中的代码。)可以为类的成员函数创建模板,但不能是虚函数和析构函数。)函数模板支持重载,可以有非通用数据类型的参数。)函数模板支持多个通用数据类型的参数。

wuyihao123的博客 378

STM32在六轴机械臂实时控制中的选型与分层架构设计

嵌入式实时控制系统中,微控制器的选型直接决定运动控制精度与系统可靠性。其核心在于匹配确定性中断响应、低延迟外设协同与工业协议栈支持等硬性指标。STM32凭借Cortex-M内核的NVIC调度能力、成熟HAL库及CAN FD/高级定时器等专用外设,在机电一体化场景中成为伺服控制中枢的首选。相比ESP32等通用MCU,STM32在硬实时性、EMC认证生态和工业总线兼容性上具备不可替代优势。本文围绕GTB六轴机械臂项目,详解基于STM32F407的硬件抽象层配置、FreeRTOS任务调度、事件队列解耦及闭环控制数

jupi8的博客 758

深入解析AMBA5 AXI与ACE协议:从基础到高级应用

本文深入解析了AMBA5 AXI与ACE协议的核心机制与应用。AXI协议通过分离通道、突发传输和乱序完成实现高性能数据传输,而ACE协议在此基础上构建了硬件级缓存一致性解决方案,通过监听机制和状态模型确保多核系统数据统一。文章还探讨了在异构计算等复杂场景下的实战应用与AMBA5的新特性。

cc789的博客 964

顺序表(Seqlist)&链表(List)的基础操作

顺序表和链表是数据结构的基础结构之一,同样也是面试的基础。初学者对于Seqlist和List的增删改查的基础练习,为其后的Tree,HashTable,Binary Linked List,Trigeminal linked list等数据结构打下坚实的基础。

Xiao__Tian__的博客 1万+

obisidian插件之【templater】模板的中文说明书

Templater 是一种模板语言,可让您将变量和函数结果插入到笔记中。它还允许您执行操作这些变量和函数的 JavaScript 代码。使用 Templater,您将能够创建强大的模板来自动执行手动任务。

m0_55795604的博客 1万+

函数模板注意事项

一、模板重载

脚踏实地,用心编写出客户满意的代码,为公司创造出应有的价值。 1133

wxComboBox类的使用方法及示例代码

其中,parent表示该控件的父窗口,ID_COMBOBOX是该控件的ID,用于在事件处理函数中区分不同的控件,"默认选项"是下拉列表框的默认选项,options是wxArrayString类型的数组,用于存储下拉列表框中的选项,style可以指定wxComboBox的样式。wxComboBox是wxWidgets中的一个常用控件,它可以被用来显示一组在下拉列表框中的选项,并允许用户从中选择一个选项。上述就是wxComboBox类的基本使用方法,使用这个控件可以方便地实现下拉列表框的功能。

学习使你进步。 714

5.3-集群电源模式解析

DSU-120 DynamIQ™集群支持9种电源模式,包括正常运行(ON)、完全断电(OFF)、三种数据保持模式(FUNC_RET、FULL_RET、MEM_RET)、两种调试模拟模式(OFF_EMU、MEM_RET_EMU),以及系统恢复模式(WARM_RST、DBG_RECOV)。这些模式通过智能管理电源状态,在保持数据完整性的同时实现功耗优化,并为系统调试和故障恢复提供支持。不同模式在RAM保持、逻辑断电和调试能力方面各有侧重,满足从正常运行到深度调试等不同场景需求。

baron-周贺贺-代码改变世界ctw 117

C++ 顺序表(动态分配)

/* 顺序表————动态分配 */ #define InitSize 5 // 顺序表初始长度 #include <iostream> #include <stdio.h> using namespace std; struct SqList { int *data; // 数组 int MaxSize; // 顺序表的最大长度 int length; // 顺序表的当前长度 }; // 初始化顺序表 void InitList(SqList &L

qq_43650934的博客 3548

损失函数大汇总(五十三)(Boundary Loss附公式推导与代码)

摘要 Boundary Loss是一种针对图像分割任务的新型损失函数,特别适用于高度类别不平衡的细粒度分割场景。与传统的区域型损失(如Dice、交叉熵)不同,它通过计算预测边界与真实边界之间的距离来优化模型,更关注边界精度而非区域重叠。核心思想是利用距离图(distance map)将边界约束转化为区域积分形式,实现端到端训练。具体实现中,损失函数为预测概率与距离图的点积,梯度仅取决于距离图,具有明确的空间引导性。相比区域型损失,Boundary Loss能更好处理小目标、细长结构等边界敏感任务,可与Dic

悦学共鸣,温柔以待,汇聚光芒,共同成长 241

《C++》解密--顺序表

是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈......,也就是连续的一条直线;顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般采用数组存储。的,线性表在物理上储存时,通常是数组、链式结构等形式。,对数组的封装,实现了常用的增删改查等接口。顺序表是线性表的一种。

2301_78136992的博客 1869

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

C++数据结构 —— 顺序表

C++数据结构、手巧顺序表

2401_87692970的博客 1520

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

C++ 静态顺序表和动态顺序表

定义:静态顺序表是一种线性表的实现方式,采用一段连续的内存空间存储数据元素,具有固定的大小。在编译时确定长度,无法动态扩展。定义:动态顺序表是一种线性表的实现,能够在运行时动态调整大小,适应数据量的变化。通常使用动态数组实现。

qq_50373827的博客 1074

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

【C++】数据结构 顺序表的实现(详解)

本篇博客给大家带来的是用C++语言来实现数据结构的顺序表

就业知识博客 2224

顺序表的基本操作C++

讲一讲顺序表吧 首先定义结构体老套路了 顺序表比较特别首先要分配好内存空间,给够空间,不够以后再来说要么扩容,扩容是倍增的扩容一会开小灶来讲就不放到主运行里了 **typedef int Elemtype;**讲一下这个,可能比较多人不太理解这什么意思,其实也是单纯的定义一个类型变量罢了(typedef的用法),只是这个名字改了一下,对于以后对程序的维护方便点而已,就是把int这个整型变量改名为Elemtype,以后要改类型就直接在int那里改成float,double,bool之类,比较方便; #incl

alanmian的博客 3064

动态顺序表

4// 给顺序表一个初始大小//定义顺序表数据类型////静态顺序表 开少了不够用 开多了浪费//};//动态顺序表 动态扩容 开辟内存在堆区 没必要用柔性数组//动态数组的基地址int size;//有效数据个数 size是 最后一个元素的下一个位置的下标//空间容量}SeqList;此处阐释静态顺序表的劣势。静态顺序表开辟的空间是固定的,开辟空间过少,不够存储, 开辟空间过多, 造成空间的浪费。因此在实际使用的过程中,使用动态顺序表居多。

有梦想的电信狗 1488

C++ 数据结构 静态顺序表、动态顺序表。

静态顺序表(Static Array List)是一种线性数据结构,通常用数组实现。它具有固定的大小,并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。

qq_50373827的博客 966

动态顺序表(动态扩容)

10//默认最大长度//顺序表的最大容量int length;//顺序表的当前长度int* data;//指向动态分配数组的指针}SeqList;由于malloc函数返回的是所申请空间的地址,因此我们需要用指针来接受,还是那句话,为了方便起见,我们用 int* 来接收。

有梦想的电信狗 2095

数据结构——顺序表代码实现——C++

我们用宏定义了eleType为char类型,之所以用宏定义是因为后续可以方便我们修改顺序表的数据储存类型。比如:可以把上述的char改为int、double、float等。int size;此结构体,我们定义了动态数组elements类型是eleType(由于我们对eleType进行了宏定义,所以这个数组是char类型的),顺序表的大小size(实际储存数据的多少),还有顺序表的容量capacity(如果存满了,这个容量是可改变的,这正是动态顺序表的优势)。

2202_75569688的博客 2019

C/C++数据结构之动态顺序表的实现

顺序表可分为静态和动态两类,静态顺序表可以用一个数组来实现,静就是体现在我们一开始就规定了数组的大小。我们设最初我们开辟4个int所需的空间,之后我们都开之前的两倍空间。因为我们这里是以整形为例子来实现的,我们把int重新起一个名字,这样做方便我们以后修改类型。尾删比较简单,我们只需要判断size是否有效,在此前提之上我们执行size-- 就可以。结合例子我们就可以修正我们的函数 ,进而提高函数的正确性。

2301_80102396的博客 1799

动态顺序表详解(单动态顺序表)

//功能:应用C++语言实现顺序表的各项操作 //基本的成员函数: // 构造函数、拷贝构造函数、赋值运算符的重载、析构函数 // 1:动态增容 // 2:打印单链表 // 3:尾插 // 4:尾删 ...

m0_69258343的博客 1902

动态顺序表的增容原理

本文深入探讨了动态顺序表的增容原理,为什么以倍数形式增加,为什么是2倍

2301_79449160的博客 1186
上一篇: c++实现双向链表的常用功能
下一篇: 面试题的那些事(1)
LeetCode8023
博客等级 码龄10年 6粉丝 53原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值