很楠不爱3

这个屌丝很懒，什么也没留下！

热门标签

【c++】vector的增删查改

作者：很楠不爱3 | 2024-02-17 22:58:33

踩

【c++】vector的增删查改

1.先定义一个类对象vector

为了防止和库里面发生冲突，定义一个命名空间，将类对象放在命名空间里面

#include<iostream>
using namespace std;
namespace zjw {
 class vector {

 public:
 private:


    };
}
1
2
3
4
5
6
7
8
9
10
11

2.定义变量，需要一个迭代器，为了便于修改，变成任意类型的迭代器，我们使用函数模版，三个迭代器变量 _start用于指向顺序表的头，_finish指向顺序表的结尾的下一位，_end_of_storage保存总容量，在初始化列表中先设置为空

#include<iostream>
using namespace std;
namespace zjw {
    template<class T>
 class vector {
 
 public:
     typedef T * iterator;//迭代器类型
     vector()
         :_start(nullptr)
         , _finish(nullptr)
         , _end_of_storage(nullptr)
     {
     }

    private:
         iterator _start;
         iterator _finish;
         iterator _end_of_storage


    };
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.定义函数

1.返回指向顺序表开始的迭代器函数
2.返回指向顺序表结尾的迭代器函数
3.返回容量大小的函数
4.返回顺序表元素多少
5.判断顺序表为空地的函数
5.一个运算符重载的函数（返回给定下标下的值）

#include<iostream>
using namespace std;
namespace zjw {
    template<class T>
 class vector {
 
 public:
     typedef T * iterator;//迭代器类型
     vector()
         :_start(nullptr)
         , _finish(nullptr)
         , _end_of_storage(nullptr)
     {
     }
     iterator begin()//1
     {
         return _start;
     }
     iterator end()//2
     {
         return  _finish;
     }
     size_t capacity()//3
     {
         return _end_of_storage - _start;
     
     }
     size_t size()//4
     {
         return _finish - _start;
     
     
     }
     bool empty()//5
     {
         return _finish == _start;
     
     
     }
     T& operator[](size_t pos)//6
     {
         assert(pos < size());
         return _start[pos];
     
     
     }




    private:
         iterator _start;
         iterator _finish;
         iterator _end_of_storage;


    };
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

4.reserve函数开空间

