第91篇 C++数据结构（一）数组

已于 2022-04-22 18:43:45 修改
阅读量1.2k 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-21 11:08:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49188222/article/details/124309378
版权

第91篇 C++数据结构（一）数组


本篇主要是说明数组的封装，数组的具体介绍一搜一大把，这里就不一一说明，这里主要是数组数组相关操作的封装实现，代码不复杂，就不作算法介绍了。

1.数组简介

数组是一个固定长度的存储相同数据类型的数据结构，数组中的元素被存储在一段连续的内存空间中。

1.1.数组的优点：

1、按照索引查询元素速度快；
2、能存储大量数据；
3、按照索引遍历数组方便；
4、数组定义简单，而且访问很方便；
5、可以随机访问其中的元素。

1.2.数组的缺点：

1、根据内容查找元素速度慢；
2、数组的大小一经确定不能改变，不适合动态存储；
3、数组只能存储一种类型的数据；
4、增加、删除元素效率慢；
5、未封装任何方法，所有操作都需要用户自己定义；
6、数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。

1.3.数组的定义与使用

在使用一个数组之前，我们需要声明这个数组。声明数组意味着我们需要指定以下内容：

1.数据类型：这个数组将要存储怎样一种类型的数据（不同类型占据的内存空间是不同的.如：字符、整型、浮点型等一些数据类型。
2.名称：用于标识这个数组并与之交互的变量名
3.数量：数组内数据的数量，它指定这个数组最多能存储的数据元素的数量

1.3.1.一维数组

一维数组定义形式如下：

type array[size];//数组的定义形式

如需要保存10个int型变量，则定义为：

int array[10];

可初始化：

int arrat[10] = {1,2,3,4,5,6,7,8,9,10};

动态申请内存为：

int* array = new int[10];

一维数组遍历如下：

for(int i = 0;i < 10;i++) {
	cout << array[i] << ", ";
}

1.3.2.二维数组

二维数组定义形式如下：

type array[row][col];//数组的定义形式

如需要表示存储int型的3 * 3的矩阵，则定义为：

int matrix[3][3];

可初始化：

int matrix[3][3] = {
	{1,2,3}, 
	{4,5,6},
	{7,8,9}};

动态申请内存为：

int** matrix = new int*[3];
for(int i = 0;i < 3;i++) {
	matrix[i] = new int[3];
}

二维数组遍历如下：

for(int i = 0;i < 3;i++) {
	for(int j = 0;j < 3;j++) {
		cout << array[i][j] << ", ";
	}
}

1.4.数组相关操作

插入、删除、查找、替换、反转、排序、截取、遍历、拼接等。
不使用标准模板库的数组容器，则需要我们自定义相关方法，在此封装一个数组类，封装了以上序列操作，技术不过关，如有错误，请以斧正。

数组插入数据的方法

1.头部插入
2.尾部插入
3.指定位置插入
4.指定区间插入：在区间内插入同一个数据或者一段数据

数组删除数据的方法

1.删除头部
2.删除尾部
3.删除指定位置
4.删除指定数据（只要等于就删除）
5.删除指定位置指定数据（如果这个位置的数据等于要删除的数据就删除）
6.删除指定区间（删除范围内所有数据）

数组查找数据的方法

1.顺序查找指定数据
2.指定位置查找指定数据
3.指定区间查找数据

数组替换数据的方法

1.替换指定位置数据
2.替换指定目标数据
3.替换指定区间数据

数组反转数据的方法

1.整体反转
2.指定区间反转

数组排序数据的方法

1.冒泡排序
2.选择排序

数组截取数据的方法

1.截取区间数据
2.截取指定位置往后数据

数组遍历数据的方法（用于封装之后的遍历）

getData(int index)遍历
重载[]遍历
at(int index)遍历

数组拼接数据的方法（封装之后）

重载+拼接

2.Array类

封装数组数据和操作数据的方法。

2.1.变量表

变量名类型属性说明
m_arrayType*私有存储数据
m_lensize_t私有表示存储有多少个数据

2.2.方法表

方法名返回类型参数属性说明
Array()--公有缺省构造
Array()-size_t len公有传长度构造
Array()-Type* array, size_t len公有传数组与长度构造
Array()-const Array& a公有拷贝构造
operator = ()Array&const Array& a公有=运算符重载
~Array()--公有析构函数
size() constsize_t-公有获取数据个数
length() constsize_t-公有获取数据个数
setData()voidint index, Type value公有设置某个位置的值
empty() constbool-公有判断是否为空
push_front()boolType value公有头部插入数据
push_back()boolType value公有尾部插入数据
insert()boolint index, Type value公有指定位置插入数据
insert()boolint begin, int end, Type value公有指定区间插入数据
pop_front()int-公有删除头部数据
pop_back()int-公有删除尾部数据
eraseIndex()boolint index公有删除指定位置数据
eraseValue()boolType value公有删除指定数据
eraseIndexValue()boolint index, Type value公有删除指定位置指定数据
eraseSection()boolint begin, int end公有删除指定区间数据
selectIndex()intint val公有顺序查找数据
selectIndexValue()boolint index, Type val公有查找指定位置指定数据
selectSection()boolint begin, int end, Type value公有指定区间查找数据
replaceIndex()boolint index, Type value公有替换指定位置数据
replaceValue()boolType target, Type value公有替换目标数据
replaceSection()boolint begin, int end, Type value公有替换区间数据
reverse()Array-公有整体反转
reverse()Arrayint begin, int end公有局部反转
bubbleSort()Array-公有冒泡排序
selectionSort()Array-公有选择排序
subArray()Arrayint begin, int end截取区间数据
subArray()Arrayint begin公有截取指定位置往后数据
getData()Typeint index公有返回指定位置数据
operator [] ()Type&int index公有返回指定位置数据
at()Typeint index公有返回指定位置数据
operator + ()ArrayArray a, Array b友元函数数组拼接
begin()Iterator-公有正向迭代器起始位置
end()Iterator-公有正向迭代器结束位置
cbegin()ConstIterator-公有正向常量迭代器起始位置
cend()ConstIterator-公有正向常量迭代器结束位置
rbegin()ReverseIterator-公有反向迭代器起始位置
rend()ReverseIterator-公有反向迭代器结束位置
crbegin()ConstReverseIterator-公有反向常量迭代器起始位置
crend()ConstReverseIterator-公有反向常量迭代器结束位置

