如何实现一个动态顺序线性表(手动打造vector)

唱跳rap(true)

一、简介
        相信学c++的小伙伴们都知道c++的库里有一个特别好用的动态数组Vector吧，但是各位小伙伴知道怎么实现的么？
        这里我就带大家手动打造一个自己的vector，话不多说，上代码（注释很详细哦）
二、代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. template <typename T>
   
5. class CList {
   
6. public:
   
7.         //初始化线性表，空间大小为10
   
8.         void Init()
   
9.         {
   
10.                 m_nLength = 0;
    
11.                 m_nSize = 10;
    
12.                 m_List = (T*)malloc(m_nSize * sizeof(T));
    
13.         }
    
14.         //在指定位置插入元素
    
15.         bool Insert(unsigned int nIndex, const T& elem)
    
16.         {
    
17.                 //如果插入元素的地址无法访问，则插入失败
    
18.                 if (nIndex<0 || nIndex>m_nLength)
    
19.                         return false;
    
20.                 //判断插入元素后是否需要重新分配内存
    
21.                 if (m_nSize < m_nLength + 1)
    
22.                 {
    
23.                         m_List = (T*)realloc(m_List, m_nSize * sizeof(T) * 2);
    
24.                         if (m_List == NULL)
    
25.                                 return false;
    
26.                         m_nSize *= 2;
    
27.                 }
    
28.                 //进行插入操作
    
29.                 for (int i = m_nLength; i > nIndex; i--)
    
30.                 {
    
31.                         m_List[i] = m_List[i - 1];
    
32.                 }
    
33.                 m_List[nIndex] = elem;
    
34.                 m_nLength++;
    
35.                 return true;
    
36.         }
    
37.         //在指定位置插入n个相同的元素
    
38.         bool Insert(unsigned int nPos, unsigned int nNum, const T& elem)
    
39.         {
    
40.                 //如果插入元素的地址无法访问，则插入失败
    
41.                 if (nPos<0 || nPos>m_nLength)
    
42.                         return false;
    
43.                 //判断插入元素后是否需要重新分配内存
    
44.                 if (m_nSize < m_nLength + nNum)
    
45.                 {
    
46.                         m_List = (T*)realloc(m_List, m_nSize * sizeof(T) * 2);
    
47.                         if (m_List == NULL)
    
48.                                 return false;
    
49.                         m_nSize *= 2;
    
50.                 }
    
51.                 //开始插入元素
    
52.                 //从后往前移位
    
53.                 for (int i = m_nLength + nNum - 1; i >= (nPos + nNum); i--)
    
54.                 {
    
55.                         m_List[i] = m_List[i - nNum];
    
56.                 }
    
57.                 m_nLength += nNum;
    
58.                 //放入元素
    
59.                 while (nNum--)
    
60.                 {
    
61.                         m_List[nPos++] = elem;
    
62.                 }
    
63.                 return true;
    
64.         }
    
65.         //在指定位置删除元素
    
66.         bool Remove(unsigned int nIndex)
    
67.         {
    
68.                 //如果删除元素的地址无法访问，则删除失败
    
69.                 if (nIndex<0 || nIndex>m_nLength)
    
70.                         return false;
    
71.                 //开始删除元素
    
72.                 m_nLength--;
    
73.                 for (int i = nIndex; i < m_nLength; i++)
    
74.                 {
    
75.                         m_List[i] = m_List[i + 1];
    
76.                 }
    
77.                 return true;
    
78.         }
    
79.         //重载下标运算符，使其可以直接修改元素
    
80.         T& operator[](unsigned int nIndex)
    
81.         {
    
82.                 //如果元素的地址无法访问，则输出错误信息
    
83.                 if (nIndex < 0 || nIndex >= m_nLength)
    
84.                         printf("访问越界\n");
    
85.                 return m_List[nIndex];
    
86.         }
    
87.         //查找元素
    
88.         int SearchElem(const T& elem)
    
89.         {
    
90.                 int nIndex = 0;
    
91.                 while (nIndex < m_nLength)
    
92.                 {
    
93.                         if (m_List[nIndex] == elem)
    
94.                                 break;
    
95.                         nIndex++;
    
96.                 }
    
97.                 //没有找到
    
98.                 if (nIndex == m_nLength)
    
99.                         nIndex = -1;
    
100.                 return nIndex;
     
101.         }
     
102.         //返回当前长度
     
103.         int GetLength()
     
104.         {
     
105.                 return m_nLength;
     
106.         }
     
107.         //清空线性表
     
108.         void Clear()
     
109.         {
     
110.                 memset(m_List, 0, m_nSize*(sizeof(T)));
     
111.                 m_nLength = 0;
     
112.         }
     
113.         //线性表元素入栈
     
114.         void push_back(const T& elem)
     
115.         {
     
116.                 //判断插入元素后是否需要重新分配内存
     
117.                 if (m_nSize < m_nLength + 1)
     
118.                 {
     
119.                         m_List = (T*)realloc(m_List, m_nSize * sizeof(T) * 2);
     
120.                         if (m_List == NULL)
     
121.                                 return;
     
122.                         m_nSize *= 2;
     
123.                 }
     
124.                 m_List[m_nLength] = elem;
     
125.                 m_nLength++;
     
126.         }
     
127.         //线性表尾部元素出栈
     
128.         T& pop_back()
     
129.         {
     
130.                 m_nLength--;
     
131.                 return m_List[m_nLength];
     
132.         }
     
133.         //返回某一位置的元素
     
134.         T at(unsigned int nIndex)
     
135.         {
     
136.                 return m_List[nIndex];
     
137.         }
     
138. private:
     
139.         T* m_List;
     
140.         int m_nLength;
     
141.         int m_nSize;
     
142. };
     
143. 
     
144. int main()
     
145. {
     
146.         CList<int> objList;
     
147.         objList.Init();
     
148.         for (int i = 0; i < 10; i++)
     
149.                 objList.push_back(i);
     
150.         for (int i = 0; i < 10; i++)
     
151.                 printf("%3d", objList[i]);
     
152.         printf("\n");
     
153.         objList.Insert(9, 5, 11);
     
154.         for (int i = 0; i < 15; i++)
     
155.                 printf("%3d", objList[i]);
     
156.         printf("\n");
     
157.         while (objList.GetLength() != 0)
     
158.         {
     
159.                 printf("%3d", objList.pop_back());
     
160.         }
     
161.         printf("\n");
     
162.         return 0;
     
163. }

复制代码

三、结束语
        嗯，可能还有一些小bug，但是大致功能实现了，欢迎各位大佬指正
        也希望和各位小伙伴们交流学习，共同进步

唱跳rap(true)

唉，之前的帖子被吃掉了，好难受，这篇是补发的

唱跳rap(true)

顶一顶

Tiramisu

再来个析构函数就完美了