  void reserve(size_t n)
     {
         if (n > capacity)
         {
             T* tmp = new T[n];
             if (_start)
             {
                 memcpy(tmp, _start, sizeof(T) * size());
                 delete[] _start;
             }
             _start = tmp;
             _finish = _start + size();
             _end_of_storage = _start + n;





         }
     
     
     
     
     
     
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.push_back函数尾插，以及尾删函数

 void push_back(const T& x)
     {
         if (_finish == _end_of_storage)
         {

             reserve(capacity() == 0 ? 4 : capacity() * 2);





         }
         *_finish = x;
         _finish++;
     }
     void pop_back()
     {
     
         assert(!empty());
         --_finish;
     
     
     
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

6.测试尾插，尾删，下标遍历，迭代器遍历，范围for遍历，以及运算符重载返回对应下标的元素

 void test1()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     for (int i = 0; i < v1.size(); i++)
     {
         cout << v1[i] << " ";
     }
     cout << endl;
     v1.pop_back();
     v1.pop_back();
     vector<int>::iterator it = v1.begin();
     while (it != v1.end())
     {
         cout << *it << " ";
         ++it;

     }
     cout << endl;
     v1.pop_back();
     for (auto e : v1)
     {
         cout << e << " ";


     }
     cout << endl;
 
 
 
 
 
 
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

这里开空间的函数会发生问题
在这里插入图片描述

7.修改扩容函数

  void reserve(size_t n)
     {
         if (n > capacity)
         {   int sz=size();
             T* tmp = new T[n];
             if (_start)
             {
                 memcpy(tmp, _start, sizeof(T) * size());
                 delete[] _start;
             }
             _start = tmp;
             _finish = _start + sz;
             _end_of_storage = _start + n;





         }
     
     
     
     
     
     
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在这里插入图片描述

8.resize函数

参数小于容量大小，相当于缩容，参数大于容量大小，相当于扩容，超过_finish的用值初始化
在讲resize之前看看模版会不会给匿名变量初始化，内置类型是否能初始化.

 template <class T>
 void f()
 {
     T x = T();
     cout << x << endl;



 }
 void test3()
 {

     f<int>();
     f<int*>();
     f<double>();




 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这里插入图片描述
发现可以，所以我们在resize里面当n>capacity(),我们可以把顺序表外的用来初始化，自定义类型相当于调用自己的构造函数，内置函数我们在这假装理解为调用自己的构造函数.

  void resize(size_t n, T val = T())
     {
         if (n < size())
         {
             _finish = _start + n;
         }
         else
         {
             if (n > capacity())
                 reserve(n);
             while (_finish != _start + n)
             {
                 *_finish = val;
                 ++_finish;

             }





         }




     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

9.测试resize

 void test2()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     cout << v1.size() << endl;
     cout << v1.capacity() << endl;
     v1.resize(10);
     cout << v1.size() << endl;
     cout << v1.capacity() << endl;
     for (auto e : v1)
     {
         cout << e << " ";


     }
     cout << endl;
     v1.resize(3);
     for (auto e : v1)
     {
         cout << e << " ";


     }

 
 
 
 
 }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在这里插入图片描述

10.封装一个打印函数用于任何vector对象

 void func(const vector<int>& v)
 {
     for (int i = 0; i < v.size(); i++)//下标
     {
         cout << v[i] << " ";



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

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


     }
     cout << endl;







 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

因为打印不同对象的元素，为了区分是有一个this指针的，但是参数是const 无法产生this指针
在这里插入图片描述
解决方法，在这些函数后面加 const ,如果是const对象调用的话，就是权限平移，如果是非const的话，是权限缩小，都可以调用了，如果要限制别人去修改这个*it,我们可以定义一个const的迭代器

void func(const vector<int>& v)
 {
     for (int i = 0; i < v.size(); i++)//下标
     {
         cout << v[i] << " ";



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

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


     }
     cout << endl;







 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

 void test4()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     func(v1);
 
 
 }
1
2
3
4
5
6
7
8
9
10
11
12

11.insert函数实现

   void insert(iterator pos, const T& val)
     {
         assert(pos >= _start);
         assert(pos <= _finish);
         if (_finish == _end_of_storage)
         {
             reserve(capacity() == 0 ? 4 : capacity() * 2);




         }
         iterator end = _finish - 1;
         while (end >= pos)
         {
             *(end + 1) = *end;
             --end;


         }
         *pos = val;
         ++_finish;
     
     
     
     
     
     
     
     
     
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

测试insert

 void test5()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 3);//找到3的位置
     
     if (pos != v1.end())
     {
         v1.insert(pos, 30);//3前插入30



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


     }
     cout << endl;
     (*pos)++;//让3+1

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


     }
     cout << endl;
 
 
 
 
 }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

在这里插入图片描述
pos保存的之前是3的地址，如果在3前插入一个30，pos所指向的位置就变成了30，*pos++,就变成了31；

如果我们不使用push_back（5）的话

 void test5()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     //v1.push_back(5);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 3);//找到3的位置
     
     if (pos != v1.end())
     {
         v1.insert(pos, 30);//3前插入30



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


     }
     cout << endl;
     (*pos)++;//让3+1

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


     }
     cout << endl;
 
 
 
 
 }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

会出现报错，到底是怎么一回事？？
在这里插入图片描述

如何修改？？
我们需要在未扩容前记录好pos距离_start的位置，拷到新空间，他与新_start也保持这个距离，更新pos

   void insert(iterator pos, const T& val)
     {
         assert(pos >= _start);
         assert(pos <= _finish);
         if (_finish == _end_of_storage)
         {
             int len=pos - _start;
             reserve(capacity() == 0 ? 4 : capacity() * 2);
             pos = _start + len;



         }
         iterator end = _finish - 1;
         while (end >= pos)
         {
             *(end + 1) = *end;
             --end;


         }
         *pos = val;
         ++_finish;
     
   
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在这里插入图片描述
这里的*pos里面的数据被清理，如果不清理应该是3++，应该是4，我们可以注释掉reserve中的delete看看

这里的问题被叫做迭代器失效

12.earse函数

 void eraase(iterator pos)
     {
             assert(pos >= _start);
             assert(pos < _finish);
             iterator start = pos + 1;
             while (start != _finish)
             {
                 *(start - 1) = *start;
                 ++start;


             }
             --_finish;
     
     
     
     
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

earse函数测试

void test6()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 2);
     if (pos != v1.end())
     {
         v1.erase(pos);//删除2
     }
     (*pos)++;2位置上的元素++
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }






 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

在这里插入图片描述
这里2删除后2的地址上存的就是3，然后给3++；在std中这个也算迭代器失效，由于这里是自己写的，所以没报错.

 void test6()
 {
     std::vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 2);
     if (pos != v1.end())
     {
         v1.erase(pos);
     }
     (*pos)++;
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }






 }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

上面会调用vector里面的函数
在这里插入图片描述
在不同编译器下有不同的处理情况。在vs中std我们认为迭代器失效，如果删除的是4的话，以我们实现的earse后，–_finish ;4那里的值没有被清理，所以后面的（*pos）++也不会出错，但在vs中我们使用vector里面的实现认为迭代器失效.
我们可以将代码拷过去在linux下试一下g++是怎么回事？？
在这里插入图片描述

在g++中使用库中的vector函数删除数据4没有报错，对于迭代器失效，不同编译器也有不同处理.

13.整体代码

#include<iostream>
#include<assert.h>
#include<vector>
using namespace std;
namespace zjw {
    template<class T>
 class vector {
 