2.3.迭代器

简单的实现四个迭代器，没有很多方法。

2.3.1.变量

变量名类型属性说明
m_arrArray*私有使用迭代器的当前数组
m_positionint私有迭代器的位置

2.3.2.方法

方法名返回类型参数属性说明
iterator()--公有缺省构造
iterator()-Array* arr, int position公有传值构造
operator == ()boolconst iterator& itb公有==运算符重载
operator != ()boolconst iterator& itb公有!=运算符重载
operator + ()iteratorint off公有+运算符重载，支持随机访问
operator - ()iteratorint off公有-运算符重载，支持随机访问
operator ++ ()iterator-公有前置++
operator ++ ()iteratorint公有后置++
operator – ()iterator-公有前置–
operator – ()iteratorint公有后置–
operator * ()Type&-公有*运算符重载，常量迭代器返回值为Type

3.测试

测试封装的数据和方法是否有问题。

3.1.构造函数测试

测试代码：

std::cout << "\n缺省构造：" << std::endl;
Array<int> arr;

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr2(8);

std::cout << "\n传数组，长度构造：" << std::endl;
int array[7]{};
Array<int> arr3(array, 7);

std::cout << "\n拷贝构造：" << std::endl;
Array<int> arr4(arr2);

输出结果：

缺省构造：

传长度构造：

传数组，长度构造：

拷贝构造：

3.2.插入测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(8);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n头部插入：" << std::endl;
arr.push_front(9);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n尾部插入：" << std::endl;
arr.push_back(7);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定位置插入：" << std::endl;
arr.insert(3, 16);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定区间插入：" << std::endl;
arr.insert(4, 7, 16);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
0, 0, 0, 0, 0, 0, 0, 0,

头部插入：
9, 0, 0, 0, 0, 0, 0, 0, 0,

尾部插入：
9, 0, 0, 0, 0, 0, 0, 0, 0, 7,

指定位置插入：
9, 0, 0, 16, 0, 0, 0, 0, 0, 0, 7,

指定区间插入：
9, 0, 0, 16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 7,

3.3.删除测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n头部删除：" << std::endl;
arr.pop_front();
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n尾部删除：" << std::endl;
arr.pop_back();
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定位置删除：" << std::endl;
arr.eraseIndex(3);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定位置指定数据删除：" << std::endl;
arr.eraseIndexValue(3, 8);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

arr.eraseIndexValue(3, 6);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定数据删除：" << std::endl;
std::cout << "\n在3---7插入19：" << std::endl;
arr.insert(3, 7, 19);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定数据删除：" << std::endl;
arr.eraseValue(19);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n指定区间删除：" << std::endl;
arr.eraseSection(3, 7);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

头部删除：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

尾部删除：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11,

指定位置删除：
2, 3, 4, 6, 7, 8, 9, 10, 11,

指定位置指定数据删除：
2, 3, 4, 6, 7, 8, 9, 10, 11,
2, 3, 4, 7, 8, 9, 10, 11,

指定数据删除：

在3---7插入19：
2, 3, 4, 19, 19, 19, 19, 19, 7, 8, 9, 10, 11,

指定数据删除：
2, 3, 4, 7, 8, 9, 10, 11,

指定区间删除：
2, 3, 4,

3.4.查找测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n查找指定数据：" << std::endl;
int res = arr.selectIndex(9);
if (res != -1) {
	std::cout << "在" << res << "处" << std::endl;
}
else {
	std::cout << "找不到！" << std::endl;
}

std::cout << "\n查找指定位置指定数据：" << std::endl;
if (arr.selectIndexValue(3, 9)) {
	std::cout << "在3处是9" << std::endl;
}
else {
	std::cout << "在3处不是9" << std::endl;
}

std::cout << "\n查找指定指定区间数据：" << std::endl;
if (arr.selectSection(3, 9, 5)) {
	std::cout << "5在3-------9之间" << std::endl;
}
else {
	std::cout << "5不在3-------9之间" << std::endl;
}

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

查找指定数据：
在8处

查找指定位置指定数据：
在3处不是9

查找指定指定区间数据：
5在3-------9之间

3.5.替换测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n替换指定数据：" << std::endl;
arr.replaceIndex(1, 44);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n替换目标数据：" << std::endl;
std::cout << "\n在1---5插入22：" << std::endl;
arr.insert(1, 5, 22);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n将22替换为44：" << std::endl;
arr.replaceValue(22, 44);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n替换区间数据：" << std::endl;
arr.replaceSection(1, 12, 33);
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

替换指定数据：
1, 44, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

替换目标数据：

在1---5插入22：
1, 22, 22, 22, 22, 22, 44, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

将22替换为44：
1, 44, 44, 44, 44, 44, 44, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

替换区间数据：
1, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 9, 10, 11, 12,

