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

一时失言乱红尘 2023-01-01 12:51 157阅读 0赞

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

**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;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY0NTI4MQ_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY0NTI4MQ_size_16_color_FFFFFF_t_70]: /images/20221120/394ffedbdca44bdcbfb7b6689de1ee98.png