CWHArray模版类

最新推荐文章于 2023-12-25 09:15:00 发布
最新推荐文章于 2023-12-25 09:15:00 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： C/C++ windows编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq125096885/article/details/51318510
版权

Array.h

#ifndef ARRAY_HEAD_FILE
#define ARRAY_HEAD_FILE

#pragma once
#include <windows.h>
#include <assert.h>
#include <memory>
#define DbgBreakPoint  _asm int 3
//

//数组模板类
template <class TYPE, class ARG_TYPE = const TYPE &> class CWHArray
{
	//变量定义
protected:
	TYPE *							m_pData;							//数组指针
	INT_PTR							m_nMaxCount;						//缓冲数目
	INT_PTR							m_nGrowCount;						//增长数目
	INT_PTR							m_nElementCount;					//元素数目

	//函数定义
public:
	//构造函数
	CWHArray();
	//析构函数
	virtual ~CWHArray();

	//信息函数
public:
	//是否空组
	bool IsEmpty() const;
	//获取数目
	INT_PTR GetCount() const;

	//功能函数
public:
	//获取缓冲
	TYPE * GetData();
	//获取缓冲
	const TYPE * GetData() const;
	//增加元素
	INT_PTR Add(ARG_TYPE newElement);
	//拷贝数组
	VOID Copy(const CWHArray & Src);
	//追加数组
	INT_PTR Append(const CWHArray & Src);
	//获取元素
	TYPE & GetAt(INT_PTR nIndex);
	//获取元素
	const TYPE & GetAt(INT_PTR nIndex) const;
	//获取元素
	TYPE & ElementAt(INT_PTR nIndex);
	//获取元素
	const TYPE & ElementAt(INT_PTR nIndex) const;

	//操作函数
public:
	//设置大小
	VOID SetSize(INT_PTR nNewSize);
	//设置元素
	VOID SetAt(INT_PTR nIndex, ARG_TYPE newElement);
	//设置元素
	VOID SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement);
	//插入数据
	VOID InsertAt(INT_PTR nIndex, const CWHArray & Src);
	//插入数据
	VOID InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount = 1);
	//删除数据
	VOID RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
	//删除元素
	VOID RemoveAll();

	//操作重载
public:
	//操作重载
	TYPE & operator[](INT_PTR nIndex);
	//操作重载
	const TYPE & operator[](INT_PTR nIndex) const;

	//内存函数
public:
	//释放内存
	VOID FreeMemory();
	//申请内存
	VOID AllocMemory(INT_PTR nNewCount);
};

//
// CWHArray<TYPE, ARG_TYPE> 内联函数

//是否空组
template<class TYPE, class ARG_TYPE>
inline bool CWHArray<TYPE, ARG_TYPE>::IsEmpty() const
{
	return (m_nElementCount == 0);
}

//获取数目
template<class TYPE, class ARG_TYPE>
inline INT_PTR CWHArray<TYPE, ARG_TYPE>::GetCount() const
{
	return m_nElementCount;
}

//增加元素
template<class TYPE, class ARG_TYPE>
inline INT_PTR CWHArray<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement)
{
	INT_PTR nIndex = m_nElementCount;
	SetAtGrow(nIndex, newElement);
	return nIndex;
}

//操作重载
template<class TYPE, class ARG_TYPE>
inline TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex)
{
	return ElementAt(nIndex);
}

//操作重载
template<class TYPE, class ARG_TYPE>
inline const TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex) const
{
	return GetAt(nIndex);
}

//
// CWHArray<TYPE, ARG_TYPE> 外联函数

//构造函数
template<class TYPE, class ARG_TYPE>
CWHArray<TYPE, ARG_TYPE>::CWHArray()
{
	m_pData = NULL;
	m_nMaxCount = 0;
	m_nGrowCount = 0;
	m_nElementCount = 0;

	return;
}

//构造函数
template<class TYPE, class ARG_TYPE>
CWHArray<TYPE, ARG_TYPE>::~CWHArray()
{
	if (m_pData != NULL)
	{
		for (INT_PTR i = 0; i < m_nElementCount; i++)	(m_pData + i)->~TYPE();
		delete[](BYTE *)m_pData;
		m_pData = NULL;
	}

	return;
}

//获取缓冲
template<class TYPE, class ARG_TYPE>
TYPE * CWHArray<TYPE, ARG_TYPE>::GetData()
{
	return m_pData;
}

//获取缓冲
template<class TYPE, class ARG_TYPE>
const TYPE * CWHArray<TYPE, ARG_TYPE>::GetData() const
{
	return m_pData;
}

