文章目录
一、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;
}
好了,本期内容就到这里了
如果对你有帮助的话,不要忘记点赞加收藏哦!!!