STL源码 vector相关函数

变量

iterator start; 表示目前使用空间的头
iterator finish; 表示目前使用空间的尾
iterator end_of_storage; 表示目前可用空间的尾

函数

函数	功能	实现	返回值
vector()	无参构造	三个变量设置为0	-
vector(size_type n, const T& value)	参数构造	新建一个数组，长度为n，用value填充n个元素	-
-	-	-	-
iterator begin()	返回使用空间的头指针	-	头指针
iterator end()	返回使用空间的尾指针	-	尾指针
size_type size()	返回使用空间的长度	-	size_t类型值
size_type capacity()	返回可用空间的长度	-	size_t类型值
bool empty()	判断数组是否为空	-	返回 true / false
T& front()	返回首元素	-	元素值
T& back()	返回最后一个元素	-	元素值
void push_back(const T&x)	在数组末尾添加一个元素x	-	-
void pop_back()	删除最后一个元素	-	-
void erase(iterator position)	删除位置position的元素	position后面的元素依次向前移动一位	-
void resize(size_type new_size, const T&x)	还不清楚	-	-
void clear()	删除所有元素，释放空间	还不清楚	-

源码

template <class T, class Alloc = alloc>

class vector {
	
public:
	typedef T 			value_type;
	typedef value_type* pointer;
	typedef value_type* iterator;
	typedef value_type& reference;
	typedef size_t		size_type;
	typedef ptrdiff_t 	difference_type;
	
protected:
	typedef simple_alloc<value_type, Alloc> data_allocator;
		
	iterator start;    // 表示目前使用空间的头
	iterator finish;    // 表示目前使用空间的尾
	iterator end_of_storage;    // 表示目前可用空间的尾
	
	void insert_aux(iterator position, const T& x);
	void deallocate() {
		if (start)
		  data_allocator::deallocate(start, end_of_storage - start);
	}
	
	void fill_initialize(size_type n, const T& value) {
		start = allocate_and_fill(n, value);
		finish = start + n;
		end_of_storage = finish;
	}
public:
	// 返回使用空间的头
	iterator begin() { return start; }
	
	// 返回使用空间的尾
	iterator end() { return finish; }
	
	// 返回vector长度
	size_type size() const { return size_type(end() - begin()); }
	 
	// 返回vector占用空间长度 
	size_type capacity() const {
		return size_type(end_of_storage - begin()); 
	}
	
	// 判断数组是否为空 
	bool empty() const { return begin() == end(); } 
	
	// 运算符重载，返回下标为n的元素 
	reference operator[] (size_type n) {
		return *(begin() + n);
	}
	
	vector() : start(0), finish(0), end_of_storage(0) {	}
	vector(size_type n, const T& value) { fill_initialize(n, value); } 
	vector(int n, const T& value)       { fill_initialize(n, value); } 
	vector(long n, const T& value)      { fill_initialize(n, value); } 
	explicit vector(size_type n)        { fill_initialize(n, T());	}
	
	~vector() {
		destory(start, finish);
		deallocate();
	}
	
	reference front() { return *begin(); }  // 第一个元素 
	reference back() {return *(end() - 1); }  // 最后一个元素 
	
	void push_back(const T&x) { // 将元素插入至最尾端 
		if(finish != end_of_storage) {
			construct(finish, x);
			++finish;			
		}
		else {
			insert_aux(end(), x);
		}
	}

	void pop_back() {  // 将最尾端元素取出 
		--finish;
		destory(finish);
	}
	
	void erase(iterator position) { // 消除某位置上的元素 
		if(position + 1 != end()) {
			copy(position + 1, finish, position);  // 后续元素往前移动 
		}
		--finish;
		destory(finish);
		return position;
	} 
	
	void resize(size_type new_size, const T&x) {
		if (new_size < size()) 
			erase(begin() + new_size, end());
		else
		    insert(end(), new_size - size(), x);
		
	} 
	
	void resize( size_type new_size) { resize(new_size, T()); }
	void clear() { erase(begin(), end()); }
protected:
	iterator allocate_and_fill(size_type n, const T& x) {
		iterator result = data_allocator::allocate(n);
		uninitialized_fill_n(result, n, x);
		return result;
	}
	
}; 

需要注意的点

1. 使用空间 与 可用空间（实际空间）
        \;\; start-finish维护的是使用空间，size，即当前数组长度
        \;\; start-end_of_storage是实际空间，capacity
        \;\; vector所采用的数据结构是线性连续空间，其实际空间总是大于等于已使用空间，一旦二者相等，整个vector需要迁移至其他空间。
        \;\; 增加新元素时，如果超过当前容量（capacity），则容量会扩充至两倍（不一定2的幂次），如果仍不足，则继续扩张。需要经历“重新配置，元素移动，释放原空间”等过程。

操作	vector元素	size	capacity
vector(2,9)	9 9	2	2
push_back(1)	9 9 1	3	4
push_back(2)	9 9 1 2	4	4
push_back(3)	9 9 1 2 3	5	8
push_back(4)	9 9 1 2 3 4	6	8
push_back(5)	9 9 1 2 3 4 5	7	8
pop_back()	9 9 1 2 3 4	6	8
pop_back()	9 9 1 2 3	5	8
pop_back()	9 9 1 2	4	8
find and erase 1	9 9 2	3	8
find 2 and insert(p2, 3,7)	9 9 7 7 7 2	6	8
clear()	-	0	8

3. 未完待续…