vector容器类型
vector容器

模板类

存放任何类型
对象(
必须
同
类对象)
vector对象

运行时高效地添加元素
并且vector
元素
连续存储
vector
构造
函数原型:
template<typename T>
explicit vector(); // 默认构造函数
vector对象
空
explicit vector(size_type n, const T& v = T()); // 创建有n
元素
vector对象
vector(const vector& x);
vector(const_iterator first, const_iterator last);
注:vector容器内存放
所有对象都
经过初始化


没有指定存储对象
初始值

对于内置类型
用0初始化
对于类类型
调用其默认构造函数进行初始化(
有其
构造函数而没有默认构造函数

此时必须提供元素初始值才能放入容器
)
举例:
vector<string> v1; // 创建空容器
其对象类型
string类
vector<string> v2(10); // 创建有10
具有初始值(即空串)
string类对象
容器
vector<string> v3(5, "hello"); // 创建有5
值
hello
string类对象
容器
vector<string> v4(v3.begin(), v3.end()); // v4
与v3相同
容器(完全复制)
vector
操作(下面
函数都
成员函数)
bool empty() const; // 

容器
空
返回true;否则返回false
size_type max_size() const; // 返回容器能容纳
大元素
数
size_type size() const; // 返回容器
元素
数
size_type capacity() const; // 容器能够存储
元素
数
有:capacity() >= size()
void reserve(size_type n); // 确保capacity() >= n
void resize(size_type n, T x = T()); // 确保返回
有:size() == n;
之前size()<n

用元素x
值补全
reference front(); // 返回容器
第
元素
引用(容器必须非空)
const_reference front() const;
reference back(); // 返回容器



元素
引用(容器必须非空)
const_reference back() const;
reference operator[](size_type pos); // 返回下标
pos
元素
引用(下标从0开始;
下标
正确
则属于未定义行
const_reference operator[](size_type pos) const;
reference at(size_type pos); // 返回下标
pos
元素
引用;
下标
正确
则抛出异常out_of_range
const_reference at(size_type pos) const;
void push_back(const T& x); // 向容器末尾添加
元素
void pop_back(); // 弹出容器



元素(容器必须非空)
// 注:下面
插入和删除操作
发生元素
移动(
了保持连续存储
性质)
所
之前
迭代器
能失效
iterator insert(iterator it, const T& x = T()); //
插入点元素之前插入元素(或者说
插入点插入元素)
void insert(iterator it, size_type n, const T& x); // 注意迭代器
能
再有效(
能重新分配空间)
void insert(iterator it, const_iterator first, const_iterator last);
iterator erase(iterator it); // 删除指定元素
并返回删除元素

元素
位置(
无元素
返回end())
iterator erase(iterator first, iterator last); // 注意:删除元素
删除点之
元素对应
迭代器
再有效
void clear() const; // 清空容器
相当于调用erase( begin(), end())
void assign(size_type n, const T& x = T()); // 赋值
用指定元素序列替换容器内所有元素
void assign(const_iterator first, const_iterator last);
const_iterator begin() const; // 迭代序列
iterator begin();
const_iterator end() const;
iterator end();
const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
const_reverse_iterator rend() const;
reverse_iterator rend();
vector对象
比较(非成员函数)
针对vector对象
比较有六
比较运算符:operator==、operator!=、operator<、operator<=、operator>、operator>=
其
对于operator==和operator!=

vector对象拥有相同
元素
数
并且对应位置
元素全部相等
则两
vector对象相等;否则
等
对于operator<、operator<=、operator>、operator>=
采用字典排序策略比较
注:其实只需要实现operator==和operator!=

了
其

根据
两
实现
因
operator!= (lhs, rhs) 
!(lhs == rhs)
operator<=(lhs, rhs) 
!(rhs < lhs)
operator>(lhs, rhs) 
(rhs < lhs)
operator>=(lhs, rhs) 
!(lhs, rhs)
vector类
迭代器
vector类
迭代器除了支持通用
前缀自增运算符外
还支持算术运算:it + n、it - n、it2 - it1
注意it2 - it1返回值
difference_type(signed类型)
注意
任何改变容器大小
操作都
能造成
前
迭代器失效
应用示例
#include <iostream>
#include <cassert>
#include <vector>
using namespace std;
int main()
{
vector<string> v(5, "hello");
vector<string> v2(v.begin(), v.end());
assert(v == v2);
cout<<"> Before operation"<<endl;
for(vector<string>::const_iterator it = v.begin(); it < v.end(); ++it)
cout<<*it<<endl;
v.insert(v.begin() + 3, 4, "hello, world");
cout<<"> After insert"<<endl;
for(vector<string>::size_type i = 0; i < v.size(); ++i)
cout<<v[i]<<endl;
vector<string>::iterator it = v.erase(v.begin() + 3, v.begin() + 6);
assert(*it == "hello, world");
cout<<"> After erase"<<endl;
for(vector<string>::size_type i = 0; i != v.size(); ++i)
cout<<v[i]<<endl;
assert(v.begin() + v.size() == v.end());
assert(v.end() - v.size() == v.begin());
assert(v.begin() - v.end() == -vector<string>::difference_type(v.size()));
return 0;
}
程序说明:上面程序
用了三
循环输出容器
元素
每
循环
遍历方式

样
特别需要说明

第二
循环
条件判断
使用了size() 函数
而

循环之前先保存
变量
再使用
之所
样做
有两
原因:其



来
修改程序时
循环
修改了容器元素
数

循环仍
能
好 地工作
而
先保存size()函数值
正确了;其二
由于
些小函数(其实现只需要
条返回语句)基本上都被声明
inline
所
需要考虑效率问题
转自百度知道~