c++手写万能动态数组（运用泛型编程，动态内存回收知识）

最近在学习c++面向对象，于是乎做了个实际练习，尝试模拟vector，

（作者还未看vector源码，以后学习了之后应该会进行优化）

大概说一下中间犯的几个错误

1. m_elements一开始定义为 E* 类型 ，这样定义虽然简便，但是在remove操作的时候，将对象赋值为null 并不会把实际占用的内存清理掉，造成内存泄漏，所以使用了E** 类型，便于存储地址进行回收。

2.rangeCheck  ensureCapacity几个函数要设为私有，不能提供给外面，没必要

3. 不能delete 掉一个不是指针的变量 

4.删除也要检查数组越界 

大概敲了一个下午  很有意思~

可能有bug 欢迎纠错

下面放源代码！！  开源精神要有！

欢迎关注 ，后面可能会多实现几种数据结构

#include<iostream>
using namespace std;
#define ELEMENT_NOT_FOUND -1;
//
template<typename E>
class Array
{
private:
	int m_size=0;		// 元素数量
	int m_capacity; // 数组容量
	E** m_elements;	// 指向首地址
	
	void outOfBounds(int index) {
		throw index;
	}
	
	void rangeCheck(int index);	// 检查下标(get,set)
	void rangeCheckForAdd(int index); // 检查下标(add)
	void ensureCapacity(int capacity); // 检查容量及扩容
	
public:
	Array(int capacity = 10);
	~Array();
	int size(); // 元素的数量
	bool isEmpty(); // 是否为空
	int indexOf(E element); // 查看元素的位置
	bool contains(E element); // 是否包含某个元素
	E set(int index, E element); // 设置index位置的元素
	E get(int index); // 返回index位置对应的元素
	void add(int index, E element); // 往index位置添加元素
	void add(E element); // 添加元素到最后面
	E remove(int index); // 删除index位置对应的元素
	void clear(); // 清除所有元素
	
};
template<typename E>
void Array<E>::rangeCheck(int index) {
	if (index < 0 || index >= m_size)
		outOfBounds(index);
}

template<typename E>
void Array<E>::rangeCheckForAdd(int index) {
	if(index < 0 || index > m_size)
		outOfBounds(index);
}

template<typename E>
void Array<E>::ensureCapacity(int capacity) {
	int oldCapacity = m_capacity;
	if (oldCapacity >= capacity) return;
	// 新容量为旧容量的1.5倍
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	E **newElements = new E*[newCapacity];
	
	for (int i = 0; i < m_size; i++) {
		newElements[i] = m_elements[i];
	}
	
	delete[] m_elements; // 释放原空间
	
	m_elements = newElements;
	
	m_capacity = newCapacity;
	
	cout << oldCapacity << "扩容为" << newCapacity << endl;
}


template<typename E>
Array<E>::Array(int capacity) {
	m_capacity = (capacity < 10) ? 10 : capacity;
	m_elements = new E*[m_capacity];
	//m_size=0;
}

template<typename E>
Array<E>::~Array() {
	delete[] m_elements;
}

template<typename E>
int Array<E>::size(){
	return m_size;
}

template<typename T>
bool Array<T>::isEmpty() {
	return m_size == 0;
}

template<typename E>
int Array<E>::indexOf(E element) {
	for (int i = 0; i < m_size; i++) {
		if (*m_elements[i] == element) return i;
	}
	return ELEMENT_NOT_FOUND;
}

template<typename E>
bool Array<E>::contains(E element) {
	return indexOf(element) != ELEMENT_NOT_FOUND;
}

template<typename E>
E Array<E>::set(int index, E element) {
	rangeCheck(index);
	E old = element;
	delete m_elements[index];
	m_elements[index] =new E(element) ;
	return old;
}
template<typename E>
E Array<E>::get(int index) {
	rangeCheck(index);
 
	return *m_elements[index];
}

template<typename E>
void Array<E>::add(int index, E element) {
 
	rangeCheckForAdd(index);
	ensureCapacity(m_size + 1);
	// 0 1 2 3 4 5 
	// 1 2 3 5 6 7
	// index=3, element=4
	
	for (int i = m_size; i > index; i--) {
		m_elements[i] = m_elements[i-1]; //只修改指针 
	}
	
	m_elements[index] = new E(element);//添加对象直接new 
	m_size++;
	 
}

template<typename E>
void Array<E>::add(E element) {
	 
	add(m_size, element);
}

template<typename E>
E Array<E>::remove(int index) {
	rangeCheck(index);
	E old = *m_elements[index];
	// 0 1 2 3 4 5 
	// 1 2 3 5 6 7
	// index=2
	for (int i = index; i < m_size; i++) {
		m_elements[i] = m_elements[i + 1];
	}
	 
	
	delete  m_elements[m_size] ;//手动删除对象
	m_elements[ m_size] = NULL;
	m_size--;
	//m_elements[--m_size] = NULL;
	
	return old;
}

template<typename E>
void Array<E>::clear() {
	// m_elements = nullptr; // 不可行，直接清除了整个指针指向的地址
	for (int i = 0; i < m_size; i++) {
		delete m_elements[i]; 
		m_elements[i]= NULL; 
	//	m_elements[i] = NULL;
		
	}
	m_size = 0;
}

int main() {
	Array<int> array;
 
	for (int i = 0; i < 30; i++) {
		array.add(i);
	}
	
 	cout << "array.set(0, 99): " << array.set(0, 99) << endl;
 	cout << "array.cotains(99): " << array.contains(99) << endl;
 	cout << "array.remove(0): " << array.remove(0) << endl;
 		cout << "array.cotains(99): " << array.contains(99) << endl;
 	cout << "array.isEmpty(): " << array.isEmpty()<< endl;
 	cout << "array.cotains(5): " << array.contains(5) << endl;
 	cout << "size = " << array.size() << endl;
	 array.add(10, 99); 
	cout << "array.add(10, 99), size = " << array.size() << endl;
	//array.clear();
	for (int i = 0; i < array.size() ;  i++) {
		if (i != 0) {
			cout << ", ";
		}
		cout << array.get(i);
	}
}