 public:
     typedef T * iterator;//迭代器类型
     typedef T* const_iterator;//迭代器类型
     vector()
         :_start(nullptr)
         , _finish(nullptr)
         , _end_of_storage(nullptr)
     {
     }
     iterator begin()const 
     {
         return _start;
     }
     iterator end()  const
     {
         return  _finish;
     }
     size_t capacity()
     {
         return _end_of_storage - _start;
     
     }
     size_t size()  const
     {
         return _finish - _start;
     
     
     }
     bool empty()
     {
         return _finish == _start;
     
     
     }
      T& operator[](size_t pos)  const
     {
          assert(pos < size());
             return _start[pos];
     
     
     }
     void reserve(size_t n)
     {
        int sz = size();
         if (n > capacity())
         {
             T* tmp = new T[n];
             if (_start)
             {
                 memcpy(tmp, _start, sizeof(T) * size());
                 delete[] _start;
             }
             _start = tmp;
             _finish = _start + sz;
             _end_of_storage = _start + n;





         }
     
     
     
     
     
     
     }
     void push_back(const T& x)
     {
         if (_finish == _end_of_storage)
         {

             reserve(capacity() == 0 ? 4 : capacity() * 2);





         }
         *_finish = x;
         _finish++;
     }
     void pop_back()
     {
     
         assert(!empty());
         --_finish;
     
     
     
     }
     void resize(size_t n, T val = T())
     {
         if (n < size())
         {
             _finish = _start + n;
         }
         else
         {
             if (n > capacity())
                 reserve(n);
             while (_finish != _start + n)
             {
                 *_finish = val;
                 ++_finish;

             }





         }




     }
     void insert(iterator pos, const T& val)
     {
         assert(pos >= _start);
         assert(pos <= _finish);
         if (_finish == _end_of_storage)
         {
             int len=pos - _start;
             reserve(capacity() == 0 ? 4 : capacity() * 2);
             pos = _start + len;



         }
         iterator end = _finish - 1;
         while (end >= pos)
         {
             *(end + 1) = *end;
             --end;


         }
         *pos = val;
         ++_finish;
     
     
     
     
     
     
     
     
     
     }

     void erase(iterator pos)
     {
             assert(pos >= _start);
             assert(pos < _finish);
             iterator start = pos + 1;
             while (start != _finish)
             {
                 *(start - 1) = *start;
                 ++start;


             }
             --_finish;
     
     
     
     
     }











   




    private:
         iterator _start;
         iterator _finish;
         iterator _end_of_storage;


 
};
 void test1()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     for (int i = 0; i < v1.size(); i++)
     {
         cout << v1[i] << " ";
     }
     cout << endl;
     v1.pop_back();
     v1.pop_back();
     vector<int>::const_iterator it = v1.begin();
     while (it != v1.end())
     {
         
         cout << *it << " ";
         
         ++it;

     }
     cout << endl;
     v1.pop_back();
     for (auto e : v1)
     {
         cout << e << " ";


     }
     cout << endl;
 
 
 
 
 
 
 }
 void test2()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     cout << v1.size() << endl;
     cout << v1.capacity() << endl;
     v1.resize(10);
     cout << v1.size() << endl;
     cout << v1.capacity() << endl;
     for (auto e : v1)
     {
         cout << e << " ";


     }
     cout << endl;
     v1.resize(3);
     for (auto e : v1)
     {
         cout << e << " ";


     }

 
 
 
 
 }
 void func(const vector<int>& v)
 {
     for (int i = 0; i < v.size(); i++)//下标
     {
         cout << v[i] << " ";



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

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


     }
     cout << endl;







 }
 void test4()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     v1.push_back(5);
     func(v1);
 
 
 }
 void test5()
 {
     vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
    // v1.push_back(5);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 3);//找到3的位置
     
     if (pos != v1.end())
     {
         v1.insert(pos, 30);//3前插入30



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


     }
     cout << endl;
     (*pos)++;//让3+1
     cout << *pos << endl;

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


     }
     cout << endl;
 
 
 
 
 }
 void test6()
 {
    std:: vector<int>v1;
     v1.push_back(1);
     v1.push_back(2);
     v1.push_back(3);
     v1.push_back(4);
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }
     cout << endl;
     auto pos = find(v1.begin(), v1.end(), 4);
     if (pos != v1.end())
     {
         v1.erase(pos);
     }
     (*pos)++;
     for (auto e : v1)//范围for
     {
         cout << e << " ";


     }






 }


}



int main()
{
   // zjw::test1();
      zjw::test6();
   // zjw::test3();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/102118