【C++】STL中vector和迭代器的int类型数据的仿写

（一）my_vecrot.h文件

#ifndef  MY_VECTOR_H
#define MY_VECTOR_H
#include <iostream>
using namespace std;

//myvector容器
class myvector
{
    
    
public:
	myvector();

	~myvector();

	void insert(int pos, int value);
	void erase(int pos);
	void resize(int num);

	int& operator[](int idx);
	//迭代器类：可以使用该类的对象，做指针的操作
	class myiterator
	{
    
    
	public:
		myiterator(myvector* pvc, int idx)
			:vc(pvc),
			index(idx)
		{
    
    }
		myiterator operator++(int)
		{
    
    
			myiterator tmp(*this);
			index++;
			return tmp;
		}
		bool operator!=(const myiterator& rhs)
		{
    
    
			return index != rhs.index;
		}
		int& operator*() //迭代器解引用
		{
    
    
			return (*vc)[index];
		}
	private:
		int index;
		myvector* vc;
	};

	myiterator getbegin();
	myiterator getend();
private:

	bool Empty();
	bool Full();
	bool ApplyNewspace();

	int* data_space;	//连续数据空间首地址
	int cur_size;	//当前元素个数
	int capacity;	//容器容量
};


#endif

（二）my_vector.cpp文件

#include "my_vector.h"

//容器实现
myvector::myvector()
{
    
    
	data_space = new int[2];
	cur_size = 0;
	capacity = 2;
}
	
myvector::~myvector()
{
    
    
	delete[] data_space;
	data_space = NULL;
}

void myvector::insert(int pos, int value)
{
    
    
	if (Full() && !ApplyNewspace())
	{
    
    
		throw exception("Applynewspace error");
	}
	for (int i = cur_size; i > pos; i--)
	{
    
    
		data_space[i] = data_space[i - 1];
	}
	data_space[pos] = value;
	cur_size++;
}
void myvector::erase(int pos)
{
    
    
	if (Empty() || pos < 0 || pos > cur_size)
	{
    
    
		throw exception("empty vector or erase pos err");
	}

	for (int i = pos; i < cur_size - 1; i++)
	{
    
    
		data_space[i] = data_space[i + 1];
	}
	cur_size--;
}
/*
resize(int num); 重新改变容器的元素个数，个数变多num>size()，使用默认值0填充新位置;
若变短num<size() ,超出长度的元素被删除，但是容量不会变
*/
void myvector::resize(int num)
{
    
    
	if (num < 0)
	{
    
    
		throw exception("num can not -num");
	}
	if (num > capacity)
	{
    
    
		int* tmp = new int[num];
		memcpy(tmp, data_space, sizeof(int) * capacity);
		memset(tmp + cur_size, 0, sizeof(int) * (num - cur_size));
		delete[] data_space;
		data_space = tmp;
		capacity = num;
	}
	else if (num <= cur_size)
	{
    
    
		cur_size = num;
		memset(data_space + cur_size, 0, sizeof(int) * (capacity - cur_size));
	}
	else
	{
    
    
		memset(data_space + cur_size, 0, sizeof(int) * (capacity - cur_size));
	}

}

bool myvector::Empty()
{
    
    
	return cur_size == 0;
}
bool myvector::Full()
{
    
    
	return cur_size == capacity;
}
//扩容
bool myvector::ApplyNewspace()
{
    
    
	int* newspace = new int[2 * capacity];
	memcpy(newspace, data_space, sizeof(int) * capacity);
	delete[] data_space;
	data_space = newspace;
	capacity *= 2;
	return true;
}
//[]运算符重载
int& myvector::operator[](int idx)
{
    
    
	//抛出异常
	if (idx < 0 || idx > cur_size)
	{
    
    
		throw exception("[idx] out range");
	}
	return data_space[idx];
}

//获取首元素、尾元素下一个地址的迭代器类型
myvector::myiterator myvector::getbegin()
{
    
    
	return myiterator(this, 0);
}
myvector::myiterator myvector::getend()
{
    
    
	return myiterator(this, cur_size);
}

（三）main.cpp文件

#include "my_vector.h"

void Print_vector(myvector& vc)
{
    
    
	myvector::myiterator it = vc.getbegin();
	while (it != vc.getend())
	{
    
    
		cout << *it << " ";
		it++;
	}
	cout << endl;
}

void Test()
{
    
    
	myvector vc;
	for (int i = 0; i < 10; i++)
	{
    
    
		vc.insert(i, i * 10);
	}
	Print_vector(vc);

	//使用erase(int pos)

	vc.erase(3);
	Print_vector(vc);

	vc.resize(15);
	Print_vector(vc);
	
	vc.resize(5);
	Print_vector(vc);
}

int main()
{
    
    
	Test();
}

（四）简单测试结果

（五）主要目的

• 通过简单仿写vector的int类型容器和对应迭代器，加深对迭代器的理解。迭代器是一个对象类型，可以使用该类的一个对象来进行指针操作。
• 精华还是在类的设计中（组合类），以及迭代器和vector两个对象之间的关系

//myvector容器
class myvector
{
public:
	myvector();

	~myvector();

	void insert(int pos, int value);
	void erase(int pos);
	void resize(int num);

	int& operator[](int idx);
	//迭代器类：是一个对象，做指针的操作
	class myiterator
	{
	public:
		myiterator(myvector* pvc, int idx)
			:vc(pvc),
			index(idx)
		{}
		myiterator operator++(int)
		{
			//系统提供浅拷贝
			myiterator tmp(*this); 
			index++;
			return tmp;
		}
		bool operator!=(const myiterator& rhs)
		{
			return index != rhs.index;
		}
		int& operator*() //迭代器解引用
		{
			return (*vc)[index];
		}
	private:
		int index;		//下标寻找位置
		myvector* vc;	
	};

	myiterator getbegin();
	myiterator getend();
private:

	bool Empty();
	bool Full();
	bool ApplyNewspace();

	int* data_space;	//连续数据空间首地址
	int cur_size;	//当前元素个数
	int capacity;	//容器容量
};