//拷贝数组
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::Copy(const CWHArray & Src)
{
	//效验参数
	assert(this != &Src);
	if (this == &Src) return;

	//拷贝数组
	AllocMemory(Src.m_nElementCount);
	if (m_nElementCount > 0)
	{
		for (INT_PTR i = 0; i < m_nElementCount; i++) (m_pData + i)->~TYPE();
		memset(m_pData, 0, m_nElementCount*sizeof(TYPE));
	}
	for (INT_PTR i = 0; i < Src.m_nElementCount; i++)	m_pData[i] = Src.m_pData[i];
	m_nElementCount = Src.m_nElementCount;

	return;
}

//追加数组
template<class TYPE, class ARG_TYPE>
INT_PTR CWHArray<TYPE, ARG_TYPE>::Append(const CWHArray & Src)
{
	//效验参数
	assert(this != &Src);
	if (this == &Src)return NULL;


	//拷贝数组
	if (Src.m_nElementCount > 0)
	{
		INT_PTR nOldCount = m_nElementCount;
		AllocMemory(m_nElementCount + Src.m_nElementCount);
		for (INT_PTR i = 0; i < Src.m_nElementCount; i++)	m_pData[m_nElementCount + i] = Src.m_pData[i];
		m_nElementCount += Src.m_nElementCount;
	}

	return m_nElementCount;
}

//获取元素
template<class TYPE, class ARG_TYPE>
TYPE & CWHArray<TYPE, ARG_TYPE>::GetAt(INT_PTR nIndex)
{
	assert((nIndex >= 0) && (nIndex < m_nElementCount));
	if ((nIndex < 0) || (nIndex >= m_nElementCount))DbgBreakPoint


	return m_pData[nIndex];
}

//获取元素
template<class TYPE, class ARG_TYPE>
const TYPE & CWHArray<TYPE, ARG_TYPE>::GetAt(INT_PTR nIndex) const
{
	assert((nIndex >= 0) && (nIndex < m_nElementCount));
	if ((nIndex < 0) || (nIndex >= m_nElementCount))return NULL;


	return m_pData[nIndex];
}

//获取元素
template<class TYPE, class ARG_TYPE>
TYPE & CWHArray<TYPE, ARG_TYPE>::ElementAt(INT_PTR nIndex)
{
	assert((nIndex >= 0) && (nIndex < m_nElementCount));
	if ((nIndex < 0) && (nIndex >= m_nElementCount))DbgBreakPoint
	

	return m_pData[nIndex];
}

//获取元素
template<class TYPE, class ARG_TYPE>
const TYPE & CWHArray<TYPE, ARG_TYPE>::ElementAt(INT_PTR nIndex) const
{
	assert((nIndex >= 0) && (nIndex < m_nElementCount));
	if ((nIndex < 0) && (nIndex >= m_nElementCount))return NULL;


	return m_pData[nIndex];
}

//设置大小
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::SetSize(INT_PTR nNewSize)
{
	//效验参数
	assert(nNewSize >= 0);
	if (nNewSize < 0)return;


	//设置大小
	AllocMemory(nNewSize);
	if (nNewSize > m_nElementCount)
	{
		for (INT_PTR i = m_nElementCount; i < nNewSize; i++) new ((VOID *)(m_pData + i)) TYPE;
	}
	else if (nNewSize < m_nElementCount)
	{
		for (INT_PTR i = nNewSize; i < m_nElementCount; i++) (m_pData + i)->~TYPE();
		memset(m_pData + nNewSize, 0, (m_nElementCount - nNewSize)*sizeof(TYPE));
	}
	m_nElementCount = nNewSize;

	return;
}

//设置元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::SetAt(INT_PTR nIndex, ARG_TYPE newElement)
{
	assert((nIndex >= 0) && (nIndex < m_nElementCount));
	if ((nIndex >= 0) && (nIndex < m_nElementCount)) m_pData[nIndex] = newElement;
	else return ;


	return;
}

//设置元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement)
{
	//效验参数
	assert(nIndex >= 0);
	if (nIndex < 0)return ;

	//设置元素
	if (nIndex >= m_nElementCount) SetSize(m_nElementCount + 1);
	m_pData[nIndex] = newElement;

	return;
}

//插入数据
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::InsertAt(INT_PTR nIndex, const CWHArray & Src)
{
	//效验参数
	assert(nStartIndex >= 0);
	if (nStartIndex < 0)return ;


	if (Src.m_nElementCount>0)
	{
		//申请数组
		if (nIndex < m_nElementCount)
		{
			INT_PTR nOldCount = m_nElementCount;
			SetSize(m_nElementCount + Src.m_nElementCount);
			for (INT_PTR i = 0; i < nCount; i++) (m_pData + nOldCount + i)->~TYPE();
			memmove(m_pData + nIndex + nCount, m_pData + nIndex, (nOldCount - nIndex)*sizeof(TYPE));
			memset(m_pData + nIndex, 0, Src.m_nElementCount*sizeof(TYPE));
			for (INT_PTR i = 0; i < Src.m_nElementCount; i++) new (m_pData + nIndex + i) TYPE();
		}
		else SetSize(nIndex + nCount);

		//拷贝数组
		assert((nIndex + Src.m_nElementCount) <= m_nElementCount);
		while (nCount--) m_pData[nIndex++] = newElement;
	}

	return;
}

