动态数组功能C++代码实现

数组是一种线性表数据结构。它用一组连续内存空间，来存储一组具有相同数据类型数据。

my_array.h

#pragma once


class My_Array
{
public:
	My_Array();		//默认构造函数
	My_Array(int N_Size,double D_Value=0);	//构造函数,设置数组大小，默认值为Dvalue
	My_Array(const My_Array& arr);		//拷贝构造函数
	My_Array& operator=(const My_Array& arr); // 拷贝赋值运算符
	~My_Array();	//析构函数

	void Print_Array();		//输出所有数组的值
	int  Get_ArraySize();	//获取数组的大小
	void Set_ArraySize(int N_Size);	//重新设置数组的大小
	double Get_ElementLocation(int N_Index);	//获取数组位置元素
	void Set_ElementLocation(int N_Index, double D_Value); // 重置指定元素的值 
	void PushBack(double D_Value);				// 在数组末尾添加元素 
	void Delete_ElementLocation(int N_Index);   // 删除指定位置的元素 
	void Insert_ElementLocation(int N_Index, double D_Value);	// 插入一个新的元素到数组中 
	double operator[](int N_Index) const;						// 重载下标运算符[] 

private:
	double *m_data;	//存放数组的动态内存指针
	int m_size;		//数组的元素个数
	int m_max;		//预留给动态数组的内存个数

private:
	void Init();	//初始化
	void Free();	//释放动态内存
	inline bool Invalidate_Index(int N_Index);	//判断下标的合法性
};

my_array.cpp

#include "my_array.h"
#include<cstring>
#include<iostream>

using namespace std;
	/*数组初始化*/
void My_Array::Init()
{
	m_size = 0;
	m_max = 1;
	m_data = new double[m_max];
}

/*释放数组动态内存*/
void My_Array::Free()
{
	delete[] m_data;

}

	/*判断下标*/
bool My_Array::Invalidate_Index(int N_Index)
{
	if (N_Index >= 0 && N_Index < m_size)
		return false;
	else
		return true;

}

/*默认构造函数*/
My_Array::My_Array()
{
	Init();
}

/*构造函数*/
My_Array::My_Array(int N_Size, double D_Value)
{
	if (N_Size == 0)
		Init();
	else
	{
		m_size = N_Size;
		m_max = N_Size;
		m_data = new double[m_max];
		for (int i = 0; i<N_Size; ++i)
			m_data[i] = D_Value;
	}
}

/*拷贝构造函数*/
My_Array::My_Array(const My_Array& arr)
{
	m_size = arr.m_size;
	m_max = arr.m_size;
	m_data = new double[m_max];
	memcpy(m_data, arr.m_data, m_size * sizeof(double));
}

	/*拷贝赋值运算符*/ 
My_Array& My_Array::operator=(const My_Array& arr)
{
	if (this == &arr) /*自赋值*/
		return *this;
	m_size = arr.m_size;
	m_max = arr.m_max;
	/* 先将右侧对象拷贝到临时对象中，然后再销毁左侧对象*/
	double *m_Temp = new double[m_max];
	memcpy(m_Temp, arr.m_data, m_size * sizeof(double));
	delete[] m_data;
	m_data = m_Temp;

	return *this;
}

	/*析构函数 */
My_Array::~My_Array()
{
	Free();
}

/*打印数组*/
void My_Array::Print_Array()
{
	if (m_size == 0)
	{
		cout << "此数组为空！" << endl;
		exit(0);
	}
	else
	{
		for (int i = 0; i<m_size; ++i)
			cout << m_data[i] << " ";
		cout << endl;
	}
}

	/*获取数组大小*/ 
int My_Array::Get_ArraySize()
{
	return m_size;
}

	/*重置数组大小 */
void My_Array::Set_ArraySize(int N_Size)
{
	//三种情况
	if (N_Size < m_size)  /*截断N_Size的元素*/
	{
		for (int i = N_Size; i<m_size; ++i)
			m_data[i] = 0;
	}
	if (m_size <= N_Size && N_Size <= m_max) /*新增元素置0*/
	{
		for (int i = m_size; i<N_Size; ++i)
			m_data[i] = 0;
	}
	if (N_Size > m_max)  /*需要重新分配空间*/
	{
		m_max = N_Size;
		double *temp = new double[m_max];
		memcpy(temp, m_data, m_size * sizeof(double));
		for (int i = m_size; i<N_Size; ++i)
			temp[i] = 0;
		delete[] m_data;
		m_data = temp;
	}
	m_size = N_Size; /*设置数组大小*/
}

		/* 获取数组位置上元素*/ 