3.6.反转测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n整体反转：" << std::endl;
Array<int> arr2 = arr.reverse();
for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
	std::cout << arr2[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n区间反转：" << std::endl;
Array<int> arr3 = arr.reverse(4, 7);
for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
	std::cout << arr3[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

整体反转：
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,

区间反转：
1, 2, 3, 4, 8, 7, 6, 5, 9, 10, 11, 12,

3.7.排序测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++ % 5;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n冒泡排序：" << std::endl;
Array<int> arr2 = arr.bubbleSort();
for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
	std::cout << arr2[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n选择排序：" << std::endl;
Array<int> arr3 = arr.selectionSort();
for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
	std::cout << arr3[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2,

冒泡排序：
0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4,

选择排序：
0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4,

3.8.截取测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n截取区间数据：" << std::endl;
Array<int> arr2 = arr.subArray(3, 9);
for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
	std::cout << arr2[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n截取指定位置往后数据：" << std::endl;
Array<int> arr3 = arr.subArray(3);
for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
	std::cout << arr3[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

截取区间数据：
4, 5, 6, 7, 8, 9, 10,

截取指定位置往后数据：
4, 5, 6, 7, 8, 9, 10, 11, 12,

3.9.遍历测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}

std::cout << "\n重载[]遍历：" << std::endl;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\nat函数遍历：" << std::endl;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr.at(i) << ", ";
}
std::cout << std::endl;

std::cout << "\ngetData函数遍历：" << std::endl;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr.getData(i) << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：

重载[]遍历：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

at函数遍历：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

getData函数遍历：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

3.10.连接测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr2(10);

num = 1;
for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
	arr2[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
	std::cout << arr2[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n连接：" << std::endl;
Array<int> arr3 = arr + arr2;
for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
	std::cout << arr3[i] << ", ";
}
std::cout << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

连接：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

3.11.迭代器测试

测试代码：

std::cout << "\n传长度构造：" << std::endl;
Array<int> arr(12);

int num = 1;
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	arr[i] = num++;
}
for (int i = 0; i < static_cast<int>(arr.size()); i++) {
	std::cout << arr[i] << ", ";
}
std::cout << std::endl;

std::cout << "\n正向迭代器遍历：" << std::endl;
for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n正向常量迭代器遍历：" << std::endl;
for (Array<int>::ConstIterator it = arr.cbegin(); it != arr.cend(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n反向迭代器遍历：" << std::endl;
for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n反向常量迭代器遍历：" << std::endl;
for (Array<int>::ConstReverseIterator it = arr.crbegin(); it != arr.crend(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n正向迭代器修改值：" << std::endl;
for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
	*it = 7;
}
for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n反向迭代器修改值：" << std::endl;
for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
	*it = num++;
}
for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
	std::cout << *it << ", ";
}
std::cout << std::endl;

std::cout << "\n迭代器随机访问测试：" << std::endl;
auto it = arr.begin();
std::cout << *it << std::endl;
it = it + 5;
std::cout << *it << std::endl;

输出结果：

传长度构造：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

正向迭代器遍历：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

正向常量迭代器遍历：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,

反向迭代器遍历：
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,

反向常量迭代器遍历：
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,

正向迭代器修改值：
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

反向迭代器修改值：
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,

迭代器随机访问测试：
24
19

4.实现代码

#pragma once
#ifndef _ARRAY_H_
#define _ARRAY_H_

#include <iostream>
#include <cassert>

template <typename Type>
class Array
{
public:
	Array()
	{
		m_array = nullptr;
		m_len = 0;
	}

	Array(size_t len)
	{
		m_array = new Type[len];
		for (int i = 0; i < len; i++) {
			m_array[i] = Type();
		}
		m_len = len;
	}

	Array(Type* array, size_t len)
	{
		if (array == nullptr) {
			m_array = nullptr;
			m_len = 0;
		}
		else {
			m_array = new Type[len];
			for (int i = 0; i < len; i++) {
				m_array[i] = array[i];
			}
			m_len = len;
		}
	}

	Array(const Array& a)
	{
		m_len = a.m_len;
		if (m_len == 0) {
			m_array = nullptr;
		}
		else {
			m_array = new Type[m_len];
			for (int i = 0; i < m_len; i++) {
				m_array[i] = a.m_array[i];
			}
		}
	}

	Array& operator = (const Array& a)
	{
		if (m_array != nullptr) {
			delete[]m_array;
		}

		m_len = a.m_len;
		if (m_len == 0) {
			m_array = nullptr;
		}
		else {
			m_array = new Type[m_len];
			for (int i = 0; i < m_len; i++) {
				m_array[i] = a.m_array[i];
			}
		}

		return *this;
	}

	~Array()
	{
		if (m_array != nullptr) {
			delete[]m_array;
			m_array = nullptr;
		}
	}

	size_t size() const
	{
		return m_len;
	}

	size_t length() const
	{
		return m_len;
	}

	void setData(int index, Type value)
	{
		assert(index >= 0 && index < m_len);
		m_array[index] = value;
	}

	bool empty() const
	{
		return m_array == nullptr;
	}

	/*
	1数组插入数据算法说明：
	1.头部插入
	2.尾部插入
	3.指定位置插入
	4.指定区间插入
	*/
	bool push_front(Type value)
	{
		if (m_array == nullptr) {
			m_array = new int(value);
			if (m_array == nullptr) {
				return false;
			}
			m_len = 1;
		}
		else {
			m_len++;
			Type* newArray = new Type[m_len];
			if (newArray == nullptr) {
				return false;
			}
			for (int i = 1; i < m_len; i++) {
				newArray[i] = m_array[i - 1];
			}
			newArray[0] = value;

			delete[]m_array;
			m_array = newArray;
		}

		return true;
	}

	bool push_back(Type value)
	{
		if (m_array == nullptr) {
			m_array = new int(value);
			if (m_array == nullptr) {
				return false;
			}
			m_len = 1;
		}
		else {
			m_len++;
			Type* newArray = new Type[m_len];
			if (newArray == nullptr) {
				return false;
			}
			for (int i = 0; i < m_len - 1; i++) {
				newArray[i] = m_array[i];
			}
			newArray[m_len - 1] = value;

			delete[]m_array;
			m_array = newArray;
		}

		return true;
	}

	bool insert(int index, Type value)
	{
		if (index == 0) {
			return push_front(value);
		}
		else if (index == m_len) {
			return push_back(value);
		}
		else if (index > m_len) {
			return false;
		}

		m_len++;
		Type* newArray = new Type[m_len];
		if (newArray == nullptr) {
			return false;
		}
		for (int i = 0; i < m_len - 1; i++) {
			if (i < index) {
				newArray[i] = m_array[i];
			}
			else {
				newArray[i + 1] = m_array[i];
			}
		}
		newArray[index] = value;

		delete[]m_array;
		m_array = newArray;

		return true;
	}

	bool insert(int begin, int end, Type value)
	{
		if (begin == end) {
			return insert(begin, value);
		}
		else if (begin > end || end >= m_len) {
			false;
		}

		int count = static_cast<unsigned long long>(end) - begin + 1;
		m_len += count;
		Type* newArray = new Type[m_len];
		if (newArray == nullptr) {
			return false;
		}
		for (int i = 0; i < m_len; i++) {
			if (i < begin) {
				newArray[i] = m_array[i];
			}
			else if (i <= end) {
				newArray[i] = value;
			}
			else {
				newArray[i] = m_array[i - count];
			}
		}

		delete[]m_array;
		m_array = newArray;

		return true;
	}
	//----插入算法结束

	/*
	2数组删除数据算法说明：
	1.头部删除
	2.尾部删除
	3.指定位置删除
	4.指定位置指定数据删除
	5.指定区间删除
	6.指定数据删除
	*/
	int pop_front()
	{
		assert(m_array != nullptr);

		int value = *m_array;

		if (m_len == 1) {
			delete[]m_array;
			m_array = nullptr;
			m_len = 0;
		}
		else {
			m_len--;
			Type* newArray = new Type[m_len];
			for (int i = 0; i < m_len; i++) {
				newArray[i] = m_array[i + 1];
			}
			delete[]m_array;
			m_array = newArray;
		}

		return value;
	}

	int pop_back()
	{
		assert(m_array != nullptr);

		int value = m_array[m_len - 1];

		if (m_len == 1) {
			delete[]m_array;
			m_array = nullptr;
			m_len = 0;
		}
		else {
			m_len--;
			Type* newArray = new Type[m_len];
			for (int i = 0; i < m_len; i++) {
				newArray[i] = m_array[i];
			}
			delete[]m_array;
			m_array = newArray;
		}

		return value;
	}

	bool eraseIndex(int index)
	{
		if (index < 0 || index >= m_len) {
			return false;
		}

		if (m_len == 1) {
			delete[]m_array;
			m_array = nullptr;
			m_len = 0;
		}
		else {
			m_len--;
			Type* newArray = new Type[m_len];
			for (int i = 0; i < m_len; i++) {
				if (i < index) {
					newArray[i] = m_array[i];
				}
				else {
					newArray[i] = m_array[i + 1];
				}
			}
			delete[]m_array;
			m_array = newArray;
		}

		return true;
	}

	bool eraseValue(Type value)
	{
		int i = 0;
		while (i < m_len) {
			if (m_array[i] == value) {
				eraseIndex(i);
			}
			else {
				i++;
			}
		}

		return true;
	}

	bool eraseIndexValue(int index, Type value) 
	{
		if (index < 0 || index >= m_len) {
			return false;
		}

		if (m_array[index] == value) {
			return eraseIndex(index);
		}

		return false;
	}

	bool eraseSection(int begin, int end)
	{
		if (begin < 0 || begin > end || end >= m_len) {
			return false;
		}

		int i = begin;
		while (i <= end) {
			eraseIndex(begin);
			i++;
		}

		return true;
	}
	//----删除算法结束

	/*
	3数组查找数据算法说明：
	1.顺序查找指定数据
	2.指定位置查找指定数据
	3.指定区间查找数据
	*/
	int selectIndex(int val)
	{
		for (int i = 0; i < m_len; i++) {
			if (m_array[i] == val) {
				return i;
			}
		}

		return -1;
	}

	bool selectIndexValue(int index, Type val)
	{
		if (index < 0 || index >= m_len) {
			return false;
		}

		return m_array[index] == val;
	}

	bool selectSection(int begin, int end, Type value)
	{
		if (begin < 0 || begin > end || end >= m_len) {
			return false;
		}

		for (int i = begin; i <= end; i++) {
			if (m_array[i] == value) {
				return true;
			}
		}

		return false;
	}
	//----查找算法结束

	/*
	4数组替换数据算法说明：
	1.替换指定位置数据
	2.替换指定目标数据
	3.替换指定区间数据
	*/
	bool replaceIndex(int index, Type value)
	{
		if (index < 0 || index >= m_len) {
			return false;
		}

		m_array[index] = value;
		return true;
	}

	bool replaceValue(Type target, Type value)
	{
		for (int i = 0; i < m_len; i++) {
			if (m_array[i] == target) {
				m_array[i] = value;
			}
		}

		return true;
	}

	bool replaceSection(int begin, int end, Type value)
	{
		if (begin < 0 || begin > end || end >= m_len) {
			return false;
		}

		for (int i = begin; i <= end; i++) {
			m_array[i] = value;
		}

		return true;
	}
	//----替换算法结束

	/*
	5数组反转数据算法说明：
	1.整体反转
	2.指定区间反转
	*/
	Array<Type> reverse()
	{
		Array<Type> arr(m_len );
		for (int i = 0; i < static_cast<int>(m_len); i++) {
			arr[i] = this->operator[](static_cast<int>(m_len) - i - 1);
		}

		return arr;
	}

	Array<Type> reverse(int begin, int end)
	{
		if (begin < 0 || begin > end || end >= m_len) {
			return Array<Type>();
		}

		Array<Type> arr(*this);
		
		for (int i = begin, j = end; i < j; i++, j--) {
			std::swap(arr[i], arr[j]);
		}

		return arr;
	}
	//----反转算法结束

	/*
	6数组排序算法说明：
	1.冒泡排序
	2.选择排序
	*/
	Array<Type> bubbleSort()
	{
		Array<Type> arr(*this);

		for (int i = 0; i < m_len; i++) {
			for (int j = 0; j < m_len - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					std::swap(arr[j], arr[j + 1]);
				}
			}
		}

		return arr;
	}

	Array<Type> selectionSort()
	{
		Array<Type> arr(*this);

		for (int i = 0; i < m_len - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < m_len; j++) {
				if (arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}

			if (minIndex != i) {
				std::swap(arr[i], arr[minIndex]);
			}
		}

		return arr;
	}
	//----排序算法结束

	/*
	数组截取数据算法说明：
	1.截取区间数据
	2.截取指定位置往后数据
	*/
	Array<Type> subArray(int begin, int end)
	{
		if (begin < 0 || begin > end || end >= m_len) {
			return Array<Type>();
		}

		int len = end - begin + 1;
		Type* subarr = new Type[len];
		for (int i = begin; i <= end; i++) {
			subarr[i - begin] = m_array[i];
		}

		return Array<Type>(subarr, len);
	}

	Array<Type> subArray(int begin)
	{
		if (begin < 0 || begin >= m_len) {
			return Array<Type>();
		}

		int len = static_cast<int>(m_len) - begin;
		Type* subarr = new Type[len];
		for (int i = begin; i < m_len; i++) {
			subarr[i - begin] = m_array[i];
		}

		return Array<Type>(subarr, len);
	}
	//----截取算法结束

	/*
	数组遍历算法说明：
	*/
	Type getData(int index)
	{
		assert(index >= 0 && index < m_len);
		return m_array[index];
	}

	Type& operator [] (int index)
	{
		assert(index >= 0 && index < m_len);
		return m_array[index];
	}

	Type at(int index)
	{
		assert(index >= 0 && index < m_len);
		return m_array[index];
	}
	//----遍历算法结束

	/*
	数组连接算法说明：
	*/
	friend Array operator + (Array a, Array b)
	{
		size_t alen = a.size();
		size_t blen = b.size();
		if (alen == 0 && blen == 0) {
			return Array();
		}

		size_t len = alen + blen;
		Array c(len);

		int i = 0;
		while (i < len) {
			if (i < alen) {
				c[i] = a[i];
			}
			else {
				c[i] = b[i - static_cast<int>(alen)];
			}

			i++;
		}

		return c;
	}
	//----连接算法结束

private:
	Type* m_array;
	size_t m_len;

public:
	class IteratorBase {
	public:
		IteratorBase()
		{
			m_arr = nullptr;
			m_position = 0;
		}

		IteratorBase(Array<Type>* arr, int position)
		{
			m_arr = arr;
			m_position = position;
		}

	protected:
		Array<Type>* m_arr;
		int m_position;
	};

	class Iterator : public IteratorBase
	{
		using MyBase = IteratorBase;
	public:
		Iterator()
			: IteratorBase()
		{

		}

		Iterator(Array<Type>* arr, int position)
			: IteratorBase(arr, position)
		{

		}

		bool operator == (const Iterator& itb)
		{
			return MyBase::m_position == itb.MyBase::m_position;
		}

		bool operator != (const Iterator& itb)
		{
			return MyBase::m_position != itb.MyBase::m_position;
		}

		Iterator operator + (int off)
		{
			assert(MyBase::m_position + off <= MyBase::m_arr->m_len);

			Iterator it = *this;
			it.MyBase::m_position += off;

			return it;
		}

		Iterator operator - (int off)
		{
			assert(MyBase::m_position - off >= 0);

			Iterator it = *this;
			it.MyBase::m_position -= off;

			return it;
		}

		Iterator operator ++ ()
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			MyBase::m_position++;

			return *this;
		}

		Iterator operator ++ (int)
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			Iterator& it = *this;
			MyBase::m_position++;

			return it;
		}

		Iterator operator -- ()
		{
			assert(MyBase::m_position - 1 >= 0);
			MyBase::m_position--;

			return *this;
		}

		Iterator operator -- (int)
		{
			assert(MyBase::m_position - 1 >= 0);
			Iterator& it = *this;
			MyBase::m_position--;

			return it;
		}

		Type& operator * ()
		{
			return MyBase::m_arr->operator[](MyBase::m_position);
		}
	};

	class ConstIterator : public IteratorBase
	{
		using MyBase = IteratorBase;
	public:
		ConstIterator()
			: IteratorBase()
		{

		}

		ConstIterator(Array<Type>* arr, int position)
			: IteratorBase(arr, position)
		{

		}

		bool operator == (const ConstIterator& itb)
		{
			return MyBase::m_position == itb.MyBase::m_position;
		}

		bool operator != (const ConstIterator& itb)
		{
			return MyBase::m_position != itb.MyBase::m_position;
		}

		ConstIterator operator + (int off)
		{
			assert(MyBase::m_position + off <= MyBase::m_arr->m_len);

			ConstIterator it = *this;
			it.MyBase::m_position += off;

			return it;
		}

		ConstIterator operator - (int off)
		{
			assert(MyBase::m_position - off >= 0);
			
			ConstIterator it = *this;
			it.MyBase::m_position -= off;

			return it;
		}

		ConstIterator operator ++ ()
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			MyBase::m_position++;

			return *this;
		}

		ConstIterator operator ++ (int)
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			ConstIterator& it = *this;
			MyBase::m_position++;

			return it;
		}

		ConstIterator operator -- ()
		{
			assert(MyBase::m_position - 1 >= 0);
			MyBase::m_position--;

			return *this;
		}

		ConstIterator operator -- (int)
		{
			assert(MyBase::m_position - 1 >= 0);
			ConstIterator& it = *this;
			MyBase::m_position--;

			return it;
		}

		Type operator * ()
		{
			return MyBase::m_arr->operator[](MyBase::m_position);
		}
	};

	class ReverseIterator : public IteratorBase
	{
		using MyBase = IteratorBase;
	public:
		ReverseIterator()
			: IteratorBase()
		{

		}

		ReverseIterator(Array<Type>* arr, int position)
			: IteratorBase(arr, position)
		{

		}

		bool operator == (const ReverseIterator& itb)
		{
			return MyBase::m_position == itb.MyBase::m_position;
		}

		bool operator != (const ReverseIterator& itb)
		{
			return MyBase::m_position != itb.MyBase::m_position;
		}

		ReverseIterator operator + (int off)
		{
			assert(MyBase::m_position + off <= MyBase::m_arr->m_len);

			ReverseIterator it = *this;
			it.MyBase::m_position += off;

			return it;
		}

		ReverseIterator operator - (int off)
		{
			assert(MyBase::m_position - off >= 0);
			ReverseIterator it = *this;
			it.MyBase::m_position -= off;

			return *this;
		}

		ReverseIterator operator ++ ()
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			MyBase::m_position++;

			return *this;
		}

		ReverseIterator operator ++ (int)
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);

			ReverseIterator& it = *this;
			MyBase::m_position++;

			return it;
		}

		ReverseIterator operator -- ()
		{
			assert(MyBase::m_position - 1 >= 0);
			MyBase::m_position--;

			return *this;
		}

		ReverseIterator operator -- (int)
		{
			assert(MyBase::m_position - 1 >= 0);
			ReverseIterator& it = *this;
			MyBase::m_position--;

			return it;
		}

		Type& operator * ()
		{
			return MyBase::m_arr->operator[](static_cast<int>(MyBase::m_arr->m_len) - MyBase::m_position - 1);
		}
	};

	class ConstReverseIterator : public IteratorBase
	{
		using MyBase = IteratorBase;
	public:
		ConstReverseIterator()
			: MyBase()
		{

		}

		ConstReverseIterator(Array<Type>* arr, int position)
			: MyBase(arr, position)
		{

		}

		bool operator == (const ConstReverseIterator& itb)
		{
			return MyBase::m_position == itb.MyBase::m_position;
		}

		bool operator != (const ConstReverseIterator& itb)
		{
			return MyBase::m_position != itb.MyBase::m_position;
		}

		ConstReverseIterator operator + (int off)
		{
			assert(MyBase::m_position + off <= MyBase::m_arr->m_len);

			ConstReverseIterator it = *this;
			it.MyBase::m_position += off;

			return it;
		}

		ConstReverseIterator operator - (int off)
		{
			assert(MyBase::m_position - off >= 0);
			ConstReverseIterator it = *this;
			it.MyBase::m_position -= off;

			return *this;
		}

		ConstReverseIterator operator ++ ()
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);
			MyBase::m_position++;

			return *this;
		}

		ConstReverseIterator operator ++ (int)
		{
			assert(MyBase::m_position + 1 <= MyBase::m_arr->m_len);

			ConstReverseIterator& it = *this;
			MyBase::m_position++;

			return it;
		}

		ConstReverseIterator operator -- ()
		{
			assert(MyBase::m_position - 1 >= 0);
			MyBase::m_position--;

			return *this;
		}

		ConstReverseIterator operator -- (int)
		{
			assert(MyBase::m_position - 1 >= 0);
			ConstReverseIterator& it = *this;
			MyBase::m_position--;

			return it;
		}

		Type operator * ()
		{
			return MyBase::m_arr->operator[](static_cast<int>(MyBase::m_arr->m_len) - MyBase::m_position - 1);
		}
	};

	Iterator begin()
	{
		return Iterator(this, 0);
	}

	Iterator end()
	{
		return Iterator(this, static_cast<int>(m_len));
	}

	ConstIterator cbegin()
	{
		return ConstIterator(this, 0);
	}

	ConstIterator cend()
	{
		return ConstIterator(this, static_cast<int>(m_len));
	}

	ReverseIterator rbegin()
	{
		return ReverseIterator(this, 0);
	}

	ReverseIterator rend()
	{
		return ReverseIterator(this, static_cast<int>(m_len));
	}

	ConstReverseIterator crbegin()
	{
		return ConstReverseIterator(this, 0);
	}

	ConstReverseIterator crend()
	{
		return ConstReverseIterator(this, static_cast<int>(m_len));
	}
};

