Vector的底层实现，附上可执行代码，欢迎提出优化改进

爱学习520

昨天写到现在，实现Vector的底层实现，代码相对而言比较简单，应该都可以看懂，我把注释写的很清楚，结构也很明确


Vector类的实现：

1. 
   
2. 
   
3. #include<iostream>
   
4. #include<string.h>
   
5. #define  SUCCESS          1      //成功
   
6. #define INDEX_ERROR      -1     // 错误的索引号   
   
7. using namespace std;
   
8. 
   
9. //定义Vector类
   
10. template<class T_ELE>
    
11. class Vector
    
12. {
    
13. private：
    
14.         int InitSize;
    
15.         int Len;
    
16.         int Index;
    
17.         int Increment;
    
18.         T_ELE* pVector;
    
19. private:
    
20.         bool expand()
    
21.         {
    
22.                 int tlen;
    
23.                 T_ELE* pNew;
    
24.                 //计算扩容后的长度
    
25.                 tlen = Len + Increment;
    
26.                 //重新申请适应新的需要的空间大小
    
27.                 pNew = new T_ELE[tlen];
    
28.                 //将原来的空间的数据复制到新申请的空间
    
29.                 memcpy(pNew, pVector, Len * sizeof(T_ELE));
    
30.                 //释放原先的空间
    
31.                 delete[] pVector;
    
32.                 pVector = pNew;
    
33.                 //修改其他对应的值
    
34.                 Len = tlen;
    
35.                 return SUCCESS;
    
36.         }
    
37. 
    
38. public:
    
39.         Vector():InitSize(10),Increment(5)
    
40.         {
    
41.                 //分配空间
    
42.                 pVector = new T_ELE[InitSize];
    
43.                 //初始化申请的空间
    
44.                 memset(pVector, 0, InitSize * sizeof(T_ELE));
    
45.                 //初始化其他变量
    
46.                 Len = InitSize;
    
47.                 Index = 0;
    
48.         }
    
49.         Vector(int size) :Increment(5)
    
50.         {
    
51.                 //分配空间
    
52.                 pVector = new T_ELE[size];
    
53.                 //初始化
    
54.                 memset(pVector, 0, size * sizeof(T_ELE));
    
55.                 //其他变量初始化
    
56.                 Len = size;
    
57.                 Index = 0;
    
58.         }
    
59.         ~Vector()
    
60.         {
    
61.                 //释放申请的堆空间
    
62.                 delete[] pVector;
    
63.                 pVector = nullptr;
    
64.         }
    
65. 
    
66. public:
    
67.         void push_back(T_ELE Element)
    
68.         {
    
69.                 //判断是否需要增容
    
70.                 if (Index >= Len)
    
71.                         expand();
    
72.                 //将新的元素放到最后一个位置
    
73.                 pVector[Index] = Element;
    
74.                 //修改对应的变化值
    
75.                 Index++;
    
76.         }
    
77.        
    
78.         int insert(int index, T_ELE Element)
    
79.         {
    
80.                 //检测插入的区间是否有误
    
81.                 if (index < 1 || index > Index + 1)
    
82.                 {
    
83.                         cout << index<<"不在区域范围，插入错误！" << endl;
    
84.                         return INDEX_ERROR;
    
85.                 }               
    
86.                 //判断是否需要扩容
    
87.                 if (Index >= Len)
    
88.                         expand();
    
89.                 //插入位置的元素和插入元素之后的所有元素后移
    
90.                 memcpy(&pVector[index], &pVector[index - 1], (Index - index+1 ) * sizeof(T_ELE));
    
91.                 pVector[index - 1] = Element;
    
92. 
    
93.                 //对应的其他成员值的变化
    
94.                 Index++;
    
95.                 return 0;
    
96.         }
    
97. 
    
98.         int at(int index)
    
99.         {
    
100.                 //判断索引是否在合理区间
     
101.                 if (index<1 || index>Index)
     
102.                 {
     
103.                         cout<<index << "不在区域内，查找越界" << endl;
     
104.                         return INDEX_ERROR;
     
105.                 }
     
106.                 //返回该索引对应的值
     
107.                 return pVector[index - 1];
     
108.         }
     
109. };

复制代码

测试案例：

1. #include "Vector.cpp"
   
2. 
   
3. //测试函数
   
4. int main()
   
5. {
   
6.         Vector<int> s(5);
   
7.         s.push_back(1);
   
8.         s.push_back(2);
   
9.         s.push_back(3);
   
10.         s.push_back(4);
    
11.         s.push_back(5);
    
12. 
    
13.         //测试增容
    
14.         s.push_back(6);
    
15. 
    
16.         //测试插入的临界错误区域
    
17.         s.insert(0,520);
    
18.         s.insert(8,520);
    
19. 
    
20.         //测试插入的临界正确区域
    
21.         s.insert(1,520);
    
22.         s.insert(3,520);
    
23.         s.insert(7,520);
    
24. 
    
25.         //显示经上述测试后目前Vector里面的元素，以判断是否正确，或者通过调试查看
    
26.         for (int i = 0; i < 9; i++)
    
27.                 cout << s.pVector[i] << endl;
    
28. 
    
29.         //最后测试at函数
    
30.         s.at(0);
    
31.         s.at(4);
    
32.         s.at(9);
    
33.         s.at(10);
    
34.        
    
35.         return 0;
    
36. }
    
37. 
    

复制代码