int main() {
int a[5] = {1, 2, 3, 4, 5};
int b[2] = {1, 2};
vector<int> v1(a, a + 5), v2(b, b + 2), v3;
vector<int>::iterator iter;
cout<<"v1 = ";
for(iter = v1.begin(); iter != v1.end(); iter ++)
cout<<*iter<<" ";
cout<<endl;
cout<<"v2 = ";
for(iter = v2.begin(); iter != v2.end(); iter ++)
cout<<*iter<<" ";
cout<<endl;
v2 = v1;
cout<<"v2 = ";
for(iter = v2.begin(); iter != v2.end(); iter ++)
cout<<*iter<<" ";
cout<<endl;
v2.assign(v1.begin(), v1.end());
cout<<"v2 = ";
for(iter = v2.begin(); iter != v2.end(); iter ++)
cout<<*iter<<" ";
cout<<endl;
v3.assign(7, 3);
cout<<"v3 = ";
for(iter = v3.begin(); iter != v3.end(); iter ++)
cout<<*iter<<" ";
cout<<endl;
return 0;
}
```
v1 = 1 2 3 4 5
v2 = 1 2
v2 = 1 2 3 4 5
v2 = 1 2 3 4 5
v3 = 3 3 3 3 3 3 3
int main() {
vector<int> v;
v.assign(6, 6);
for(int i = 0; i < 10; i ++)
cout<<v[i]<<" ";
cout<<endl;
return 0;
}
```
6 6 6 6 6 6 135137 0 0 0
- 案例2
```c
// 改良后的代码使用at(), 在越界的时候抛出异常out_of_range
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v;
v.assign(6, 6);
for(int i = 0; i < 10; i ++)
cout<<v.at(i)<<" ";
cout<<endl;
return 0;
}
```
6 6 6 6 6 6
terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check
/usercode/script.sh: line 62: 13 Aborted $output - < "/usercode/inputFile"
int main() {
vector<char> v;
for(int i = 0; i < 10; ++ i)
v.push_back(i + 65);
int size = v.size();
vector<char>::iterator startIterator;
vector<char>::iterator tempIterator;
for(int i = 0; i < size; i ++)
{
startIterator = v.begin();
v.erase(startIterator);
for(tempIterator = v.begin(); tempIterator != v.end(); tempIterator ++)
cout<<*tempIterator;
cout<<endl;
}
return 0;
}
```
BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
EFGHIJ
FGHIJ
GHIJ
HIJ
IJ
J
```c
vector3(3, 1, v2.get_allocator()); // 把v2的内存分配器作为一个参数参与构造v3. 这样,他们两个用一个内存分配器.
```
### c++中的allocator类
#### 概述
- 它用于将内存的分配和对象的构造分离开来. 它分配的内存是原始的、未构造的.
```c
allocator<string> alloc; // 定义了一个可以分配string的allocator对象
auto const p = alloc.allocate(n); // 分配n个未初始化的string内存,即为n个空string分配了内存,分配的内存是原始的、未构造的
```
#### allocator用法
- allocator<T> a // 定义了一个名为a的allocator对象,它可以为类型T的对象分配内存
- a.allocate(n) // 分配能保存n个类型为T的对象的内存
- a.deallocate(p, n) // 释放T*指针p地址开始的内存,这块内存保存了n个类型为T的对象,p必须是一个先前由allocate返回的指针,且n必须是p创建时所要求的大小,且在调用该函数之前必须销毁在这片内存上创建的对象,这是因为在创建的过程中我们分配的是最原始的内存,所以在释放内存的时候也只能严格释放这片最原始的内存
- a.construct(p, args) // p必须是一个类型为T*的指针,指向一片原始内存,arg将被传递给类型为T的构造函数,用来在p指向的原始内存上构建对象
- a.destory(p) // p为T*类型的指针,用于对p指向的对象执行析构函数
#### 详解
- allocate用于分配原始内存
- 正如前面说到,allocate出来的内存是最原始的,未构造的内存. 它的construct成员函数接受一个指针和零个或多个额外的参数,在给定位置构造对象, 额外的参数是用于初始化构造对象的
```c
auto q = p; // q指向最后构造的元素之后的位置
alloc.construct(q++); // *q为空字符串
alloc.construct(q++, 10, 'c'); // *q为cccccccccc
alloc.construct(q++, "hi"); // *q为hi
```
- 用完对象后,必须对这种构造的对象调用destory销毁,它接受一个指针,对指向的对象执行析构函数
```c
while(q != p)
alloc.destory(--q);
```
循环开始处,q是指向最后构造的元素之后的一个位置,调用destory之前我们先对q进行递减操作,所以第一次调用destory销毁的是最后一个元素,依次执行销毁操作直到q和p相等. 我们只能对真正构造了的元素进行destory操作,一旦元素被销毁,就可以重新使用这部分内存来保存其他string或归还给系统,释放内存通过调用deallocate完成
```c
alloc.deallocate(p, n)
```
其中p不能为空,必须指向allocate分配的内存,而且大小参数n也必须与调用allocate分配内存时提供的大小参数相等insert 函数
- 语法:
- iterator insert(iterator loc, const TYPE & val); // 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器
- void insert(iterator loc, size_type num, const TYPE & val); // 在指定位置loc前插入num个数值为val的元素
- void insert(iterator loc, input_iterator first, input_iterator last); // 在指定位置loc前插入区间[first, last)的所有元素
- 案例 ```c
// 创建一个vec,置入字母表的前十个字符
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<char> v;
for(int i = 0; i < 10; ++ i)
v.push_back(i + 65);
// 插入4个C到vector中
vector<char>::iterator theIterator = v.begin();
v.insert(theIterator, 4, 'C');
// 显示vector中的内容
for(theIterator = v.begin(); theIterator != v.end(); theIterator ++)
cout<<*theIterator;
cout<<endl;
return 0;
}
```
CCCCABCDEFGHIJ
int main() {
vector<char> v;
for(int i = 0; i < 10; ++ i)
v.push_back(i + 65);
int size = v.size();
vector<char>::iterator theIterator;
for(int i = 0; i < size; i ++){
v.pop_back();
for(theIterator = v.begin(); theIterator != v.end(); theIterator ++)
cout<<*theIterator;
cout<<endl;
}
return 0;
}
```
ABCDEFGHI
ABCDEFGH
ABCDEFG
ABCDEF
ABCDE
ABCD
ABC
AB
A
int main() {
vector<int> v;
for(int i = 0; i <= 5; i ++)
v.push_back(i);
vector<int>::reverse_iterator pos;
pos = v.rbegin();
for(int i = 0; i <= 5; i ++)
{
cout<<*pos<<" ";
pos++;
}
return 0;
}
```
5 4 3 2 1 0
int main() {
vector<int> v;
for(int i = 0; i <= 5; i ++)
v.push_back(i);
vector<int>::reverse_iterator pos;
pos = v.rend();
for(int i = 0; i <= 5; i ++)
{
pos--;
cout<<*pos<<" ";
}
return 0;
}
```
0 1 2 3 4 5
int main() {
vector<int> v;
for(int i = 1; i <= 3; i ++)
v.push_back(i);
v.resize(5, 8); //多出的两个空间都初始化为8
for(int i = 0; i < v.size(); i ++) // resize 与 reverse并不会删除原先的元素以释放空间
cout<<v[i];
cout<<endl;
v.reserve(7); // 新元素还没有构造
for(int i = 0; i < 7; i ++)
cout<<v[i]<<" "; // 当i > 4。此时不能用[]访问元素
cout<<endl;
cout<<v.size()<<endl;
cout<<v.capacity()<<endl;
return 0;
}
```
12388
1 2 3 8 8 0 0
5
7
int main() {
vector<int> v1, v2;
for(int i = 1; i <= 3; i ++){
v1.push_back(i);
v2.push_back(i);
}
v2.push_back(4);
v2.push_back(5);
v1.swap(v2);
for(int j = 0; j < v1.size(); j ++)
cout<<v1[j]<<" ";
cout<<endl;
for(int k = 0; k < v2.size(); k ++)
cout<<v2[k]<<" ";
cout<<endl;
return 0;
}
```
1 2 3 4 5
1 2 3
- 注:
- `vector<vector<int> > v(3);` 定义了一个 vector 容器,该容器中的每个元素都是一个 vector<int> 容器,即可以认为,v是一个二维数组,一共三行,每行都是一个可变长的一维数组
- 在 Dev C++ 中,上面写法中 int 后面的两个`>`之间需要有空格,否则有的编译器会把它们当作`>>`运算符,编译会出错
typedef struct rect{
int id;
int length;
int width;
// 对于向量元素是结构体的。可在结构体内部定义比较函数,下面按照id,length,width升序排序
bool operator < (const rect & a) const
{
if(id != a.id)
return id < a.id;
else
{
if(length != a.length)
return length < a.length;
else
return width < a.width;
}
}
}Rect;
int main() {
vector<Rect> vec;
Rect rect;
rect.id = 1;
rect.length = 2;
rect.width = 3;
vec.push_back(rect);
vector<Rect>::iterator it = vec.begin();
cout<<(*it).id<<" "<<(*it).length<<" "<<(*it).width<<endl;
return 0;
}
```
1 2 3
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。