vector

构造函数

构造函数列表

构造函数	详细信息
vector	无参构造函数
vector(size_type n,const value_type& val = value_type())	构造大小为 n，值都为 val的vector
vector(const vector& x)	拷贝构造函数
vector(InputIterator first, InputIterator last)	first 和 last都是两个迭代器，构造 last - first个大小的vector

构造函数使用示例

int main() {
	// 无参构造
	vector<int> v1;
	// 构造大小为 10，值都是 10 
	vector<int>v2(10,10);
	// 拷贝 v2 构造 v3
	vector<int>v3(v2);
	// 以 v3 的迭代器构造，值和 v2 v3一致
	vector<int>v4(v3.begin(), v3.end());
	
	// 以下是对四个 vector 的打印
	for (int i = 0; i < v1.size(); ++i) {
		cout << v1[i]<<" ";
	}
	cout << endl;

	for (int i = 0; i < v2.size(); ++i) {
		cout << v2[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v3.size(); ++i) {
		cout << v3[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < v4.size(); ++i) {
		cout << v4[i] << " ";
	}
	cout << endl;
}

结果如下图：

迭代器

迭代器的定义

• begin 返回第一个数据位置的 iterator 或者 const_iterator
• end 返回最后一个数据位置的下一个位置的 iterator 或者 const_iterator
• rbegin 返回最后一个数据位置的 reverse_iterator
• rend 返回第一个数据位置的前一个位置的 reverse_iterator
  

迭代器的使用

int main() {
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	
	// 正向迭代器
	vector<int>::iterator it = v1.begin();
	while (it != v1.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	// 反向迭代器
	vector<int>::reverse_iterator rit = v1.rbegin();
	while (rit != v1.rend()) {
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}

基本功能函数

• resize 修改 vector 的 size
• reserve 修改 vector 的 capcity
• push_back 尾插
• pop_back 尾删
• insert 在任意位置插入
• erase 删除任意位置元素
• swap 交换两个 vector 的元素

vector的遍历

三种方式

1. for循环
2. 迭代器
3. 范围for

int main() {
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

	// for 循环的遍历方式
	for (int i = 0; i < v1.size(); ++i) {
		cout << v1[i] << " ";
	}
	cout << endl;

	// 迭代器遍历
	vector<int>::iterator it = v1.begin();
	while (it != v1.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 范围 for
	for (auto e:v1) {
		cout << e << " ";
	}
	cout << endl;
}

模拟实现

#include<iostream>
#include<assert.h>
using namespace std;

namespace self {

    template<class T>
    class vector {
    public:

        // Vector的迭代器是一个原生指针
        typedef T* iterator;

        typedef const T* const_iterator;

        iterator begin() {
            return _start;
        }

        iterator end() {
            return _finish;
        }

        const_iterator cbegin() {
            return _start;
        }

        const_iterator cend() const {
            return _finish;
        }





        vector() 
            :_start(nullptr)
            ,_finish(nullptr)
            ,_endOfStorage(nullptr){
        }

        vector(int n, const T& value = T()) 
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr) {

            reserve(n);
            while (n--) {
                push_back(value);
            }
        }

        template<class InputIterator>

        vector(InputIterator first, InputIterator last) {
            reserve(first - last);
            while (first != last) {
                push_back(*first);
                ++first;
            }
        }

        vector(const vector<T>& v) 
            :_start(nullptr)
            ,_finish(nullptr)
            ,_endOfStorage(nullptr){

            reserve(v.capacity);
            iterator it = begin();
            const_iterator vit = v.cbegin;
            while (vit != v.cend) {
                *it = *vit;
            }
            _finish = _start + v.size();
            _endOfStorage = _start + v.capacity;
        }

        vector<T>& operator= (vector<T> v) {
            swap(v);
            return *this;
        }

        ~vector() {
            delete[] _start;
            _start = _finish = _endOfStorage = 0;
        }

            // capacity

        size_t size() const {
            return _finish - _start;
        }

        size_t capacity() const {
            return _endOfStorage - _start;
        }

        void reserve(size_t n) {
            if (capacity() < n) {
                size_t OldSize = size();
                T* tmp = new T[n];
                if (_start) {
                    for (size_t i = 0; i < OldSize; ++i) {
                        tmp[i] = _start[i];
                    }

                    _start = tmp;
                    _finish = _start + OldSize;
                    _endOfStorage = _start + n;
                }
            }
        }

        void resize(size_t n, const T& value = T()) {
            // 1. 当前的 size >= n
            if (size() >= n) {
                _finish = _start + n;
                return;
            }

            // 2. 当前的 size < n 空间不够，增容
            if (capacity() < n) {
                reserve(n);
            }

            // 将 size() 扩大到 n
            for (int i = _finish - _start; i < n; ++i) {
                _start[i] = value;
            }
        }




        T& operator[](size_t pos) {
            assert(pos < _finish);
            return _start[pos];
        }   

        const T& operator[](size_t pos)const {
            assert(pos < _finish);
            return _start[pos];
        }




        void push_back(const T& x) {
            insert(end(), x);
        }

        void pop_back() {
            erase(--end());
        }

        void swap(vector<T>& v) {
            ::swap(_start,v._start);
            ::swap(_finish,v._finish);
            ::swap(_endOfStorage,v._endOfStorage);
        }

        iterator insert(iterator pos, const T& x) {
            assert(pos <= _finish);
            // 1. 如果空间不够，先增容
            int n = pos - _start;
            if (_endOfStorage == _finish) {
                int newcapacity = (_endOfStorage == 0) ? 2 : 2 * capacity();
                reserve(newcapacity);

                // 如果增容了，需要重置 pos
                pos = _start + n;
            }
            iterator end = _finish - 1;
            while (end >= pos) {
                (*end + 1) = *end;
                --end;
             }
            *pos = x;
            ++_finish;
            return pos;
        }

        iterator erase(iterator pos) {
            iterator begin = pos + 1;
            while (begin != _finish) {
                (*begin - 1) = *begin;
                ++begin;
            }
            --_finish;
            return pos;
        }

    private:

        iterator _start; // 指向数据块的开始
        iterator _finish; // 指向有效数据的尾
        iterator _endOfStorage; // 指向存储容量的尾

    };

}