//插入数据
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount)
{
	//效验参数
	assert(nIndex >= 0);
	assert(nCount > 0);
	if ((nIndex < 0) || (nCount <= 0))return ;


	//申请数组
	if (nIndex < m_nElementCount)
	{
		INT_PTR nOldCount = m_nElementCount;
		SetSize(m_nElementCount + nCount);
		for (INT_PTR i = 0; i < nCount; i++) (m_pData + nOldCount + i)->~TYPE();
		memmove(m_pData + nIndex + nCount, m_pData + nIndex, (nOldCount - nIndex)*sizeof(TYPE));
		memset(m_pData + nIndex, 0, nCount*sizeof(TYPE));
		for (INT_PTR i = 0; i < nCount; i++)::new (m_pData + nIndex + i) TYPE();
	}
	else SetSize(nIndex + nCount);

	//拷贝数组
	assert((nIndex + nCount) <= m_nElementCount);
	while (nCount--) m_pData[nIndex++] = newElement;

	return;
}

//删除数据
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::RemoveAt(INT_PTR nIndex, INT_PTR nCount)
{
	//效验参数
	assert(nIndex >= 0);
	assert(nCount >= 0);
	assert(nIndex + nCount <= m_nElementCount);
	if ((nIndex < 0) || (nCount<0) || ((nIndex + nCount>m_nElementCount)))return ;


	//删除数据
	INT_PTR nMoveCount = m_nElementCount - (nIndex + nCount);
	for (INT_PTR i = 0; i < nCount; i++) (m_pData + nIndex + i)->~TYPE();
	if (nMoveCount > 0) memmove(m_pData + nIndex, m_pData + nIndex + nCount, nMoveCount*sizeof(TYPE));
	m_nElementCount -= nCount;

	return;
}

//删除元素
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::RemoveAll()
{
	if (m_nElementCount > 0)
	{
		for (INT_PTR i = 0; i < m_nElementCount; i++) (m_pData + i)->~TYPE();
		memset(m_pData, 0, m_nElementCount*sizeof(TYPE));
		m_nElementCount = 0;
	}

	return;
}

//释放内存
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::FreeMemory()
{
	if (m_nElementCount != m_nMaxCount)
	{
		TYPE * pNewData = NULL;
		if (m_nElementCount != 0)
		{
			pNewData = (TYPE *) new BYTE[m_nElementCount*sizeof(TYPE)];
			memcpy(pNewData, m_pData, m_nElementCount*sizeof(TYPE));
		}
		delete[](BYTE *)m_pData;
		m_pData = pNewData;
		m_nMaxCount = m_nElementCount;
	}

	return;
}

//申请内存
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE, ARG_TYPE>::AllocMemory(INT_PTR nNewCount)
{
	//效验参数
	assert(nNewCount >= 0);

	if (nNewCount > m_nMaxCount)
	{
		//计算数目
		INT_PTR nGrowCount = m_nGrowCount;
		if (nGrowCount == 0)
		{
			nGrowCount = m_nElementCount / 8;
			nGrowCount = (nGrowCount < 4) ? 4 : ((nGrowCount>1024) ? 1024 : nGrowCount);
		}
		nNewCount += nGrowCount;

		//申请内存
		TYPE * pNewData = (TYPE *) new BYTE[nNewCount*sizeof(TYPE)];
		memcpy(pNewData, m_pData, m_nElementCount*sizeof(TYPE));
		memset(pNewData + m_nElementCount, 0, (nNewCount - m_nElementCount)*sizeof(TYPE));
		delete[](BYTE *)m_pData;

		//设置变量
		m_pData = pNewData;
		m_nMaxCount = nNewCount;
	}

	return;
}

//

#endif


main.cpp

#include <stdio.h>
#include "Array.h"


int main(void)
{

	CWHArray<int> myArray;
	for (int i = 0; i < 10;i++)
	{
		myArray.Add(i);
		printf("%d\n", myArray.GetAt(i));
	}
	myArray.IsEmpty();
	myArray.GetCount();
	myArray.GetData();
	myArray.GetAt(0);
	myArray.ElementAt(0);
	myArray.SetSize(20);
	myArray.SetAt(0, 456);
	myArray.InsertAt(5, 10);

	for (int i = 0; i < 20;i++)
	{
		printf("%d\n", myArray.GetAt(i));
	}

	myArray.RemoveAt(0);
	myArray.RemoveAll();

	return 0;
}
/*
0
1
2
3
4
5
6
7
8
9
456
1
2
3
4
10
5
6
7
8
9
0
0
0
0
0
0
0
0
0
请按任意键继续. . .
*/