#endif //_ARRAY_H_

5.测试代码

#include "Array.h"

void constructorTest();//构造函数测试
void insertTest();//插入测试
void eraseTest();//删除测试
void selectTest();//查找测试
void replaceTest();//替换测试
void reverseTest();//反转测试
void sortTest();//排序测试
void subTest();//截取测试
void ergodicTest();//遍历测试
void connectTest();//连接测试
void iteratorTest();//迭代器测试

int main()
{
	constructorTest();//构造函数测试
	insertTest();//插入测试
	eraseTest();//删除测试
	selectTest();//查找测试
	replaceTest();//替换测试
	reverseTest();//反转测试
	sortTest();//排序测试
	subTest();//截取测试
	ergodicTest();//遍历测试
	connectTest();//连接测试
	iteratorTest();//迭代器测试

	return 0;
}

void constructorTest()//构造函数测试
{
	std::cout << "\n缺省构造：" << std::endl;
	Array<int> arr;

	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr2(8);

	std::cout << "\n传数组，长度构造：" << std::endl;
	int array[7]{};
	Array<int> arr3(array, 7);

	std::cout << "\n拷贝构造：" << std::endl;
	Array<int> arr4(arr2);
}

void insertTest()//插入测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(8);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n头部插入：" << std::endl;
	arr.push_front(9);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n尾部插入：" << std::endl;
	arr.push_back(7);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定位置插入：" << std::endl;
	arr.insert(3, 16);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定区间插入：" << std::endl;
	arr.insert(4, 7, 16);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;
}