double My_Array::Get_ElementLocation(int N_Index)
{
	if (Invalidate_Index(N_Index))
	{
		cout << "数组索引无效!" << endl;
		exit(0);
	}
	return m_data[N_Index];
}

// 设置指定位置元素的值 
void My_Array::Set_ElementLocation(int N_Index, double D_Value)
{
	if (Invalidate_Index(N_Index))
	{
		cout << "数组索引无效!" << endl;
		exit(0);
	}
	else
	{
		m_data[N_Index] = D_Value;
	}
}

void My_Array::PushBack(double D_Value)
{
	if (m_size < m_max)
	{
		m_data[m_size] = D_Value;
	}
	else
	{
		m_max = m_max * 2;
		double* temp = new double[m_max];
		memcpy(temp, m_data, m_size * sizeof(double));
		delete[] m_data;
		m_data = temp;
		m_data[m_size] = D_Value;
	}
	++m_size; /*数组大小加1*/
}

// 从数组中删除一个元素 
void My_Array::Delete_ElementLocation(int N_Index)
{
	if (Invalidate_Index(N_Index))
	{
		cout << "数组索引无效!" << endl;
		exit(0);
	}
	else
	{
		for (int i = N_Index; i<m_size; ++i)
			m_data[i] = m_data[i + 1];
		m_data[m_size - 1] = 0;
		--m_size;
	}
}

// 插入一个新元素到指定位置 
void My_Array::Insert_ElementLocation(int N_Index, double D_Value)
{
	if (N_Index<0 || N_Index>m_size)
	{
		cout << "数组插入索引无效!" << endl;
		exit(0);
	}

	if (m_size < m_max) /* 未满，插入 */
	{
		for (int i = m_size - 1; i >= N_Index; --i)
			m_data[i + 1] = m_data[i];
		m_data[N_Index] = D_Value;
	}
	else        /* 重新分配空间 */
	{
		m_max = m_max * 2;
		double* temp = new double[m_max];
		memcpy(temp, m_data, m_size * sizeof(double));
		delete[] m_data;
		m_data = temp;
		for (int i = m_size - 1; i >= N_Index; --i)
			m_data[i + 1] = m_data[i];
		m_data[N_Index] = D_Value;
	}
	++m_size; /* 数组大小加1 */
}

// 重载下标运算符[] 
double My_Array::operator[](int N_Index) const
{
	if (N_Index<0 || N_Index >= m_size)
	{
		cout << "Error: the index in [] is invalid!" << endl;
		exit(0);
	}
	return m_data[N_Index];
}

test_array.cpp

#include "my_array.h"
#include<cstring>
#include<iostream>
using namespace std;

int main()
{
	//默认构造
	My_Array arr1;
	//构造函数
	My_Array arr2(10,7);
	//拷贝构造函数
	My_Array arr3(arr2);
	
	//显示数组
	arr1.PushBack(10);	//尾部插入元素
	arr1.Print_Array();
	arr2.Print_Array();
	arr3.Print_Array();

	//数组大小
	cout << "arr1 size: " << arr1.Get_ArraySize() << endl;
	cout << "arr2 size: " << arr2.Get_ArraySize() << endl;

	//重置数组大小
	arr2.Set_ArraySize(5);
	arr2.Print_Array();
	cout << "revise arr2 size: " << arr2.Get_ArraySize() << endl;

	//获取指定位置元素
	cout << "arr2[0] :" << arr2.Get_ElementLocation(0) << endl;

	//设置指定位置元素
	arr2.Set_ElementLocation(2, 3);
	arr2.Print_Array();

	//删除元素
	arr2.Delete_ElementLocation(3);
	arr2.Print_Array();

	//插入元素到指定位置
	arr2.Insert_ElementLocation(2, 9);
	arr2.Print_Array();

	//下标访问
	cout << arr2[2] << endl;

	system("pause");
	return 0;
}