125096
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
麻将协议
u010401391的专栏
03-09 1938
麻将PC客户端移植： CArrayTemplate改为CWHArray CSkinImage改为CPngImage、CBitImage SetLoadInfo改为LoadImage、LoadFromResource 注释掉CImageHandle CSkinButton::SetButtonImage加1个透明度参数，填false CGameFrameDlg改为CGameFrameEn
MFC中CList类使用注意
ellor的专栏
07-29 3855
初学mfc者，往往对CList等mfc的Collect类的使用感到迷惑，在使用中经常会遇到许多问题，导致对vc中的Collect类的使用产生了惧怕。以下，就个人经历而言,告诉大家如何使用CList。CList是一个双向链表类。1、头文件名不可少Clist类定义在Afxtempl.h 头文件中，因此在使用该类时，需要加这个头文件名。2、理解CList的声明和构造方法CList
详解c++---array和模板
qq_68695298的博客
05-13 1783
array的介绍和模板的一些特性
C++11 模板类array
最新发布
wendyWJGU的博客
12-25 484
C++11 模板类array
C++：array，模板特化 详解
zhang_si_hang的博客
08-02 989
array对比原生数组，还是有一些越界检查的优势的。但是实际中我们统一直接用vector更香！5.非类型模板参数（1）非类型模板参数是常量，不可修改全特化即是将模板参数列表中所有的参数都确定化半特化/偏特化 :1、将模板参数类表中的一部分参数特化。2、偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来class Data{public:}private:T1 _d1;T2 _d2;};// 全特化 ：全特化即是将模板参数列表中所有的参数都确定化。.........
c++ array模板类使用
热门推荐
我的博客
08-10 6万+
目录 1、array模板类的定义 （1）array模板类的声明 （2）容器属性 （3）array模板类的说明 （4）array模板类头文件 2、array模板类的使用 （1）Iterators （2）Capacity （3）Element access （4）Modifiers （5）Compare （6）Other 本章是对c++ array模板类的知识归纳，讲述了c+...
网狐动态数组CWHArray
liujiayu2的专栏
05-28 2560
#ifndef ARRAY_HEAD_FILE #define ARRAY_HEAD_FILE #pragma once ////////////////////////////////////////////////////////////////////////////////// //数组模板类 template class CWHArray { //
php模版类.zip
07-11
PHP模板引擎就是一个PHP类库，使用它可以使PHP代码和HTML代码进行分离，使代码的可读性和维护性得到显著提高。而且这样做的好处是，让美工专心设计HTML前台页面，程序员专心去写PHP业务逻辑。因此，模化引擎很适合...
分类摄影图库展示网页模板
01-22
这类模版通常包含各种预设的布局、色彩方案和交互元素，以帮助用户轻松地将照片分类并展示给访问者。 【描述】"分类摄影图库展示网页模板"的核心功能在于其分类系统，能够根据摄影主题、风格、颜色或摄影师等不同...
电气类的visio模版
01-12
电气类的Visio模板，给需要的同志使用，很不错的 电气类的Visio模板，给需要的同志使用，很不错的 电气类的Visio模板，给需要的同志使用，很不错的 电气类的Visio模板，给需要的同志使用，很不错的
面向对象 类模版
06-25
类模板，模板的类型参数由关键字class 或关键字typename 及其后的标识符构成。在模板参数表中关键字class 和typename 的意义相同。（在标准C++之前关键字typename 没有被支持 ，把这个关键字加入到C++中的原因是因为...
Array数组模板vc
06-04
抽象类+模板，实现数组模板，可以有助于模板的学习
MFC常用函数Ⅲ（容器）
qq_47999510的博客
12-15 559
①容器CArray——数组 template <class TYPE, class ARG_TYPE = const TYPE&> class CArray : public CObject // Arrays class CByteArray; // 支持字节的动态数组。 class CWordArray; // 支持 16 位数组。 class CDWordArray; // 支持 32 位双字数组。 class CU
关于C++：STL容器模板类的内部实现-array
qq_38501425的博客
04-16 888
关于C++：STL容器模板类的内部实现-array 本小白最近在学习C++中STL的相关知识，特在此做个笔记 今天看到了array类的内部实现，特此来整理一下所学
CArray的参数如何使用，TYPE与ARG_TYPE的解释
weixin_34049948的博客
11-26 286
2019独角兽企业重金招聘Python工程师标准>>> ...
VC++ 数组模板类
老狼的专栏
01-13 508
头文件声明（CSWArray.h） #ifndef ARRAY_HEAD_FILE #define ARRAY_HEAD_FILE #pragma once //数组模板类 template <class TYPE, class ARG_TYPE=const TYPE &> class CSWArray { //变量定义 protected: TYPE * ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值