void eraseTest()//删除测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n头部删除：" << std::endl;
	arr.pop_front();
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n尾部删除：" << std::endl;
	arr.pop_back();
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定位置删除：" << std::endl;
	arr.eraseIndex(3);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定位置指定数据删除：" << std::endl;
	arr.eraseIndexValue(3, 8);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	arr.eraseIndexValue(3, 6);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定数据删除：" << std::endl;
	std::cout << "\n在3---7插入19：" << std::endl;
	arr.insert(3, 7, 19);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定数据删除：" << std::endl;
	arr.eraseValue(19);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n指定区间删除：" << std::endl;
	arr.eraseSection(3, 7);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;
}

void selectTest()//查找测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n查找指定数据：" << std::endl;
	int res = arr.selectIndex(9);
	if (res != -1) {
		std::cout << "在" << res << "处" << std::endl;
	}
	else {
		std::cout << "找不到！" << std::endl;
	}

	std::cout << "\n查找指定位置指定数据：" << std::endl;
	if (arr.selectIndexValue(3, 9)) {
		std::cout << "在3处是9" << std::endl;
	}
	else {
		std::cout << "在3处不是9" << std::endl;
	}

	std::cout << "\n查找指定指定区间数据：" << std::endl;
	if (arr.selectSection(3, 9, 5)) {
		std::cout << "5在3-------9之间" << std::endl;
	}
	else {
		std::cout << "5不在3-------9之间" << std::endl;
	}
}

