1 #include <iostream>
2 
3 int main() {
4     int len;
5     std::cin >> len;
6     int arr[len];
7     return 0;
8 }

std::vector<int> vec0;
std::vector<int> vec1(10);
std::vector<int> vec2(10, 0);

 1 template <class T, class Alloc = alloc>
 2 class vector {
 3 
 4 ...
 5 
 6 protected:
 7   typedef simple_alloc<value_type, Alloc> data_allocator;  
 8   iterator start;                                    　//表示目前使用空间的头
 9   iterator finish;                                  　//表示目前使用空间的尾
10   iterator end_of_storage;                  　　　　　　//表示目前可用空间的尾
11 
12   void fill_initialize(size_type n, const T& value) {
13         start = allocate_and_fill(n, value);
14         finish = start + n;
15         end_of_storage = finish;
16   }
17 
18    // 分配空间并填满内容
19    iterator allocate_and_fill(size_type n, const T& x) {
20         iterator result = data_allocator::allocate(n);
21         uninitialized_fill_n(result, n, x);
22         return result;
23     }
24 
25 ...
26 
27 public:
28     vector() : start(0), finish(0), end_of_storage(0) {}
29     vector(size_type n, const T& value) {fill_initialize(n, value);}
30     vector(int n, const T& value) {fill_initialize(n, value);}
31     vector(long n, const T& value) {fill_initialize(n, value);}
32     explicit vector(size_type n) {fill_initialize(n, T());}
33 ...
34 }

void fill_initialize(size_type n, const T& value) {
        start = allocate_and_fill(n, value);
        finish = start + n;
        end_of_storage = finish;
}

  // 分配空间并填满内容
iterator allocate_and_fill(size_type n, const T& x) {
         iterator result = data_allocator::allocate(n);
         uninitialized_fill_n(result, n, x);
         return result;
 }

template<class ForwardIterator, class SIze, class T>
ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T& x);

... ...

~vector() {
    destroy(start, finish);
    dellocate();
}

... ...

class Foo {..};
Foo* pf = new Foo;             // 分配内存，然后构造对象
delete pf;                     // 将对象析构，然后释放内存

// 这是construct()函数
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
    new (P) T1(value);　　// placement new;调用T1::T1(value)
}

// 第一个版本
template <class T>
inline void destroy(T* pointer) {
    pointer->~T();
}

// 第二个版本
template<class ForwardIterator, class T>
inline void destroy(ForwardIterator first, ForwardIterator last, T*) {
    __destroy(first, last, value_type(first));
}

1 void push_back(const T& x) {
2     if (finish != end_of_storage) {
3         construct(finish, x);
4         ++finish;
5     } else {
6         insert_aux(end(), x);
7      }
8 }    

 1 template <class T, class Alloc>  
 2     void insert_aux(iterator position, const T& x)  
 3     {  
 4         if (finish != end_of_storage)    // 还有备用空间  
 5         {  
 6             // 在备用空间起始处构造一个元素，并以vector最后一个元素值为其初值  
 7             construct(finish, *(finish - 1));  
 8             ++finish;  
 9             T x_copy = x;  
10             copy_backward(position, finish - 2, finish - 1);  
11             *position = x_copy;  
12         }  
13         else   // 已无备用空间  
14         {  
15             const size_type old_size = size();  
16             const size_type len = old_size != 0 ? 2 * old_size : 1;  
17             // 以上配置元素：如果大小为0，则配置1（个元素大小）  
18             // 如果大小不为0，则配置原来大小的两倍  
19             // 前半段用来放置原数据，后半段准备用来放置新数据  
20   
21             iterator new_start = data_allocator::allocate(len);  // 实际配置  
22             iterator new_finish = new_start;  
23             // 将内存重新配置  
24             try  
25             {  
26                 // uninitialized_copy()的第一个参数指向输入端的起始位置
27                 // 第二个参数指向输入端的结束位置（前闭后开的区间)
28                 // 第三个参数指向输出端(欲初始化空间)的起始处
29 
30                 // 将原vector的安插点以前的内容拷贝到新vector
31                 new_finish = uninitialized_copy(start, position, new_start);  
32                 // 为新元素设定初值 x  
33                 construct(new_finish, x);  
34                 // 调整已使用迭代器的位置  
35                 ++new_finish;  
36                 // 将安插点以后的原内容也拷贝过来  
37                 new_finish = uninitialized_copy(position, finish, new_finish);  
38             }  
39             catch(...)  
40             {  
41                 // 回滚操作  
42                 destroy(new_start, new_finish);  
43                 data_allocator::deallocate(new_start, len);  
44                 throw;  
45             }  
46             // 析构并释放原vector  
47             destroy(begin(), end());  
48             deallocate();  
49   
50             // 调整迭代器，指向新vector  
51             start = new_start;  
52             finish = new_finish;  
53             end_of_storage = new_start + len;  
54         }  
55     }            

void pop_back() {
    --finish();                // 将尾端迭代器往前移一格,表示将放弃尾端元素
    destroy(finish);        　　// 析构对象
}