CPP-STL:vector容器
1. vector容器简介:
vector向量容器是一种随机访问的数组类型,它提供了对数组元素的快速访问、随机访问,以及在序列尾部快速、随机地插入和删除操作。它类似于数据结构中的队列、数组和堆栈等概念。
2. vector容器的定义
2.1 头文件 #include<vector>
2.2 命名空间 using namespace std;
2.3 举例:
vector<string> m_vector;//定义一个string类型的向量容器
vector<int> m_vector;//定义一个int类型的向量容器
vector<int> m_vector(10);//创建了具有10个元素的容器,每个元素初始值为0
vector<int> m_vector(10,5);//创建具有10个元素的容器,每个元素初始值为5
vector<char> v1(5,’k’);
vector<char> v2(v1);//v2和v1相同。
int iArray[]={11,13,19,23,27};
vector<int> v(iArray,iArray+5);//用数组iArray创建容器。
3. vector容器的初始化
3.1 使用push_back()函数
如:
#pragma warning(disable:4786) #include <vector>
#include <iostream>
#include <string> using namespace std; int main()
{
vector<string> m_vector; m_vector.push_back("B08020526");
m_vector.push_back("B08020888");
m_vector.push_back("南邮"); for (int i=;i<;i++)
{
cout<<m_vector[i]<<endl;
} return ;
}
3.2 预先设定容器大小,有元素存在,方可使用[]运算符
#pragma warning(disable:4786) #include <vector>
#include <iostream> using namespace std; void main (void)
{
vector<int> Myvector; Myvector.reserve();//限定大小为4 // 新元素还没有构造, 此时不能用[]访问元素
for (int i=;i<;i++)
{
Myvector.push_back(i);
}
for(unsigned int i=;i<;i++)
{
Myvector[i]=i+;
cout<<Myvector[i]<<" ";
} }
4. vector容器大小的判断
主要是区分vector的几个函数,它们是size()、max_size()、capacity()
size:指容器当前存储了多少个元素
max_size:指容器的最大尺寸,一般是一个定值。但是不同的数据类型,有着不同的值。如int为1073741823,而double类型的向量容器的max_size为: 536870911;
capacity:指容器的容量,有reserve()函数确定;当没有reserve()函数确定时,它的值与size相同;
举例:
#pragma warning(disable:4786) #include <iostream>
#include <vector> using namespace std ; typedef vector<int> INTVECTOR; void main()
{
INTVECTOR thevector; thevector.push_back() ; cout << "size=" << thevector.size() << endl;
cout << "max_size=" << thevector.max_size()<< endl;
cout << "capacity=" << thevector.capacity() << endl; thevector.reserve(); cout << "size is: " << thevector.size() << endl;
cout << "max_size is: " << thevector.max_size()<< endl;
cout << "capacity is: " << thevector.capacity() << endl;
} // size=1 // max_size=1073741823 // capacity=1 // size is: 1 // max_size is: 1073741823 // capacity is: 1000
5. vector容器的遍历
5.1使用迭代器和循环相结合
#pragma warning(disable:4786) #include <iostream>
#include <vector>
#include <string> using namespace std; struct student
{
int ID;
string name; student(int i,string n)
{
ID=i;
name=n;
}
}; void main (void)
{
vector<student> Myvector;
vector<student>::iterator m_Iterator;//生成迭代器 student stu1(,"张三");
student stu2(,"李四");
student stu3(,"王五");
student stu4(,"张三"); Myvector.push_back(stu1);
Myvector.push_back(stu2);
Myvector.push_back(stu3);
Myvector.push_back(stu4); for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
{
cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
}
}
输出:
1 张三
4 李四
2 王五
3 张三
5.2使用for_each()算法
#pragma warning(disable:4786) #include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each() using namespace std; struct student
{
int ID;
string name; student(int i,string n)
{
ID=i;
name=n;
}
};
void OutFun(student &OutStu);//自定义输出函数 void main (void)
{
vector<student> Myvector; student stu1(,"张三");
student stu2(,"李四");
student stu3(,"王五");
student stu4(,"张三"); Myvector.push_back(stu1);
Myvector.push_back(stu2);
Myvector.push_back(stu3);
Myvector.push_back(stu4); for_each(Myvector.begin(),Myvector.end(),OutFun);
} void OutFun(student &OutStu)
{
cout<<OutStu.ID<<" "<<OutStu.name<<endl;
}
5.3使用size()函数及[]运算法符和for循环相结合。
如:
for (int i=0;i<Myvector.size();i++)
{
cout<<Myvector[i].ID<<" "<<Myvector[i].name<<endl;
}
6. vector容器的反向遍历
6.1使用迭代器和循环相结合
vector<student>::reverse_iterator m_Iterator;//一定要将迭代器声明为反向迭代器
......
for (m_Iterator=Myvector.rbegin();m_Iterator!=Myvector.rend();m_Iterator++)
{
cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
}
6.2使用for_each()算法
for_each(Myvector.rbegin(),Myvector.rend(),OutFun);//需要头文件 algorithm
6.3 使用size()函数及[]运算法符和for循环相结合。
for (int i=Myvector.size()-;i>=;i--)
{
cout<<Myvector[i].ID<<" "<<Myvector[i].name<<endl;
}
7. vector容器的删除操作
7.1调用pop_back()函数,删除向量容器尾部的一个元素;
7.2调用erase();函数,删除由迭代器指向的一个元素,或由迭代器指向的一个区间。
Myvector.erase(Myvector.begin()+);
Myvector.erase(Myvector.begin(),Myvector.end()-);
7.3 clear()函数,删除所有的元素
7.4 用算法remove(),只是将待删除元素之后的元素移动到vector的前端,而不是删除。若要真正移除,需要搭配使用erase()。
8. vector容器插入元素
Myvector.insert(Myvector.begin()+,,stu4);
第一个参数是迭代器类型,表示插入的位置,第二个参数表示参入的个数。第三个参数表示插入的元素。
另外一种表达形式:
student stu_array[]={stu1,stu2,stu3,stu4}; Myvector.insert(Myvector.begin()+,&stu_array[],&stu_array[]);
9. vector容器中元素的查找
9.1.很显然,要用算法中的find函数或者find_if函数。当vector中存储的是普通类型,如int,double等时,find的第三个参数,可以是这种类型的一个值;当vector中存储的是一个类时,该类必须重载‘==’运算符。
9.2对于find_if,其第三个参数是一个函数名。而且这个函数的返回值必须为bool类型的,而且其参数必须是vector存储的类型的引用。
举例:
//文件名:CHAPTER6-8.cpp #pragma warning(disable:4786) #include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each()
using namespace std;
class student
{
public:
int ID;
string name;
student(int i,string n)
{
ID=i;
name=n;
}
bool operator == (const student& ob)
{
if (ob.ID==ID&&ob.name==name)
{
return true;
}
else
{
return false;
}
}
}; void OutFun(student &OutStu);
bool ForFindFun(student &OutStu); void main (void)
{
vector<student> Myvector;
vector<student>::iterator m_Iterator; student stu1(,"张三");
student stu2(,"李四");
student stu3(,"王五");
student stu4(,"赵六");
Myvector.push_back(stu1);
Myvector.push_back(stu2);
Myvector.push_back(stu3);
Myvector.push_back(stu4); for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
{
cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
}
cout<<"----------------------------------------"<<endl; for_each(Myvector.rbegin(),Myvector.rend(),OutFun); cout<<"----------------------------------------"<<endl; /*m_Iterator=remove(Myvector.begin(),Myvector.end(),&stu2);*/
Myvector.insert(Myvector.begin()+,,stu4);
for_each(Myvector.begin(),Myvector.end(),OutFun);
// student stu_array[4]={stu1,stu2,stu3,stu4}; // Myvector.insert(Myvector.begin()+2,&stu_array[0],&stu_array[3]); // for_each(Myvector.begin(),Myvector.end(),OutFun); int var_count(); var_count=count(Myvector.begin(),Myvector.end(),stu1);
cout<<"\n与stu1相同的个数为"<<var_count<<endl; var_count=count_if(Myvector.begin(),Myvector.end(),ForFindFun);
cout<<"\nID大于2的个数有:"<<var_count<<endl;
} void OutFun(student &OutStu)
{
cout<<OutStu.ID<<" "<<OutStu.name<<endl;
} bool ForFindFun(student &OutStu)
{
if (OutStu.ID>)
{
return true;
}
return false;
}
//输出结果为:
1 张三
4 李四
2 王五
3 赵六
----------------------------------------
3 赵六
2 王五
4 李四
1 张三
----------------------------------------
1 张三
4 李四
3 赵六
3 赵六
2 王五
3 赵六
与stu1相同的个数为1
ID大于2的个数有:4
10. vector容器中元素的排序
//文件名:CHAPTER6-8.cpp #pragma warning(disable:4786) #include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each() using namespace std; class student
{
public:
int ID;
string name;
student(int i,string n)
{
ID=i;
name=n;
}
bool operator == (const student& ob)
{
if (ob.ID==ID&&ob.name==name)
{
return true;
}
else
{
return false;
}
}
}; void OutFun(student &OutStu);
bool ForFindFun(student &OutStu);
bool MySort(student &stuE,student&Temp_stu);
void main (void)
{
vector<student> Myvector;
vector<student>::iterator m_Iterator;
student stu1(,"张三");
student stu2(,"李四");
student stu3(,"王五");
student stu4(,"赵六");
Myvector.push_back(stu1);
Myvector.push_back(stu2);
Myvector.push_back(stu3);
Myvector.push_back(stu4); for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
{
cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
}
cout<<"----------------------------------------"<<endl; for_each(Myvector.rbegin(),Myvector.rend(),OutFun);
cout<<"----------------------------------------"<<endl; m_Iterator=remove(Myvector.begin(),Myvector.end(),stu2);
Myvector.insert(Myvector.begin()+,,stu4); for_each(Myvector.begin(),Myvector.end(),OutFun); // student stu_array[4]={stu1,stu2,stu3,stu4}; // Myvector.insert(Myvector.begin()+2,&stu_array[0],&stu_array[3]); // for_each(Myvector.begin(),Myvector.end(),OutFun); int var_count(); var_count=count(Myvector.begin(),Myvector.end(),stu1);
cout<<"\n与stu1相同的个数为"<<var_count<<endl; var_count=count_if(Myvector.begin(),Myvector.end(),ForFindFun);
cout<<"\nID大于2的个数有:"<<var_count<<endl; cout<<"---------------整理结果--------------------"<<endl;
for (int i=Myvector.size();i>;i--)
{
sort(Myvector.begin(),Myvector.end(),MySort);
}
for_each(Myvector.begin(),Myvector.end(),OutFun);
} void OutFun(student &OutStu)
{
cout<<OutStu.ID<<" "<<OutStu.name<<endl;
} bool ForFindFun(student &OutStu)
{
if (OutStu.ID>)
{
return true;
}
return false;
}
bool MySort(student &stuE,student&Temp_stu)
{
// student temp(0,"");
if (stuE.ID>Temp_stu.ID)
{
student temp(stuE.ID,stuE.name);
stuE.ID=Temp_stu.ID;
stuE.name=Temp_stu.name; Temp_stu.ID=temp.ID;
Temp_stu.name=temp.name;
}
return true;
}
11. vector容器中元素的交换
如:swap(stu1,stu2);
那么就相当于stu1的值和stu2的值进行了交换。
如:将MySort修改如下,结果仍然不变。
bool MySort(student &stuE,student&Temp_stu)
{
// student temp(0,"");
if (stuE.ID>Temp_stu.ID)
{
swap(stuE,Temp_stu);
}
return true;
}
当然,也可以进行容器的交换。
如:
vector<int > v1;
vector<int > v2;
v1.swap(v2);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
vector是C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。为了可以使用vector,必须在你的头文件中包含下面的代码:#include <vector>
构造函数。
Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成,而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。
函数列表如下:
Constructors 构造函数
Operators 对vector进行赋值或比较
assign() 对Vector中的元素赋值
at() 返回指定位置的元素
back() 返回最末一个元素
begin() 返回第一个元素的迭代器
capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下)
clear() 清空所有元素
empty() 判断Vector是否为空(返回true时为空)
end() 返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
erase() 删除指定元素
front() 返回第一个元素
get_allocator() 返回vector的内存分配器
insert() 插入元素到Vector中
max_size() 返回Vector所能容纳元素的最大数量(上限)
pop_back() 移除最后一个元素
push_back() 在Vector最后添加一个元素
rbegin() 返回Vector尾部的逆迭代器
rend() 返回Vector起始的逆迭代器
reserve() 设置Vector最小的元素容纳数量
resize() 改变Vector元素数量的大小
size() 返回Vector元素数量的大小
swap() 交换两个Vector
/////////////////////////////////////////////////////////////////////////////////////
函数详细说明
构造函数
语法:
vector();
vector( size_type num, const TYPE &val );
vector( const vector &from );
vector( input_iterator start, input_iterator end );
C++ Vectors可以使用以下任意一种参数方式构造:
无参数 - 构造一个空的vector,
数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector
vector(from) - 构造一个与vector from 相同的vector
迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).
举例,下面这个实例构造了一个包含5个值为42的元素的Vector
vector<int> v1( 5, 42 );
运算符
语法:
v1 == v2
v1 != v2
v1 <= v2
v1 >= v2
v1 < v2
v1 > v2
v[]
C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.
两个vectors被认为是相等的,如果:
它们具有相同的容量
所有相同位置的元素相等.
vectors之间大小的比较是按照词典规则.
assign函数
语法:
void assign( input_iterator start, input_iterator end );
void assign( size_type num, const TYPE &val );
assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.
at函数
语法:
TYPE at( size_type loc );
at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素. 例如, 考虑下面的代码:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is "
<< v[i] << endl;
}
这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is "
<< v.at(i) << endl;
}
取代试图访问内存里非法值的作法,at() 函数能够辨别出访问是否越界并在越界的时候抛出一个异常out_of_range.
back 函数
语法:
TYPE back();
back() 函数返回当前vector最末一个元素的引用.例如:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
cout << "The first element is " << v.front()
<< " and the last element is "
<< v.back() << endl;
这段代码产生如下结果:
The first element is 0 and the last element is 4
begin 函数
语法:
iterator begin();
begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:
vector<int> v1( 5, 789 );
vector<int>::iterator it;
for( it = v1.begin(); it != v1.end(); it++ )
cout << *it << endl;
capacity 函数
语法:
size_type capacity();
capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.
clear 函数
语法:
void clear();
clear()函数删除当前vector中的所有元素.
empty 函数
语法:
bool empty();
如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
while( !v.empty() ) {
cout << v.back() << endl;
v.pop_back();
}
end 函数
语法:
iterator end();
end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.
erase 函数
语法:
iterator erase( iterator loc );
iterator erase( iterator start, iterator end );
erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.例如:
// 创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator startIterator;
vector<char>::iterator tempIterator;
for( int i=0; i < size; i++ )
{
tartIterator = alphaVector.begin();
alphaVector.erase( startIterator );
// Display the vector
for( tempIterator = alphaVector.begin(); tempIterator !=
alphaVector.end(); tempIterator++ )
cout << *tempIterator;
cout << endl;
}
这段代码将会显示如下输出:
BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
EFGHIJ
FGHIJ
GHIJ
HIJ
IJ
J
front 函数
语法:
TYPE front();
front()函数返回当前vector起始元素的引用
get_allocator 函数
语法:
allocator_type get_allocator();
get_allocator() 函数返回当前vector的内存分配器.在STL里面一般不会调用new或者alloc来分配内存,而且通过一个allocator对象的相关方法来分配.
示例:vector<int>v3( 3, 1, v2.get_allocator( ));//把V2的内存分配器作为一个参数参与构造V3。这样,它们两个用一个内存分配器了。
insert 函数
语法:
iterator insert( iterator loc, const TYPE &val );
void insert( iterator loc, size_type num, const TYPE &val );
void insert( iterator loc, input_iterator start, input_iterator end );
insert() 函数有以下三种用法:
在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
在指定位置loc前插入num个值为val的元素
在指定位置loc前插入区间[start, end)的所有元素 .
举例:
//创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
//插入四个C到vector中
vector<char>::iterator theIterator = alphaVector.begin();
alphaVector.insert( theIterator, 4, 'C' );
//显示vector的内容
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end();
theIterator++ )
cout << *theIterator;
这段代码将显示:
CCCCABCDEFGHIJ
max_size 函数
语法:
size_type max_size();
max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).
pop_back
语法:
void pop_back();
pop_back()函数删除当前vector最末的一个元素,例如:
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator theIterator;
for( int i=0; i < size; i++ ) {
alphaVector.pop_back();
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end();
theIterator++ )
cout << *theIterator;
cout << endl;
}
这段代码将显示以下输出:
ABCDEFGHI
ABCDEFGH
ABCDEFG
ABCDEF
ABCDE
ABCD
ABC
AB
A
push_back 函数
语法:
void push_back( const TYPE &val );
push_back()添加值为val的元素到当前vector末尾
rbegin 函数
语法:
reverse_iterator rbegin();
rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值,详见逆代器相关内容)
示例:
vector<int>v1;
for(int i=1;i<=5;i++)
{
v1.push_back(i);
}
vector<int>::reverse_iterator pos;
pos=v1.rbegin();
cout<<*pos<<" ";
pos++;
cout<<*pos<<endl;
输出结果为:5 4
rend 函数
语法:
reverse_iterator rend();
rend()函数返回指向当前vector起始位置的逆迭代器.
示例:
vector<int>v1;
for(int i=1;i<=5;i++)
{
v1.push_back(i);
}
vector<int>::reverse_iterator pos;
pos=v1.rend();
pos--;
cout<<*pos<<" ";
pos--;
cout<<*pos<<endl;
输出结果为:1 2
reserve 函数
语法:
void reserve( size_type size );
reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)
resize 函数
语法:
void resize( size_type size, TYPE val );
resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val
resize 与reserve的区别
reserve是容器预留空间,但并不真正创建元素对象,在创建对象之前,不能引用容器内的元素,因此当加入新的元素时,需要用push_back()/insert()函数。
resize是改变容器的大小,并且创建对象,因此,调用这个函数之后,就可以引用容器内的对象了,因此当加入新的元素时,用operator[]操作符,或者用迭代器来引用元素对象。再者,两个函数的形式是有区别的,reserve函数之后一个参数,即需要预留的容器的空间;resize函数可以有两个参数,第一个参数是容器新的大小,第二个参数是要加入容器中的新元素,如果这个参数被省略,那么就调用元素对象的默认构造函数。
初次接触这两个接口也许会混淆,其实接口的命名就是对功能的绝佳描述,resize就是重新分配大小,reserve就是预留一定的空间。这两个接口即存在差别,也有共同点。下面就它们的细节进行分析。
为实现resize的语义,resize接口做了两个保证:
一是保证区间[0, new_size)范围内数据有效,如果下标index在此区间内,vector[indext]是合法的。
二是保证区间[0, new_size)范围以外数据无效,如果下标index在区间外,vector[indext]是非法的。
reserve只是保证vector的空间大小(capacity)最少达到它的参数所指定的大小n。在区间[0, n)范围内,如果下标是index,vector[index]这种访问有可能是合法的,也有可能是非法的,视具体情况而定。
resize和reserve接口的共同点是它们都保证了vector的空间大小(capacity)最少达到它的参数所指定的大小。
因两接口的源代码相当精简,以至于可以在这里贴上它们:
void resize(size_type new_size) { resize(new_size, T()); }
void resize(size_type new_size, const T& x) {
if (new_size < oldsize)
erase(oldbegin + new_size, oldend); // erase区间范围以外的数据,确保区间以外的数据无效
else
insert(oldend, new_size - oldsize, x); // 填补区间范围内空缺的数据,确保区间内的数据有效
示例:
#include<iostream>
#include<vector>
using namespace std;
void main()
{
vector<int>v1;
for(int i=1;i<=3;i++)
{
v1.push_back(i);
}
v1.resize(5,8);//多出的两个空间都初始化为8,
for(i=0;i<v1.size();i++)//resize与reserver并不会删除原先的元素以释放空间
{
cout<<v1[i]<<" ";
}
cout<<endl;
v1.reserve(7);// 新元素还没有构造,
for(i=0;i<7;i++)
{
cout<<v1[i]<<" ";//当i>4,此时不能用[]访问元素
}
cout<<endl;
cout<<v1.size()<<endl;
cout<<v1.capacity()<<endl;
}
输出结果为:
1 2 3 8 8
1 2 3 8 8 -842150451 -842150451
5
7
size 函数
语法:
size_type size();
size() 函数返回当前vector所容纳元素的数目
swap 函数
语法:
void swap( vector &from );
swap()函数交换当前vector与vector from的元素
示例:
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;
输出结果为:
1 2 3 4 5
1 2 3
CPP-STL:vector容器的更多相关文章
- C++ STL vector容器学习
STL(Standard Template Library)标准模板库是C++最重要的组成部分,它提供了一组表示容器.迭代器.函数对象和算法的模板.其中容器是存储类型相同的数据的结构(如vector, ...
- 浅谈C++ STL vector 容器
浅谈C++ STL vector 容器 本篇随笔简单介绍一下\(C++STL\)中\(vector\)容器的使用方法和常见的使用技巧.\(vector\)容器是\(C++STL\)的一种比较基本的容器 ...
- STL - vector容器
1Vector容器简介 vector是将元素置于一个动态数组中加以管理的容器. vector可以随机存取元素(支持索引值直接存取, 用[]操作符或at()方法,这个等下会详讲). vector尾部添加 ...
- STL vector容器 和deque容器
前言 STL是C++的框架,然后vector容器和deque容器又是STL的一部分... 这块的内容都是理解.概念为主,没什么捷径,希望读者能静下来记. 先来讲vector容器(单端动态数组) 1.v ...
- 2.3 C++STL vector容器详解
文章目录 2.3.1 引入 2.3.2 代码实例 2.3.3 运行结果 总结 2.3.1 引入 vector 容器 动态数组 可变数组 vector容器 单口容器(尾部操作效率高) vector动态增 ...
- [C++STL] vector 容器的入门
vector容器的入门 #include<vector> 创建vector容器的几种方式 数据类型可以是结构体,也能是另外一个容器 vector 的初始化: (1) 创建并声明大小 vec ...
- STL vector容器需要警惕的一些坑
从迭代器中取值切记需要判断是否为空 例如: vector<int> vtTest; vtTest.clear(); if (vtTest.empty()){ ; } ]; 如果没有忘了判断 ...
- C++STL(二)——vector容器
STL--vector容器 vector对象的概念 vector基本操作 vector对象的初始化.赋值 vector查找.替换(已在上一片 string类 博客总结过了,不再总结) vector添加 ...
- STL vector用法介绍
STL vector用法介绍 介绍 这篇文章的目的是为了介绍std::vector,如何恰当地使用它们的成员函数等操作.本文中还讨论了条件函数和函数指针在迭代算法中使用,如在remove_if()和f ...
- STL vector 用法介绍
介绍 这篇文章的目的是为了介绍std::vector,如何恰当地使用它们的成员函数等操作.本文中还讨论了条件函数和函数指针在迭代算法中使用,如在remove_if()和for_each()中的使用.通 ...
随机推荐
- android:ellipsize省略文字用法(转载)
转自:http://zhangkun716717-126-com.iteye.com/blog/864989 TextView及其子类,当字符内容太长显示不下时可以省略号代替未显示的字符:省略号可以在 ...
- git status -s 的表达式的读法
1 2 读法 解决方案 ?? 未被追踪 git add -A 或git add 文件路径 A 新添加文件 注:??被add后的状态 OK,等待commit. M 已 ...
- hdoj5317【素数预处理】
//这个很好了...虽然是一般.. int isp[1000100]; int p[1000100]; void init() { int sum=0; int i,j; fill(isp,isp+1 ...
- hdu1085 Holding Bin-Laden Captive!【生成函数】
列出生成函数的多项式之后暴力乘即可 #include<iostream> #include<cstdio> #include<cstring> using name ...
- (十)SpringBoot的文件上传
一:添加commons-fileupload依赖 打开pom文件添加 <dependency> <groupId>commons-fileupload</groupId& ...
- 无向图的边双连通分量(EBC)
嗯,首先边双连通分量(双连通分量之一)是:在一个无向图中,去掉任意的一条边都不会改变此图的连通性,即不存在桥(连通两个边双连通分量的边),称作边双连通分量.一个无向图的每一个极大边双连通子图称作此无向 ...
- python实现堆排序
理论知识: 二叉树:度不超过2的树(节点最多有两个叉) 满二叉树:一个二叉树,如果每一个层的节点数都达到最大值,则这个二叉树就是满二叉树. 完全二叉树:叶节点只能出现在最下层和次下层,并且最下面一层的 ...
- bzoj 5015 [Snoi2017]礼物
题面 https://www.lydsy.com/JudgeOnline/problem.php?id=5015 题解 首先把k=1,k=2,k=3的手推一遍 然后发现一些规律 就是数列可以表示成$a ...
- Eclipse安装jad反编译插件(在线安装)
Help→Eclipse Marketplace→Find→jad 然后等安装完成重启eclipse即可
- Super Mario 树状数组离线 || 线段树
Super Mario Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total ...