void replaceTest()//替换测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n替换指定数据：" << std::endl;
	arr.replaceIndex(1, 44);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n替换目标数据：" << std::endl;
	std::cout << "\n在1---5插入22：" << std::endl;
	arr.insert(1, 5, 22);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n将22替换为44：" << std::endl;
	arr.replaceValue(22, 44);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n替换区间数据：" << std::endl;
	arr.replaceSection(1, 12, 33);
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;
}

void reverseTest()//反转测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n整体反转：" << std::endl;
	Array<int> arr2 = arr.reverse();
	for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
		std::cout << arr2[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n区间反转：" << std::endl;
	Array<int> arr3 = arr.reverse(4, 7);
	for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
		std::cout << arr3[i] << ", ";
	}
	std::cout << std::endl;
}

void sortTest()//排序测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++ % 5;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n冒泡排序：" << std::endl;
	Array<int> arr2 = arr.bubbleSort();
	for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
		std::cout << arr2[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n选择排序：" << std::endl;
	Array<int> arr3 = arr.selectionSort();
	for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
		std::cout << arr3[i] << ", ";
	}
	std::cout << std::endl;
}

void subTest()//截取测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n截取区间数据：" << std::endl;
	Array<int> arr2 = arr.subArray(3, 9);
	for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
		std::cout << arr2[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n截取指定位置往后数据：" << std::endl;
	Array<int> arr3 = arr.subArray(3);
	for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
		std::cout << arr3[i] << ", ";
	}
	std::cout << std::endl;
}

