文章目录
一、vector的源码分析
这里我们只是简单的去了解一下原码即可，后序将会出一个专题着重剖析stl源码
1.分析思路
vector的原码有很多版本，我们采用与侯捷老师的《STL原码剖析》这本书同一个版本的原码
对于我们所看的vector原码，我们首先要关注的是成员变量。这个是最核心的部分。
如下所示，这三个就是我们的成员变量
可以注意到，vector原码采用的是三个迭代器作为成员变量，这与我们之前的string是有所差异的。既然是迭代器，那么我们就在来找找迭代器真正的类型是什么？
如下图所示
我们可以注意到在源码中，迭代器实际上就是我们的模板参数T，T就是我们vector里面每个数据的类型，这些迭代器本质就是T的指针。因为对于vector就是一个顺序表，所以它完全可以用原生的指针作为迭代器
现在我们已经知道了成员变量及其类型，可以看到是与我们原来所想的有所差异，那么我们就要进行对比，与正常的顺序表它这些成员变量究竟是什么意思？为了得知这些成员变量是什么意思，我们需要做的就是看构造函数和插入接口
2.构造函数和插入接口
如下所示，是我们找到的构造函数
对于第一个无参的构造，它的作用是将三个指针全部置空。这里我们似乎也看不出什么来
既然如此，那么我们再来关注一下这个尾插函数
既然关注到了尾插，那么肯定涉及到扩容
接下来我们就可以根据这两个函数进行猜测成员变量都是啥意思。事实上根据单词的意思，我们已经可以猜测的七七八八了，这两个函数起到的作用就是可以进行验证我们猜测的是否正确
有了上面的猜测，尾插函数其实我们大概也就能够读懂。至于reserve函数，我们也可以看出来它显示开好空间，然后释放掉原来的空间，在最后的三行中，再次验证了我们的猜测
二、手把手教你写一个简单的vector
1.基本结构
我们的基本结构如下所示
2.迭代器与私有成员变量的定义
根据前面的分析，我们很容易写出成员变量和迭代器的定义
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};
3.构造函数
如下所示，是最基本的无参的构造函数，我们只需要将全部的置空即可
vector()
:_start(nullptr)
,_finish(nullptr)
,_end_of_storage(nullptr)
{}
4.size和capacity
这个两个也是很重要的接口，后序的很多测试都是需要依靠他的
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
5.迭代器函数接口
迭代器接口也是比较容易写出来的。和string是类似的，这里不再赘述
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
6.析构函数
析构函数也是最基本必须要完成的默认成员函数之一，我们当_start不为空的时候，直接释放掉内存即可
~vector()
{
if (_start)
{
delete[] _start;
_start = nullptr;
_finish = nullptr;
_end_of_storage = nullptr;
}
}
7.reserve接口
这个接口起着扩容的重大作用，当我们增加数据的时候，必须要先判断是否需要进行扩容。当我们要求的容量大于我们实际的容量时候，我们就开辟一块新的空间，然后拷贝数据，最后释放掉原来的数据。最后改变指针的指向，需要注意的是，我们最好提前算好原来的size，以便后来_finish指针的计算。
void reserve(size_t n)
{
if (n > capacity())
{
iterator tmp = new T[n];
int sz = size();
if (_start)
{
memcpy(tmp, _start, sizeof(T) * sz);
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}
8.尾插
有了前面的接口，我们现在可以去实现一下尾插的接口，这个逻辑也是很简单的，当finish和end_of_storage相等的时候，就是需要扩容了，然后我们直接插入数据即可
void push_back(const T& val)
{
if (_finish == _end_of_storage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = val;
_finish++;
}
9.operator[]运算符重载
对于这个接口，它和string的基本实现也是类似的，需要注意要写两个函数重载，这是为了保证const对象只读和普通对象读写的特性
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
10.简单的测试前面的接口
我们使用如下代码对前面接口进行测试。
void Print(const Sim::vector<int>& v)
{
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void testvector2()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(4);
for (size_t i = 0; i < v.size(); i++)
{
v[i]++;
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
Print(v);
cout << endl;
}
经过测试后，符合我们的预期
11.insert以及迭代器失效问题
对于这个接口，我们的思路是这样的，首先我们先断言，pos在合理的范围之内，然后当容量满了以后，我们进行扩容，注意在这里扩容时候要小心，这里当我们扩容以后，pos会失效的，因为pos还是指向原来的空间，我们扩容完以后已经将原来的空间给释放了，所以pos会失效。这就是迭代器失效问题，为了防止pos失效，我们需要先记录pos的相对位置，然后当扩容以后重新加上去就可以计算出新的pos位置了。
void insert(iterator pos, const T& val)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _end_of_storage)
{
int sz = pos - _start;
int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + sz;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *(end);
end--;
}
*pos = val;
_finish++;
}
最后我们就可以正常的按照我们逻辑进行挪动数据和插入数据了。
下面是我们的测试代码
void testvector3()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
其实上面的仅仅只是内部的迭代器失效问题，这个问题我们已经得到了解决，还有一类迭代器失效是外部的迭代器失效问题，如下所示的测试代码，当我们想要在某处插入多次数据的时候，可能会引发pos失效的问题，这是因为，在内部插入数据需要扩容的时候已经修改了pos的值，pos的位置已经被改变了。而在外部还在使用原来的pos自然是不行的
可见，我们的程序引发了断言错误，正是由于pos已被内部所改变了。故同一个pos不可以连续使用
那么在这里，我们可能会想，能否在传参的时候对pos使用传引用呢。其实这样也是错的，这是因为如果传引用的话，会涉及到权限放大的问题。由于pos里面的数据肯定是要被修改的，所以pos肯定不可以使用const迭代器。故参数必须使用普通的迭代器。而如果我们在传参的时候，我们实参写了一个运算表达式。运算表达式返回一个结果的时候会产生一个临时变量，临时变量具有常性。由此权限放大了。故不可以使用传引用。或者当我们直接使用迭代器begin函数作为实参的话，由于这个迭代器是传值返回，也是会产生临时变量，故仍然会权限放大。再次说明了不可以传引用。
所以insert以后迭代器可能失效
insert以后就不要使用这个形参迭代器了，因为他可能已经失效了
继续使用它就是一个高危行为
在库里面它的解决方案就是带一个返回值
库里面这个返回值返回的是新插入元素的位置
这样一来我们就可以从外部规避这个迭代器失效问题了
所以真正的代码应该是这样的：
iterator insert(iterator pos, const T& val)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _end_of_storage)
{
int sz = pos - _start;
int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + sz;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *(end);
end--;
}
*pos = val;
_finish++;
return pos;
}
12.erase以及迭代器失效
对于erase，我们可以很容易的写出如下代码，即依次往前挪动。这个思路看上去确实没什么毛病
void erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
if (_start)
{
iterator end = pos + 1;
while (end != _finish)
{
*(end - 1) = *end;
end++;
}
_finish--;
}
}
但是当我做出如下操作的时候，发生了断言错误
其实仔细一想也确实是这样的，因为我们删除了倒数第二个值以后， 原来的pos还是指向那个位置，这里的pos已经是最后一个位置了。当再次删除的时候，必然产生pos断言错误。这就意味着pos已经不是指向原来的值了，已经失效了。继续使用pos有可能会越界或者跳过了某些数据。
如果是vs的std库里面的话，直接程序报错
下图的其实不算足够严谨，因为我们已经改变了pos，相当于我们没有连续使用同一个迭代器，vs不会直接暴力报错。这里崩溃原因其实还是因为越界了。
如下图所示，还算比较严谨，因为我们连续使用同一个pos，vs直接暴力检查，直接报错。但是在linux下，并没有如此暴力的检查。但是我们还是不能这样写，因为我们不可以让一个代码可以在linux下可以跑，但是vs下不能跑，这样代码移植性太差了。
也就是说
erase以后，迭代器失效了，vs进行了强制检查，直接报错，必须要重新给pos赋值，才可以不报错
而在linux下的g++编译器，并没有做直接报错的处理，但是结果很可能不符合我们的预期，有可能会产生非常危险的现象
标准为了避免迭代器失效，所以就要给pos重新赋值，那么我们只能给函数添加返回值了
如上可知，它这个返回的是刚刚被删除的那个元素的下一个位置。
所以最终代码是这样的
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
if (_start)
{
iterator end = pos + 1;
while (end != _finish)
{
*(end - 1) = *end;
end++;
}
_finish--;
}
return pos;
}
总结：vector在使用完erase和insert迭代器对象以后，不能在使用这个迭代器了，我们认为迭代器失效了，因为结果是未定义的
13.尾删
如下所示，我们既可以直接调用erase复用，也可以自己直接写一个都是可以的。
void pop_back()
{
if (_start)
{
_finish--;
}
//erase(_finish-1);
}
14.resize
resize的基本逻辑我们都明白，但是有一点需要注意的是，如果处理第二个缺省参数，对于内置类型我们直接给0当然是可以的，但是倘若是构造类型的话，显然是不可以的。我们这里的策略是给一个匿名对象，这个匿名对象就是默认构造出来的，这就意味着我们每一个对象最好都写上默认构造函数，否则迟早会出问题的。但是内置类型严格来说是没有默认构造函数这一说法的。但是C++中对内置类型做了升级。让内置类型也类似于有了默认构造。
如下代码所示。
最终我们代码如下所示
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
_finish++;
}
}
}
如下是测试结果
15.拷贝构造
如下代码所示，这是一个典型的深拷贝问题。
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
_start = new T[v.capacity()];
memcpy(_start, v._start, sizeof(T) * v.size());
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
运行结果如下所示
当然拷贝构造不仅仅这一种写法，还有很多种写法。如下所示
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
16.赋值运算符重载
这里我们可以直接使用现代写法，比较容易简洁
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish,v._finish);
std::swap(_end_of_storage,v._end_of_storage);
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
测试结果如下所示：
17.再谈reserve
当我们写出这样的代码的时候，我们惊讶的发现，居然报错了
void testvector6()
{
Sim::vector<string> v;
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
v.push_back("4444");
v.push_back("5555");
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
这个代码咋一看好像没什么大问题，而且在我们使用内置类型的连续尾插时候也没有出现问题，那么这里为什么会出现问题呢？
我们可以将内存图给画出来
如下图所示，这是我们一开始的情形
当我们再次插入数据的时候，我们发现需要进行扩容了，于是在我们扩容的时候，我们使用reserve函数，它里面有个部分是memcpy
注意，这里的memcpy就是原罪。因为我们这里对于vector来说，确实是一个深拷贝，但是对于string而言，它里面的数据是一个浅拷贝。
当我们程序结束需要delete的时候，就会出事了，程序第二次析构。
所以这里的问题就是：vector是深拷贝，但是vector空间上存的对象是string数组，使用memcpy会导致string对象的浅拷贝
解决方案也很简单，把这行代码给替换一下，下面我们所使用的看似简单，实则内藏玄机，注意看，我们看似使用了一个简单的变量，在这个遍历中，我们将原来的每一个_start所指向的数组依次使用赋值运算符重载交给新的数组中，这样一来深拷贝的问题就交给了赋值运算符重载。从而成功的规避了这个问题
void reserve(size_t n)
{
if (n > capacity())
{
iterator tmp = new T[n];
int sz = size();
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * sz);
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}
现在我们的代码就可以正常运行了
18.再谈拷贝构造
reserve存在浅拷贝的问题，那么拷贝构造是否也存在呢？因为我们的拷贝构造也是使用了memcpy，我们可以验证一下。结果发现确实也存在问题
既然如此，那么我们也进行一次修正，去处理掉这个问题
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T) * v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
这里笔者在给一段测试代码，这段代码的拷贝构造部分的分析极其复杂，有兴趣的可以去研究一下。
void testvector7()
{
Sim::vector<Sim::vector<int>> v;
Sim::vector<int> vv;
vv.push_back(1);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
Sim::vector<Sim::vector<int>> v1(v);
for (Sim::vector<int> e : v)
{
for (int c : e)
{
cout << c << " ";
}
cout << endl;
}
}
19.用n个val去构造
这个代码我们可以直接复用前面的resize
需要注意的是，这个初始化列表一定要写，或者给成员变量写缺省参数都是可以的。如果不写的话，那么会出现很多问题的。
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
resize(n, val);
}
如下是一个简单的测试代码
void testvector8()
{
Sim::vector<int> v(10, 1);
for (int e : v)
{
cout << e << " ";
}
cout << endl;
}
20.用迭代器区间构造函数
我们可以很容易的写出以下代码
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
while (first != last)
{
push_back(*first);
first++;
}
}
但是当我们运行的时候，发现了一个很奇怪的错误
为什么说奇怪呢？首先是我们测试用例并没有做出任何改变，我们仅仅只是加了一个迭代器区间构造函数，而且报的错误是非法的间接寻址。
事实上这是编译器的选择函数的问题
是由于以下两个函数产生冲突了
我们写的参数是10和1，编译器会认为是int类型的，但是第一个函数的第一个参数是无符号的整型，第二个的参数是可变的，理论上来说第二个是更匹配的。故编译器选择了第二个函数使用。而迭代器本应类似一个指针，这里却是一个普通的变量，当然会发生问题了。这个问题正好就是非法的间接寻址。
如果我们将代码写成10u的话，也就意味着第一个参数变为了无符号的整型。第二个参数是int是满足第一个函数的形式的，且不可能满足第二个函数的参数，因为第二个的两个参数必须是一致的，故这样下，编译器才会正确的选择函数
或者说，当我们的第二个参数确定好了，不可能与第一个是一样的，那这样编译器也不会错误的识别函数。比如说字符串类型等等
这样一来我们现在测试一下我们的迭代器区间初始化，可见符合我们的预期
这样还是不符合我们本应该的想法的，我们不可能每次都记得要多写一个u，在编译器中解决的方案就是多写了几个函数重载，改变了第一个参数的类型。这样的话编译器发现有一个是编译失败的，那么自然就会选择可以编译正确的函数。
三、vector完整代码
vector完整代码
#pragma once
#include<iostream>
#include<string.h>
#include<assert.h>
#include<algorithm>
using namespace std;
namespace Sim
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{}
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T) * v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v[i];
}
_finish = _start + v.size();
_end_of_storage = _start + v.capacity();
}
//vector(const vector<T>& v)
// :_start(nullptr)
// , _finish(nullptr)
// , _end_of_storage(nullptr)
//{
// reserve(v.capacity());
// for (auto e : v)
// {
// push_back(e);
// }
//}
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
resize(n, val);
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
resize(n, val);
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
while (first != last)
{
push_back(*first);
first++;
}
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish,v._finish);
std::swap(_end_of_storage,v._end_of_storage);
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = nullptr;
_finish = nullptr;
_end_of_storage = nullptr;
}
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_storage - _start;
}
void reserve(size_t n)
{
if (n > capacity())
{
iterator tmp = new T[n];
int sz = size();
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * sz);
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
_finish++;
}
}
}
void push_back(const T& val)
{
if (_finish == _end_of_storage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = val;
_finish++;
}
void pop_back()
{
if (_start)
{
_finish--;
}
//erase(_finish-1);
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
iterator insert(iterator pos, const T& val)
{
assert(pos >= _start && pos <= _finish);
if (_finish == _end_of_storage)
{
int sz = pos - _start;
int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
pos = _start + sz;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *(end);
end--;
}
*pos = val;
_finish++;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
if (_start)
{
iterator end = pos + 1;
while (end != _finish)
{
*(end - 1) = *end;
end++;
}
_finish--;
}
return pos;
}
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};
}
测试代码
#define _CRT_SECURE_NO_WARNINGS 1
#include<string.h>
#include<string>
#include<vector>
#include"vector.h"
void Print(const Sim::vector<int>& v)
{
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void testvector1()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(4);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void testvector2()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(4);
for (size_t i = 0; i < v.size(); i++)
{
v[i]++;
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
Print(v);
cout << endl;
}
void testvector3()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
v.insert(v.begin(), 10);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
//在第三个数据位置处进行插入多次数据
Sim::vector<int>::iterator pos = v.begin() + 2;
pos = v.insert(pos, 222);
pos = v.insert(pos, 333);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void testvector4()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.insert(v.begin(), 10);
v.insert(v.begin(), 20);
v.insert(v.begin(), 30);
v.insert(v.begin(), 40);
v.insert(v.begin(), 50);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
Sim::vector<int>::iterator pos = v.begin()+6;
pos = v.erase(pos);
pos = v.erase(pos);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.pop_back();
v.pop_back();
v.pop_back();
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void test()
{
int i = 0;
int j = int();
int k = int(1);
cout << "i=" << i << endl;
cout << "j=" << j << endl;
cout << "k=" << k << endl;
}
void testvector5()
{
Sim::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.insert(v.begin(), 10);
v.insert(v.begin(), 20);
v.insert(v.begin(), 30);
v.insert(v.begin(), 40);
v.insert(v.begin(), 50);
v.resize(10, 100);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
v.resize(5, 10);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
Sim::vector<int> v1(v);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
auto v2 = v;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void testvector6()
{
Sim::vector<string> v;
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
v.push_back("4444");
v.push_back("5555");
Sim::vector<string> v1(v);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
void testvector7()
{
Sim::vector<Sim::vector<int>> v;
Sim::vector<int> vv;
vv.push_back(1);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
v.push_back(vv);
Sim::vector<Sim::vector<int>> v1(v);
for (Sim::vector<int> e : v)
{
for (int c : e)
{
cout << c << " ";
}
cout << endl;
}
}
void testvector8()
{
Sim::vector<int> v(10, 1);
for (int e : v)
{
cout << e << " ";
}
cout << endl;
Sim::vector<int> v1(v.begin(), v.end());
for (int e : v1)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
testvector8();
return 0;
}
好了，本期内容就到这里了
如果对你有帮助的话，不要忘记点赞加收藏哦！！！
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
