43.数组类封装

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include "MyArray.h"
using namespace std;


void test01()
{
	//堆区创建数组
	MyArray * array = new MyArray(30);

	MyArray  * array2 = new MyArray(*array);  //new方式指定调用拷贝构造
	MyArray array3 = *array;    //构造函数返回的本体

	//MyArray * array4 = array; //这个是声明一个指针 和array执行的地址相同，所以不会调用拷贝构造

	delete array;
	//尾插法测试
	for (int i = 0; i < 10;i++)
	{
		array2->push_Back(i);
	}
	//获取数据测试
	for (int i = 0; i < 10;i++)
	{
		cout << array2->getData(i) << endl;
	}
	
	//设置值测试
	array2->setData(0, 1000);

	cout << array2->getData(0) << endl;;

	//获取数组大小
	cout << "array2 的数组大小为： " << array2->getSize() << endl;


	//获取数组容量
	cout << "array2 的数组容量为： " << array2->getCapacity() << endl;

	//获取 设置 数组内容  如何用[]进行设置和访问
	array3.push_Back(100000);
	cout << array3.getData(0) << endl;
	cout << array3[0] << endl;
	array3[0] = 100; // 100000 = 100
	cout << array3[0] << endl;

}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

输出

拷贝构造调用
拷贝构造调用
0
1
2
3
4
5
6
7
8
9
1000
array2 的数组大小为： 10
array2 的数组容量为： 30
100000
100000
100

MyArray.h

#pragma  once
#include <iostream>
using namespace std;

class MyArray
{
public:
	MyArray(); //默认构造  默认100容量
	MyArray(int capacity);
	MyArray(const MyArray& array);

	~MyArray();


	//尾插法
	void push_Back(int val);

	//根据索引获取值
	int getData(int index);

	//根据索引设置值
	void setData(int index, int val);

	//获取数组大小
	int getSize();

	//获取数组容量
	int getCapacity();

	//[]运算符重载
	int& operator[](int index );

private:
	int * pAddress; //指向真正存储数据的指针
	int m_Size; //数组大小
	int m_Capacity; //数组容量

};

MyArray.cpp

#include "MyArray.h"

//默认构造
MyArray::MyArray()
{
	this->m_Capacity = 100;
	this->m_Size = 0;
	this->pAddress = new int[this->m_Capacity];
}
//有参构造  参数 数组容量
MyArray::MyArray(int capacity)
{
	//cout << "有参函数调用" << endl;
	this->m_Capacity = capacity;
	this->m_Size = 0;
	this->pAddress = new int[this->m_Capacity];
}

//拷贝构造
MyArray::MyArray(const MyArray& array)
{
	cout << "拷贝构造调用" << endl;
	this->pAddress = new int[array.m_Capacity]; 
	this->m_Size = array.m_Size;
	this->m_Capacity = array.m_Capacity;

	for (int i = 0; i < array.m_Size;i++)
	{
		this->pAddress[i] = array.pAddress[i];
	}

}
//析构
MyArray::~MyArray()
{
	if (this->pAddress != NULL)
	{
		//cout << "析构调用" << endl;
		delete[] this->pAddress;
		this->pAddress = NULL;
	}
}

void MyArray::push_Back(int val)
{
	//判断越界？ 用户自己处理
	this->pAddress[this->m_Size] = val;
	this->m_Size++;
}

int MyArray::getData(int index)
{
	return this->pAddress[index];
}

void MyArray::setData(int index, int val)
{
	this->pAddress[index] = val;
}

int MyArray::getSize()
{
	return this->m_Size;
}

int MyArray::getCapacity()
{
	return this->m_Capacity;
}

//[]重载实现
int& MyArray::operator[](int index)
{

	return this->pAddress[index];
}