1
// 1. 无参构造
2
vector<int> v1;
3

4
// 2. 构造并初始化n个val
5
vector<int> v2(10, 5);  // 10个5
6

7
// 3. 拷贝构造
8
vector<int> v3(v2);
9

10
// 4. 使用迭代器构造
11
int arr[] = {1, 2, 3, 4};
12
vector<int> v4(arr, arr + sizeof(arr)/sizeof(arr[0]));
13

14
// 5. C++11列表初始化
15
vector<int> v5 = {1, 2, 3, 4};

1
vector<int> v = {1, 2, 3, 4};
2

3
// 下标访问
4
for(size_t i = 0; i < v.size(); ++i)
5
    cout << v[i] << " ";
6

7
// at()访问（会检查边界）
8
try {
9
    cout << v.at(10);  // 抛出异常
10
} catch(out_of_range& e) {
11
    cout << e.what();
12
}
13

14
// 首尾元素
15
cout << v.front();  // 第一个元素
16
cout << v.back();   // 最后一个元素

1
// 错误示例：删除偶数
2
vector<int> v = {1, 2, 3, 4, 5, 6};
3
auto it = v.begin();
4
while(it != v.end()) {
5
    if(*it % 2 == 0) {
6
        v.erase(it);  // erase后it失效
7
        // ++it;  // 错误：使用失效的迭代器
8
    }
9
    ++it;
10
}
11

12
// 正确写法1：利用erase返回值
13
auto it = v.begin();
14
while(it != v.end()) {
15
    if(*it % 2 == 0) {
16
        it = v.erase(it);  // erase返回下一个有效迭代器
17
    } else {
18
        ++it;
19
    }
20
}
21

22
// 正确写法2：使用算法
23
v.erase(remove_if(v.begin(), v.end(),
24
                  [](int x){return x%2==0;}),
25
        v.end());

1
// 无参构造
2
vector() = default;
3

4
// 拷贝构造（现代写法）
5
vector(const vector<T>& v) {
6
    reserve(v.capacity());
7
    for(auto& e : v) {
8
        push_back(e);
9
    }
10
}
11

12
// 迭代器范围构造
13
template<class InputIterator>
14
vector(InputIterator first, InputIterator last) {
15
    while(first != last) {
16
        push_back(*first);
17
        ++first;
18
    }
19
}
20

21
// 填充构造
22
vector(size_t n, const T& val = T()) {
23
    reserve(n);
24
    for(size_t i = 0; i < n; ++i) {
25
        push_back(val);
26
    }
27
}
28

29
// 赋值运算符（现代写法）
30
vector<T>& operator=(vector<T> v) {
31
    swap(v);
32
    return *this;
33
}

1
size_t size() const { return _finish - _start; }
2
size_t capacity() const { return _end_of_storage - _start; }
3
bool empty() const { return _start == _finish; }
4

5
void reserve(size_t n) {
6
    if(n > capacity()) {
7
        size_t old_size = size();
8
        T* tmp = new T[n];
9

10
        // 深拷贝，不能用memcpy
11
        for(size_t i = 0; i < old_size; ++i) {
12
            tmp[i] = _start[i];  // 调用赋值运算符
13
        }
14

15
        delete[] _start;
16
        _start = tmp;
17
        _finish = _start + old_size;
18
        _end_of_storage = _start + n;
19
    }
20
}
21

22
void resize(size_t n, const T& val = T()) {
23
    if(n < size()) {
24
        _finish = _start + n;
25
    } else {
26
        if(n > capacity()) {
27
            reserve(n);
28
        }
29
        while(_finish != _start + n) {
30
            *_finish = val;
31
            ++_finish;
32
        }
33
    }
34
}

1
void push_back(const T& x) {
2
    if(_finish == _end_of_storage) {
3
        reserve(capacity() == 0 ? 4 : capacity() * 2);
4
    }
5
    *_finish = x;
6
    ++_finish;
7
}
8

9
void pop_back() {
10
    assert(!empty());
11
    --_finish;
12
}
13

14
iterator insert(iterator pos, const T& x) {
15
    assert(pos >= _start && pos <= _finish);
16

17
    // 扩容时记录偏移量，防止迭代器失效
18
    if(_finish == _end_of_storage) {
19
        size_t len = pos - _start;
20
        reserve(capacity() == 0 ? 4 : capacity() * 2);
21
        pos = _start + len;
22
    }
23

24
    // 移动元素
25
    iterator end = _finish - 1;
26
    while(end >= pos) {
27
        *(end + 1) = *end;
28
        --end;
29
    }
30
    *pos = x;
31
    ++_finish;
32
    return pos;
33
}
34

35
iterator erase(iterator pos) {
36
    assert(pos >= _start && pos < _finish);
37
    iterator it = pos + 1;
38
    while(it != _finish) {
39
        *(it - 1) = *it;
40
        ++it;
41
    }
42
    --_finish;
43
    return pos;
44
}