void ergodicTest()//遍历测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}

	std::cout << "\n重载[]遍历：" << std::endl;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\nat函数遍历：" << std::endl;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr.at(i) << ", ";
	}
	std::cout << std::endl;

	std::cout << "\ngetData函数遍历：" << std::endl;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr.getData(i) << ", ";
	}
	std::cout << std::endl;
}

void connectTest()//连接测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr2(10);

	num = 1;
	for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
		arr2[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr2.size()); i++) {
		std::cout << arr2[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n连接：" << std::endl;
	Array<int> arr3 = arr + arr2;
	for (int i = 0; i < static_cast<int>(arr3.size()); i++) {
		std::cout << arr3[i] << ", ";
	}
	std::cout << std::endl;
}

void iteratorTest()//迭代器测试
{
	std::cout << "\n传长度构造：" << std::endl;
	Array<int> arr(12);

	int num = 1;
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		arr[i] = num++;
	}
	for (int i = 0; i < static_cast<int>(arr.size()); i++) {
		std::cout << arr[i] << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n正向迭代器遍历：" << std::endl;
	for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n正向常量迭代器遍历：" << std::endl;
	for (Array<int>::ConstIterator it = arr.cbegin(); it != arr.cend(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n反向迭代器遍历：" << std::endl;
	for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n反向常量迭代器遍历：" << std::endl;
	for (Array<int>::ConstReverseIterator it = arr.crbegin(); it != arr.crend(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n正向迭代器修改值：" << std::endl;
	for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
		*it = 7;
	}
	for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n反向迭代器修改值：" << std::endl;
	for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
		*it = num++;
	}
	for (Array<int>::ReverseIterator it = arr.rbegin(); it != arr.rend(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	for (Array<int>::Iterator it = arr.begin(); it != arr.end(); it++) {
		std::cout << *it << ", ";
	}
	std::cout << std::endl;

	std::cout << "\n迭代器随机访问测试：" << std::endl;
	auto it = arr.begin();
	std::cout << *it << std::endl;
	it = it + 5;
	std::cout << *it << std::endl;
}

6.总结

特殊的测试没有做，不知道有没有问题。

大唐不良猿
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ opencv的Mat多维数组的初始化、dot、Element-wise
修炼之路
06-15 4912
Mat多维数组初始化 #include <iostream> #include <opencv2/opencv.hpp> #include <opencv2/imgproc/imgproc.hpp> #include <opencv2/highgui/highgui.hpp> int main() { //定义一个float数组 float a[4] = {1,2,3,4}; //将数组转换为矩阵,2行2列的矩阵 cv::
基于VS2017的算法验证中，用C/C++读取MATLAB中mat结构体数据
u010332101的博客
05-12 2122
基于VS2017的算法验证中，用C/C++读取用MATLAB中mat结构体数据 由于生成算法代码验证所需的数据量比较大，且不易构建，所以调用MATLAB与C/C++的混合编程接口，将MATLAB中生成的验证所需的数据存为mat来读取。其实网站上对于如何用C/C++读取mat数据有详细的介绍，写这篇文字目的只是想把实现这个过程中 碰到的问题记录下来，如果再有人有这个需要可以不用再去查查查 翻资料了。也许这里面也会有错误，欢迎指正。 1、配置注意事项 VS2017中关联库及附加项等等，右键工程属性中即可找到，具
C++读取.mat文件到opencv的Mat结构中
nullganbadie的博客
03-15 2976
因项目需要，最近在研究C++如何读取matlab的.mat文件，本文主要内容包括读取矩阵储存的.mat文件和结构体储存的.mat文件。 话不多说，直接上代码： #include &lt;mat.h&gt; #include &lt;iostream&gt; #include &lt;opencv2/opencv.hpp&gt; using namespace std; using names...
C++把一个文件下的所有文件遍历到一个数组里
guanxunmeng8928的博客
01-06 265
void FindAllFile(CString path, CString* filenames, int& count) { CFileFind finder; BOOL working = finder.FindFile(path + "\\*.*"); while (working) { working = finder.FindNextFileW(); if (finder.IsDots()) { continue; } else if (finder..
C++遍历方法
独孤过的博客
07-18 9650
下标 迭代器 STL for_each 基于范围循环 for for each foreach
数据结构C++描述
03-15
数据结构C++描述 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 3 1.2.3 引用参数 3 1.2.4 常量引用参数 4 1.2.5 返回值 4 1.2.6 递归...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
11.7.2 指向结构数组的指针 179 11.7.3 结构指针变量作函数参数 180 11.8 动态存储分配 181 11.9 链表的概念 182 11.10 枚举类型 184 11.10.1 枚举类型的定义和枚举变量的说明 184 11.10.2 枚举类型变量的赋值和使用...
数据结构与算法：C++描述
11-10
本书在简要回顾了基本的C++ 程序设计概念的基础上，全面系统地介绍了队列、堆栈、树、图等基本数据结构，以及贪婪算法、分而治之算法、分枝定界算法等多种算法设计方法，为数据结构与算法的继续学习和研究奠定了一个...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
C++常见的遍历算法
m0_63932570的博客
03-29 1114
在结束完前面的容器学习后，紧随其后的就是C++种常见的算法啦，学完C++这几种常见的算法后，会发现我们在学数据结构时用C语言写的算法相比，C++这几种算法真的节省了不少代码（对于博主这种喜欢走捷径的人来说无疑是一件好事）。当然这里不是说数据结构里的那些算法就没有用，那是我们C++算法的底层本质，还是有必要去好好深究的。下面就让我们来看看这第一种算法——遍历算法吧 1.for_each 用法代码： 2.transform： 用法代码： 3.find：用法代码： 自定义类型的查找： .
数据结构 数组
03-31
数据结构 数组源代码 程序 数组的使用
第8讲-结构体与结构体数组
02-15
讲解区分结构体与结构体数组：结构体的引出、结构体变量的定义和引用、结构体数组
使用c++超详细解释数据结构中的数组
Mr.林先生的博客
03-24 1548
数组是数据结构中最基本的数据类型之一，它是一组具有相同数据类型的数据元素的集合，每个元素可以通过一个索引（Index）来访问。在C++中，数组是一种固定大小的数据结构，可以使用数组名和索引来访问数组元素。下面我们来详细讲解数组在数据结构中涉及的所有知识点。
【C++】【一】结构体数组
格物致知
09-07 1188
#include<iostream> using namespace std; #include <string> #include <ctime> //学生的结构体 struct Student { //姓名 string sName; //分数 int score; }; //老师的结构体定义 struct Teacher { //姓名 string tName; //学生数组 struct Student sArray[5]; }; ...
C++学习笔记之数组，结构体...
qq_42761380的博客
01-26 2047
一维数组，结构体，字符串引用等基础知识
c++数组长度函数length_C++可变长的数组，老司机手把手教你实现
weixin_39603995的博客
11-28 3014
01 实现自定义的可变长数组类型假设我们要实现一个会自动扩展的数组，要实现什么函数呢？先从下面的main函数给出的实现，看看有什么函数是需要我们实现的。int main(){ MyArray a; // 初始化的数组是空的 for(int i = 0; i < 5; ++i) a.push_back(i); // push_back是成员函数 MyArray...
c++创建数组的三种方式
热门推荐
dawnButterfly的博客
05-14 3万+
#include<iostream> using namespace std; int main() { //c++创建数组的三种方式。 int tab[] = { 1,2,3 }; //方法二 int tab1[10]; //方法三 int tab2[10] = { 1,2,3 }; cout << tab2[2] << endl; cout << tab2[3] << endl; cout << size
opencv中的Mat与数组互转
秋月的私语
07-09 1万+
直接上代码，初步验证测试正确，数组形式与opencv的存储方式一致为BGR。 cv::Mat TransBufferToMat(unsigned char* pBuffer, int nWidth, int nHeight, int nBandNum, int nBPB = 1) { cv::Mat mDst; if (nBandNum == 4) { ...
opencv C++ Mat类的基本知识（混
cicistream
11-09 1万+
Mat::clone()  创建一个全拷贝 Mat::copyTo();  不止表示拷贝数据，还表示n=m.col(0) Mat矩阵中数据指针Mat.data是uchar类型指针，CV_8U系列可以通过计算指针位置快速地定位矩阵中的任意元素。
c++如何向结构体数组中加入一组数据
最新发布
06-07
假设有以下结构体定义...// 向第一个元素中加入数据 students[0].name = "Tom"; students[0].age = 18; students[0].score = 90.5; ``` 同样的方式可以向其它元素中加入数据，只需要将数组下标修改为对应的元素即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大唐不良猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值