C++动态数组扩容类

C++数组扩容类

#include<iostream>
#include<string>
using namespace std;
class Myarray {
	int maxval = 3;//自定义空间上限
	//不推荐写法:int *arr = new int[maxval];这会导致，在拷贝构造时，
	//即使写了arr= new int[maxval]，两个对象指向的还是同一片地址。
	//从而导致在析构时，delete语句去删除一个已经没有内存指向的野指针，触发断点。
	int *arr;
	int length=0;//数组长度
	int fp = 0;//数组末尾元素下标

	void insert_elem(int elem) {//只用于类内函数调用，有扩容机制的给arr增加元素
		arr[fp++] = elem;
		if (fp >= maxval) {
			maxval += length >> 1;//扩容长度扩一半
			int *tmp = new int[maxval];//创建更大空间的数组
			for (int i = 0; i < length; i++) {
				tmp[i] = arr[i];
			}
			delete[]arr;
			arr = tmp;//将arr指向这个扩容后的空间
		}
	}

public:
	Myarray(){//构造函数1:无参构造
		this->length = 0;
		this->fp = 0;
		arr = new int[maxval];
	}

	Myarray(int len) {//构造函数2:初始化长度，所有元素为0的构造
		this->length = len;
		arr = new int[maxval];
		for (int i = 0; i < length; i++) {
			insert_elem(0);
		}
	}

	Myarray(int len, int elem) {//构造函数3:初始化长度为len和所有元素为elem的构造
		this->length = len;//动态数组长度变为len
		arr = new int[maxval];
		for (int i = 0; i < len; i++) {//将值传入arr
			insert_elem(elem);
		}
	}

	Myarray(int* begin,int* end){//构造函数4:由已知数组初始化的构造
		this->length = end - begin;
		arr = new int[maxval];
		for (int i = 0; i < length; i++) {
			insert_elem(begin[i]);
		}
	}

	Myarray(const Myarray &x) {//自定义拷贝构造：同类型对象初始化的构造
		cout << "拷贝构造" << endl;
		length = x.length;
		maxval = x.maxval;
		arr = new int[x.maxval];
		fp = maxval - 1;
		for (int i = 0; i < x.length; i++) {
			arr[i] = x.arr[i];
		}
	}

	void push_back(int elem) {//从数组尾部插入元素
		length++;
		insert_elem(elem);
	}

	void print(void) {//打印数组
		for (int i = 0; i < length; i++) {
			cout << this->arr[i]<<"\t";
		}
		cout << endl;
	}

	~Myarray() {//析构函数：释放已申请的内存
		if (arr != NULL) {
			cout << "析构" << endl;
			delete[]arr;
			arr = NULL;
		}
	}
};

int main() {
	int ac[] = { 2,1,4,3,5 };
	Myarray arr1(ac, ac + 5);//构造函数4：以数组ac初始化arr1
	arr1.print();

	Myarray arr2(arr1);//拷贝构造：以arr1初始化arr2
	arr2.print();

	Myarray arr3(3, 5);//构造函数3：初始化3个5
	arr3.print();

	Myarray arr4(2);
	arr4.push_back(6);
	arr4.print();
	system("pause");
}

/*
1,如何解决扩容问题?
	使用insert_elem(int elem)函数：
		每插入一个elem，length++，fp++(表示数组末尾元素的下标)
		fp>=maxval时扩容
		maxval扩大原来一半，maxval+=maxval>>1;
		创建更大的空间：int *tmp=new int[maxval];
		释放原来的空间,并更改指针指向:delete []arr; arr=tmp;
2,析构导致促发断点的原因及解决办法?
	当类中有指针且调用拷贝构造时，要在拷贝构造函数中写上空间申请语句（arr = new int[maxval];）
	以保证两个指针指向不同空间,这样，在析构时就不会因为释放野指针而触发断点。
*/

/*要点：
1.动态数组的无效值并不是NALL！
*/