vector pop_back _生活经验

vector中push_back函数的意思是什么

文章插图

vector中push_back函数的意思是在vector的末尾插入一个元素。vector简单理解为动态一维数组push_back作用是在这个一维数组尾部插入一个元素 vector vv.push_back(1); //v里面是1v.push_back(2); //v里面是1 , 2v.push_back(3); //v里面是1 , 2 , 3 。扩展资料：push_back是编程语言里面的一个函数名。函数原型void push_back(value _type _Ch);参数_Ch --> The character to be added to the end of the string.在vector类中：void push_back(const _Ty &_X){insert(end(), _X);}在vector类中：void push_back(const bool _X){insert(end(), _X);}参考资料来源：百度百科-push_back
MFC vector容器为什么只有pop_back()没有pop_front()?vector模板类就跟堆内存一样，先进后出。就那种模型。
没区别不嫌累就多写点

c++中vector<T>pop_back()和stack<T>.pop()对弹出的对象执行delete操作吗不执行delete操作。如果是指针的话，需要自己delete ，如果在栈上，析构函数会在生命期结束调用。

在化学材料中pop是什么意思POP ，对辛基苯酚名称的缩写。
中文别名:4-辛基苯酚;4-正辛基苯酚
是一种化工产品，广泛用于制造油溶性酚醛树脂、表面活性剂、粘合剂等。

C语言中的pop函数是什么单词的缩写关于 pop 函数，我不太确定题主说的是哪个函数，因为 C 语言的标准函数库是没有 pop 这个函数的。如果题主说的是 C++ 的 Stack 类中的 pop 函数的话，它并不是一个缩写，因为从栈中取值的操作就叫做 pop 。然后就是查询单词原型的网站，因为 C 语言好多函数库中的函数名都是按照很奇怪的方法缩写的，所以基本上没有一个专门查全称的网站。不过题主可以参考http://www.cplusplus.com/reference/clibrary/这个网站里面虽然没有指出具体的缩写方式，但是能很好地解释 C 语言标准函数库的所有函数的作用。通过它的介绍你应该会对函数的全称有一个大概的理解。比如说这个针对 stdio.h 头文件中所定义函数的解释：不光是 C 语言，C++ 的标准类库的信息也可以在这个网站中找到。
PopBackStack 和 replace 操作有何不同拦截back按钮,调用FragmentManager.popBackStack(String na. c++中vector T pop_back()和stack T .pop()对弹出的对象执行dele. 不执行delete操作。如果是指针的话,需要自己

c++怎么决定用vector，queue还是stack1.Stack
top()返回栈顶元素，并不移除这个元素
empty()如果栈空返回true ，否则false
size（）栈的大小
void push()插入元素到栈顶
void pop()移除栈顶元素
#include
#include
using namespace std;

void main()
{
stack v;
for(int i=0;i<10;i++)
v.push(i+97);

cout<<v.size()<<endl;

while(!v.empty())
{
cout<<v.top()<<" ";
v.pop();
}
}

2.queue
empty()判空
front()返回队头元素
pop（）删除对头元素
back()返回队尾元素
push（）在队尾加入元素
size（）大小

#include
#include
using namespace std;
int main()
{
queueq;
for(int i=0;i<5;i++)q.push(i);
while(!q.empty()) //or while(q.size())
{
cout<<q.front();
q.pop();
}
return 0;
}
//树的非递归遍历，层次遍历什么的，不用自己再写栈和队列了，直接利用STL中的就行了

头文件：
#include
using namespace std;

1.默认的sort函数是按升序排。对应于1）
sort(a,a+n);//两个参数分别为待排序数组的首地址和尾地址
2.可以自己写一个cmp函数，按特定意图进行排序。对应于2）
例如：
int cmp( const int &a, const int &b ){
if( a > b )
return 1;
else
return 0;
}
sort(a,a+n,cmp);
是对数组a降序排序
又如：
int cmp( const POINT &a, const POINT &b ){
if( a.x < b.x )
return 1;
else
if( a.x == b.x ){
if( a.y < b.y )
return 1;
else
return 0;
}
else
return 0;
}
sort(a,a+n,cmp);
是先按x升序排序，若x值相等则按y升序排

与此类似的还有C中的qsort，以下同附上qsort的使用方法：

#include

格式 qsort(array_name,data_number,sizeof(data_type),compare_function_name)(void*)bsearch
(pointer_to_key_word,array_name,find_number,

sizeof(data_type),compare_function_name)

e.g.

int Cmp(const void*a,const void *b)

{

int*pa=(int*)a,*pb=(int*)b;

if(*pa>*pb) return 1;

else if (*pa==*pb)return 0;

elsereturn -1;

}

qsort(data,N,sizeof(int),Cmp);// 对int型数组进行快速排序（非降序排列）

p=(int*)bsearch(&a,data,n,sizeof(int),Cmp);

bool compare(int a,int b)
{
return ab ，则为降序
}

标准库Vector类型

使用需要的头文件：

#include

Vector：Vector 是一个类模板。不是一种数据类型。Vector是一种数据类型。

一、定义和初始化

Vector v1;//默认构造函数v1为空

Vector v2(v1);//v2是v1的一个副本

Vector v3(n,i);//v3包含n个值为i的元素

Vector v4(n);//v4含有n个值为0的元素

二、值初始化

1>如果没有指定元素初始化式，标准库自行提供一个初始化值进行值初始化。

2>如果保存的式含有构造函数的类类型的元素，标准库使用该类型的构造函数初始化。

3>如果保存的式没有构造函数的类类型的元素，标准库产生一个带初始值的对象，使用这个对象进行值初始化。

三、Vector对象最重要的几种操作

1.v.push_back(t)在数组的最后添加一个值为t的数据

2.v.size()当前使用数据的大小

3.v.empty()判断vector是否为空

4.v[n]返回v中位置为n的元素

5.v1=v2把v1的元素替换为v2元素的副本

6.v1==v2判断v1与v2是否相等

7.！=、、>=保持这些操作符惯有含义

vector容器类型

vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。

vector的构造

函数原型：

template

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 v1;// 创建空容器，其对象类型为string类

vector v2(10);// 创建有10个具有初始值（即空串）的string类对象的容器

vector v3(5, "hello"); // 创建有5个值为“hello”的string类对象的容器

vector 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!= ，如果vector对象拥有相同的元素个数，并且对应位置的元素全部相等，则两个vector对象相等；否则不等。

对于operator、operator>=，采用字典排序策略比较。

注：其实只需要实现operator==和operator!=就可以了，其它可以根据这两个实现。因为，operator!=
(lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs <
lhs) ， operator>(lhs, rhs) 就是 (rhs =（lhs, rhs) 就是
!(lhs, rhs) 。

vector类的迭代器

vector类的迭代器除了支持通用的前缀自增运算符外，还支持算术运算：it + n、it - n、it2 - it1 。注意it2 - it1返回值为difference_type（signed类型）。

注意，任何改变容器大小的操作都可能造成以前的迭代器失效。

应用示例

#include

#include

#include

using namespace std;

int main()

{

vector v(5, "hello");

vector v2(v.begin(), v.end());

assert(v == v2);

cout Before operation"<<endl;

for(vector::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::size_type i = 0; i < v.size(); ++i)

cout<<v[i]<<endl;

vector::iterator it = v.erase(v.begin() + 3, v.begin() + 6);

assert(*it == "hello, world");

cout After erase"<<endl;

for(vector::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::difference_type(v.size()));

return 0;

}

程序说明：上面程序中用了三个循环输出容器中的元素，每个循环的遍历方式是不一样的。特别需要说明的是，第二个循环在条件判断中使用了size()

函数，而不是在循环之前先保存在变量中再使用。之所以这样做，有两个原因：其一，如果将来在修改程序时，在循环中修改了容器元素个数，这个循环仍然能很好地工作，而如果先保存size()函数值就不正确了；其二，由于这些小函数（其实现只需要一条返回语句）基本上都被声明为inline，所以不需要考虑效率问题。

vector pop_back中的pop是什么意思，那个字母缩写push_back 是往vector的尾部压入数据
pop_back 是从vecotr弹出最后压入的那个数据
pop有类似跳出的意思，应该不是缩写。

急！ C++中stack ， pop的操作pop返回值类型是void（error C2440: '=' : cannot convert from 'void' to 'char'明确指出了这一点）。因为如果返回非void类型，返回时会调用复制构造函数，如果其中抛出异常就会在未完成构造的情况下中断且无法简单回滚，无法保证容器的异常安全性，所以在std::stack的设计时就考虑把返回栈顶元素的功能交给其它成员函数实现，这个成员函数的原型是const typename std::stack::value_type& std::stack::top() const;，在std::stack的类作用域内简作const value_type top() const;，其中value_type是元素类型。
因此s2[len]=st.pop(); 是错的。应该使用
s2[len]=st.top();
st.pop();
另外既然使用string，直接用==和!=比较就可以了。
strcmp的原型是int strcmp(const char*, const char*);，不接受string类型的参数，所以产生错误。
或者用string的成员函数c_str得到C风格字符串表示：strcmp(s1.c_str(),s2.c_str()) 。也可以不用string而用char数组，这样就可以直接strcmp 。
↑2011-3-20 20:36 。
----
er...才注意到LZ用string而用的是operator[]……注意string和内置数组、vector、map等一样，operator[]是不进行越界检查的（上述除了内置数组外都有成员函数at完成相同功能并会在之前检查是否越界，如果越界抛出out_of_range异常）……而LZ初始化后string自身管理的内存就已经确定了（因为没进行调用会改变内存大小的操作），虽然通常是16字节，但不见得会有保证（取决于模板类std::basic_string的具体实现；这里LZ忘了len++和末尾置零。。。我这里改正之后还是有问题，应该就是这个原因）。对于string还是直接用+=在末尾增加内容比较好，如果内存不够用会自动分配，而且也比较直观。
如果一定要用[]最好自己用数组或者指针分配空间。
改好的代码（只看第二个while循环就行）：
#include
#include
#include
using namespace std;
int main()
{
int len=0;
string s1;
string s2;
stack st;
cout<<"请输入要判断的字符串： ";
cin>>s1;
while(s1[len]!='\0')
{
st.push(s1[len]);
len++;
}
len=0;
while(st.size()!=0)
{
s2+=st.top();
st.pop();
}
if(s1==s2)
cout<<"该字符串为一个回文";
return 0;
}

c++ 急急急急采用STL的vector动态数组完成用于堆的push和pop两个操作。vector属于动态数组，可以随意的添加、删除数组中的元素。其中push是向数组中添加元素，pop是向数组中删除元素的。
使用时需要#include
using namespace std;

使用如下：

vector vTest;//定义一个int型的vector
vTest.push_back(6);//向数组中添加6
vTest.push_back(8);//向数组中添加8
vTest.pop_back();//删除一个元素，也就是最后进来的那个元素---8

MFC vector 为什么只有popback没有popfront那头指针呢？可以这么考虑，vector是一个单向链表，那么删结尾和删开头哪个容易？

vector类中为什么没有push_front方法和pop_front方法？为什么？对vector进行push_front会造成所有元素的迁移，不符合vector设计的初衷

C++STL的vector中front（）是返回第一个元素的应用吗？front()返回的的确是第一个元素的引用。但是你定义的b并不是一个引用，操作b不会对a中的元素造成影响。若定义int &b=a.front();则对b的操作会影响a中第一个元素。
【C++ STL】vector 中为什么没有push_front？首先,你得要先明白,vector是开辟一块空间来作为数组来存放元素(随机迭代器),如果有了pop_front,pop_back这个功能则很容易造成内存碎片,pop_front会造成头部内存产生碎片,pop_back朝臣尾部内存产生碎片,所以不能像deque(双向迭代器)那样有pop_front, pop_back这样的完全相同的实现.其次才是性能上的问题,vector实现pop_front的功能可以这样:
vector vi;
vi.push_back(1);
vi.push_back(2);
vi.push_back(3);
vi.erase(vi.begin());//等同于push_front
但是,这样实现的实质是,重新开辟内存放置元素后释放原先的内存,这样做的原因是放置内存碎片,在程序中,如果产生内存碎片则意味着这是内存泄露,是十分危险的一件事情,所以不能在stl中出现

vector类中为什么没有push_front方法和pop_front方法？为什么？vector类主要用的是向量，访问其中的元素可以用下标，比如a[89]而push_front方法和pop_front方法是堆栈中使用的堆栈用的是指针用这些操作访问很方便

利用c++中的vector创建动态二维数组vector为C++中的一个容器类，其功能相当于动态数组。使用vector需要包含头文件vector 。vector的常用操作：1. v.push_back(t)在容器的最后添加一个值为t的数据，容器的size变大。另外list有push_front()函数，在前端插入，后面的元素下标依次增大。2. v.size()返回容器中数据的个数，size返回相应vector类定义的size_type的值。3. v.empty()判断vector是否为空4. v[n]返回v中位置为n的元素5. v.insert(pointer,number, content)向v中pointer指向的位置插入number个content的内容。6. v.pop_back()删除容器的末元素，并不返回该元素。7.v.erase(pointer1,pointer2) 删除pointer1到pointer2中间（包括pointer1所指）的元素。8. v1==v2判断v1与v2是否相等。9. ！=、、>=保持这些操作符惯有含义。10. vector::iterator p=v1.begin( ); p初始值指向v1的第一个元素。*p取所指向元素的值。11.p=v1.end( ); p指向v1的最后一个元素的下一位置。12.v.clear()删除容器中的所有元素。12.v.clear()删除容器中的所有元素。若要用vector实现二维动态数组，可用vector作模板类型参数：vector > arr;

c++ 容器类常用成员函数#include
vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：
using std::vector;
vector vInts;
或者连在一起，使用全名：
std::vector vInts;
建议使用全局的命名域方式：using namespace std;
函数
表述
c.assign(beg,end)c.assign(n,elem)
将[beg; end)区间中的数据赋值给c 。将n个elem的拷贝赋值给c 。
c.at(idx)
传回索引idx所指的数据，如果idx越界，抛出out_of_range 。
c.back()
传回最后一个数据，不检查这个数据是否存在。
c.begin()
传回迭代器中的第一个数据地址。
c.capacity()
返回容器中数据个数。
c.clear()
移除容器中所有数据。
c.empty()
判断容器是否为空。
c.end()
指向迭代器中的最后一个数据地址。
c.erase(pos)
c.erase(beg,end)
删除pos位置的数据，传回下一个数据的位置。
删除[beg,end)区间的数据，传回下一个数据的位置。
c.front()
传回第一个数据。
get_allocator
使用构造函数返回一个拷贝。
c.insert(pos,elem)
c.insert(pos,n,elem)
c.insert(pos,beg,end)
在pos位置插入一个elem拷贝，传回新数据位置。在pos位置插入n个elem数据。无返回值。在pos位置插入在[beg,end)区间的数据。无返回值。
c.max_size()
返回容器中最大数据的数量。
c.pop_back()
删除最后一个数据。
c.push_back(elem)
在尾部加入一个数据。
c.rbegin()
传回一个逆向队列的第一个数据。
c.rend()
传回一个逆向队列的最后一个数据的下一个位置。
c.resize(num)
重新指定队列的长度。
c.reserve()
保留适当的容量。
c.size()
返回容器中实际数据的个数。
c1.swap(c2)
swap(c1,c2)
将c1和c2元素互换。同上操作。
vector
cvector c1(c2)
vectorc(n)
ectorc(n, elem)
vectorc(beg,end)
c.~ vector ()
创建一个空的vector 。复制一个vector 。创建一个vector ，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector 。创建一个以[beg;end)区间的vector 。销毁所有数据，释放内存。
operator[]
返回容器中指定位置的一个引用。
创建一个vector
vector容器提供了多种创建方法，下面介绍几种常用的。
创建一个Widget类型的空的vector对象：
vector vWidgets;
创建一个包含500个Widget类型数据的vector：
vector vWidgets(500);
创建一个包含500个Widget类型数据的vector ，并且都初始化为0：
vector vWidgets(500, Widget(0));
创建一个Widget的拷贝：
vector vWidgetsFromAnother(vWidgets);
向vector添加一个数据
vector添加数据的缺省方法是push_back() 。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector中添加10个数据，需要如下编写代码：
for(int i= 0;i<10; i++) {
vWidgets.push_back(Widget(i));
}
获取vector中制定位置的数据
vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果想知道vector存放了多少数据，可以使用empty() 。获取vector的大小，可以使用size() 。例如，如果想获取一个vector v的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：
int nSize = v.empty() ? -1 : static_cast(v.size());
访问vector中的数据
使用两种方法来访问vector 。
1、 vector::at()
2、 vector::operator[]
operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：
分析下面的代码：
vector v;
v.reserve(10);
for(int i=0; i<7; i++) {
v.push_back(i);
}
try {int iVal1 = v[7];
// not bounds checked - will not throw
int iVal2 = v.at(7);
// bounds checked - will throw if out of range
} catch(const exception& e) {
cout << e.what();
}
删除vector中的数据
vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。
Remove_if()算法如果要使用remove_if()，需要在头文件中包含如下代码：：
#include
Remove_if()有三个参数：
1、 iterator _First：指向第一个数据的迭代指针。
2、 iterator _Last：指向最后一个数据的迭代指针。
3、 predicate _Pred：一个可以对迭代操作的条件函数。
条件函数
条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。
例如，假如想从一个vector中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：
#include
enum findmodes {
FM_INVALID = 0,
FM_IS,
FM_STARTSWITH,
FM_ENDSWITH,
FM_CONTAINS
};
typedef struct tagFindStr {
UINT iMode;
CString szMatchStr;
} FindStr;
typedef FindStr* LPFINDSTR;
然后处理条件判断：
class FindMatchingString : public std::unary_function {
public:
FindMatchingString(const LPFINDSTR lpFS) :
m_lpFS(lpFS) {
}
bool operator()(CString& szStringToCompare) const {
bool retVal = false;
switch (m_lpFS->iMode) {
case FM_IS: {
retVal = (szStringToCompare == m_lpFDD->szMatchStr);
break;
}
case FM_STARTSWITH: {
retVal = (szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szWindowTitle);
break;
}
case FM_ENDSWITH: {
retVal = (szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szMatchStr);
break;
}
case FM_CONTAINS: {
retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1);
break;
}
}
return retVal;
}
private:
LPFINDSTR m_lpFS;
};
通过这个操作你可以从vector中有效地删除数据：
FindStr fs;
fs.iMode = FM_CONTAINS;
fs.szMatchStr = szRemove;
vs.erase(std::remove_if(vs.begin(), vs.end(), FindMatchingString(&fs)), vs.end());
Remove(),remove_if()等所有的移出操作都是建立在一个迭代范围上的，不能操作容器中的数据。所以在使用remove_if()，实际上操作的时容器里数据的上面的。
看到remove_if()实际上是根据条件对迭代地址进行了修改，在数据的后面存在一些残余的数据，那些需要删除的数据。剩下的数据的位置可能不是原来的数据，但他们是不知道的。
调用erase()来删除那些残余的数据。注意上面例子中通过erase()删除remove_if()的结果和vs.enc()范围的数据。

c++容器，成员函数Insert传递3个迭代器参数的使用问题。#include <vector>
vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：
using std::vector;
vector<int> vInts;
或者连在一起，使用全名：
std::vector<int> vInts;
建议使用全局的命名域方式：using namespace std;
函数
表述
c.assign(beg,end)c.assign(n,elem)
将[beg; end)区间中的数据赋值给c 。将n个elem的拷贝赋值给c 。
c.at(idx)
传回索引idx所指的数据，如果idx越界，抛出out_of_range 。
c.back()
传回最后一个数据，不检查这个数据是否存在。
c.begin()
传回迭代器中的第一个数据地址。
c.capacity()
返回容器中数据个数。
c.clear()
移除容器中所有数据。
c.empty()
判断容器是否为空。
c.end()
指向迭代器中的最后一个数据地址。
c.erase(pos)
c.erase(beg,end)
删除pos位置的数据，传回下一个数据的位置。
删除[beg,end)区间的数据，传回下一个数据的位置。
c.front()
传回第一个数据。
get_allocator
使用构造函数返回一个拷贝。
c.insert(pos,elem)
c.insert(pos,n,elem)
c.insert(pos,beg,end)
在pos位置插入一个elem拷贝，传回新数据位置。在pos位置插入n个elem数据。无返回值。在pos位置插入在[beg,end)区间的数据。无返回值。
c.max_size()
返回容器中最大数据的数量。
c.pop_back()
删除最后一个数据。
c.push_back(elem)
在尾部加入一个数据。
c.rbegin()
传回一个逆向队列的第一个数据。
c.rend()
传回一个逆向队列的最后一个数据的下一个位置。
c.resize(num)
重新指定队列的长度。
c.reserve()
保留适当的容量。
c.size()
返回容器中实际数据的个数。
c1.swap(c2)
swap(c1,c2)
将c1和c2元素互换。同上操作。
vector<Elem>
cvector<Elem> c1(c2)
vector <Elem> c(n)
ector <Elem> c(n, elem)
vector <Elem> c(beg,end)
c.~ vector <Elem>()
创建一个空的vector 。复制一个vector 。创建一个vector，含有n个数据，数据均已缺省构造产生。创建一个含有n个elem拷贝的vector 。创建一个以[beg;end)区间的vector 。销毁所有数据，释放内存。
operator[]
返回容器中指定位置的一个引用。
创建一个vector
vector容器提供了多种创建方法，下面介绍几种常用的。
创建一个Widget类型的空的vector对象：
vector<Widget> vWidgets;
创建一个包含500个Widget类型数据的vector：
vector<Widget> vWidgets(500);
创建一个包含500个Widget类型数据的vector，并且都初始化为0：
vector<Widget> vWidgets(500, Widget(0));
创建一个Widget的拷贝：
vector<Widget> vWidgetsFromAnother(vWidgets);
向vector添加一个数据
vector添加数据的缺省方法是push_back() 。push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector<Widget>中添加10个数据，需要如下编写代码：
for(int i= 0;i<10; i++) {
vWidgets.push_back(Widget(i));
}
获取vector中制定位置的数据
vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。如果想知道vector存放了多少数据，可以使用empty() 。获取vector的大小，可以使用size() 。例如，如果想获取一个vector v的大?。恢浪欠裎眨?或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：
int nSize = v.empty() ? -1 : static_cast<int>(v.size());
访问vector中的数据
使用两种方法来访问vector 。
1、 vector::at()
2、 vector::operator[]
operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。但at()是我们的首?。蛭猘t()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：
分析下面的代码：
vector<int> v;
v.reserve(10);
for(int i=0; i<7; i++) {
v.push_back(i);
}
try {int iVal1 = v[7];
// not bounds checked - will not throw
int iVal2 = v.at(7);
// bounds checked - will throw if out of range
} catch(const exception& e) {
cout << e.what();
}
删除vector中的数据
vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。
Remove_if()算法如果要使用remove_if()，需要在头文件中包含如下代码：：
#include <algorithm>
Remove_if()有三个参数：
1、 iterator _First：指向第一个数据的迭代指针。
2、 iterator _Last：指向最后一个数据的迭代指针。
3、 predicate _Pred：一个可以对迭代操作的条件函数。
条件函数
条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。
例如，假如想从一个vector<CString>中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：
#include <functional>
enum findmodes {
FM_INVALID = 0,
FM_IS,
FM_STARTSWITH,
FM_ENDSWITH,
FM_CONTAINS
};
typedef struct tagFindStr {
UINT iMode;
CString szMatchStr;
} FindStr;
typedef FindStr* LPFINDSTR;
然后处理条件判断：
class FindMatchingString : public std::unary_function<CString, bool> {
public:
FindMatchingString(const LPFINDSTR lpFS) :
m_lpFS(lpFS) {
}
bool operator()(CString& szStringToCompare) const {
bool retVal = false;
switch (m_lpFS->iMode) {
case FM_IS: {
retVal = (szStringToCompare == m_lpFDD->szMatchStr);
break;
}
case FM_STARTSWITH: {
retVal = (szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szWindowTitle);
break;
}
case FM_ENDSWITH: {
retVal = (szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())
== m_lpFDD->szMatchStr);
break;
}
case FM_CONTAINS: {
retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1);
break;
}
}
return retVal;
}
private:
LPFINDSTR m_lpFS;
};
通过这个操作你可以从vector中有效地删除数据：
FindStr fs;
fs.iMode = FM_CONTAINS;
fs.szMatchStr = szRemove;
vs.erase(std::remove_if(vs.begin(), vs.end(), FindMatchingString(&fs)), vs.end());
Remove(),remove_if()等所有的移出操作都是建立在一个迭代范围上的，不能操作容器中的数据。所以在使用remove_if()，实际上操作的时容器里数据的上面的。
看到remove_if()实际上是根据条件对迭代地址进行了修改，在数据的后面存在一些残余的数据，那些需要删除的数据。剩下的数据的位置可能不是原来的数据，但他们是不知道的。
调用erase()来删除那些残余的数据。注意上面例子中通过erase()删除remove_if()的结果和vs.enc()范围的数据。

什么是容器首先，我们必须理解一下，在C++ 中容器被定义为：在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象，当然这是一个朴素的理解，这种“对象”还包含了一系列处理“其它对象”的方法，因为这些方法在程序的设计上会经常被用到，所以容器也体现了一个好处，就是“容器类是一种对特定代码重用问题的良好的解决方案” 。容器还有另一个特点是容器可以自行扩展。在解决问题时我们常常不知道我们需要存储多少个对象，也就是说我们不知道应该创建多大的内存空间来保存我们的对象。显然，数组在这一方面也力不从心。容器的优势就在这里，它不需要你预先告诉它你要存储多少对象，只要你创建一个容器对象，并合理的调用它所提供的方法，所有的处理细节将由容器来自身完成。它可以为你申请内存或释放内存，并且用最优的算法来执行您的命令。容器是随着面向对象语言的诞生而提出的，容器类在面向对象语言中特别重要，甚至它被认为是早期面向对象语言的基础。在现在几乎所有的面向对象的语言中也都伴随着一个容器集，在C++ 中，就是标准模板库（STL）。和其它语言不一样，C++ 中处理容器是采用基于模板的方式。标准C++ 库中的容器提供了多种数据结构，这些数据结构可以与标准算法一起很好的工作，这为我们的软件开发提供了良好的支持！通用容器的分类 STL对定义的通用容器分三类：顺序性容器、关联式容器和容器适配器。顺序性容器是一种各元素之间有顺序关系的线性表，是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。这个位置和元素本身无关，而和操作的时间和地点有关，顺序性容器不会根据元素的特点排序而是直接保存了元素操作时的逻辑顺序。比如我们一次性对一个顺序性容器追加三个元素，这三个元素在容器中的相对位置和追加时的逻辑次序是一致的。关联式容器和顺序性容器不一样，关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能，这样迭代器就能根据元素的特点“顺序地”获取元素。关联式容器另一个显著的特点是它是以键值的方式来保存数据，就是说它能把关键字和值关联起来保存，而顺序性容器只能保存一种（可以认为它只保存关键字，也可以认为它只保存值）。这在下面具体的容器类中可以说明这一点。容器适配器是一个比较抽象的概念， C++的解释是：适配器是使一事物的行为类似于另一事物的行为的一种机制。容器适配器是让一种已存在的容器类型采用另一种不同的抽象类型的工作方式来实现的一种机制。其实仅是发生了接口转换。那么你可以把它理解为容器的容器，它实质还是一个容器，只是他不依赖于具体的标准容器类型，可以理解是容器的模版。或者把它理解为容器的接口，而适配器具体采用哪种容器类型去实现，在定义适配器的时候可以由你决定。下表列出STL 定义的三类容器所包含的具体容器类：标准容器类特点顺序性容器 vector从后面快速的插入与删除，直接访问任何元素 deque从前面或后面快速的插入与删除，直接访问任何元素 list双链表，从任何地方快速插入与删除关联容器 set快速查找，不允许重复值 multiset快速查找，允许重复值 map一对多映射，基于关键字快速查找，不允许重复值 multimap一对多映射，基于关键字快速查找，允许重复值容器适配器 stack后进先出 queue先进先出 priority_queue最高优先级元素总是第一个出列 vector ,deque 和 list顺序性容器：向量vector：是一个线性顺序结构。相当于数组，但其大小可以不预先指定，并且自动扩展。它可以像数组一样被操作，由于它的特性我们完全可以将vector 看作动态数组。在创建一个vector 后，它会自动在内存中分配一块连续的内存空间进行数据存储，初始的空间大小可以预先指定也可以由vector 默认指定，这个大小即capacity（）函数的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块，但这样的分配是很耗时的，在重新分配空间时它会做这样的动作：首先，vector 会申请一块更大的内存块；然后，将原来的数据拷贝到新的内存块中；其次，销毁掉原内存块中的对象（调用对象的析构函数）；最后，将原来的内存空间释放掉。如果vector 保存的数据量很大时，这样的操作一定会导致糟糕的性能（这也是vector 被设计成比较容易拷贝的值类型的原因）。所以说vector 不是在什么情况下性能都好，只有在预先知道它大小的情况下vector 的性能才是最优的。vector的特点：(1) 指定一块如同数组一样的连续存储，但空间可以动态扩展。即它可以像数组一样操作，并且可以进行动态操作。通常体现在push_back() pop_back() 。(2) 随机访问方便，它像数组一样被访问，即支持[ ] 操作符和vector.at()(3) 节省空间，因为它是连续存储，在存储数据的区域都是没有被浪费的，但是要明确一点vector 大多情况下并不是满存的，在未存储的区域实际是浪费的。(4) 在内部进行插入、删除操作效率非常低，这样的操作基本上是被禁止的。Vector 被设计成只能在后端进行追加和删除操作，其原因是vector 内部的实现是按照顺序表的原理。(5) 只能在vector 的最后进行push 和pop ，不能在vector 的头进行push 和pop 。(6) 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放，这个操作非常消耗性能。所以要vector 达到最优的性能，最好在创建vector 时就指定其空间大小。双向链表list是一个线性链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠后，它的检索时间就越长。检索时间与目标元素的位置成正比。虽然随机检索的速度不够快，但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置，插入或删除一个元素仅对最多三个元素有所影响，不像vector 会对操作点之后的所有元素的存储地址都有所影响，这一点是vector 不可比拟的。list的特点：(1) 不使用连续的内存空间这样可以随意地进行动态操作；(2) 可以在内部任何位置快速地插入或删除，当然也可以在两端进行push 和pop 。(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at()；(4) 相对于verctor 占用更多的内存。双端队列deque是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它允许较为快速地随机访问，但它不像vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小。它不需要重新分配空间，所以向末端增加元素比vector 更有效。实际上，deque 是对vector 和list 优缺点的结合，它是处于两者之间的一种容器。deque的特点：(1) 随机访问方便，即支持[ ] 操作符和vector.at() ，但性能没有vector 好；(2) 可以在内部进行插入和删除操作，但性能不及list；(3) 可以在两端进行push、pop；三者的比较下图描述了vector、list、deque 在内存结构上的特点： vector是一段连续的内存块，而deque 是多个连续的内存块， list 是所有数据元素分开保存，可以是任何两个元素没有连续。vector的查询性能最好，并且在末端增加数据也很好，除非它重新申请内存段；适合高效地随机存储。list是一个链表，任何一个元素都可以是不连续的，但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的，而查询性能非常差；适合大量地插入和删除操作而不关心随机存取的需求。deque是介于两者之间，它兼顾了数组和链表的优点，它是分块的链表和多个数组的联合。所以它有被list 好的查询性能，有被vector 好的插入、删除性能。如果你需要随即存取又关心两端数据的插入和删除，那么deque 是最佳之选。关联容器 set, multiset, map, multimap是一种非线性的树结构，具体的说采用的是一种比较高效的特殊的平衡检索二叉树—— 红黑树结构。（至于什么是红黑树，我也不太理解，只能理解到它是一种二叉树结构）因为关联容器的这四种容器类都使用同一原理，所以他们核心的算法是一致的，但是它们在应用上又有一些差别，先描述一下它们之间的差别。set，又称集合，实际上就是一组元素的集合，但其中所包含的元素的值是唯一的，且是按一定顺序排列的，集合中的每个元素被称作集合中的实例。因为其内部是通过链表的方式来组织，所以在插入的时候比vector 快，但在查找和末尾添加上被vector 慢。multiset，是多重集合，其实现方式和set 是相似的，只是它不要求集合中的元素是唯一的，也就是说集合中的同一个元素可以出现多次。map，提供一种“键- 值”关系的一对一的数据存储能力。其“键”在容器中不可重复，且按一定顺序排列（其实我们可以将set 也看成是一种键- 值关系的存储，只是它只有键没有值。它是map 的一种特殊形式）。由于其是按链表的方式存储，它也继承了链表的优缺点。multimap，和map 的原理基本相似，它允许“键”在容器中可以不唯一。关联容器的特点是明显的，相对于顺序容器，有以下几个主要特点： 1，其内部实现是采用非线性的二叉树结构，具体的说是红黑树的结构原理实现的； 2，set和map 保证了元素的唯一性，mulset 和mulmap 扩展了这一属性，可以允许元素不唯一； 3，元素是有序的集合，默认在插入的时候按升序排列。基于以上特点，1，关联容器对元素的插入和删除操作比vector 要快，因为vector 是顺序存储，而关联容器是链式存储；比list 要慢，是因为即使它们同是链式结构，但list 是线性的，而关联容器是二叉树结构，其改变一个元素涉及到其它元素的变动比list 要多，并且它是排序的，每次插入和删除都需要对元素重新排序； 2，关联容器对元素的检索操作比vector 慢，但是比list 要快很多。vector 是顺序的连续存储，当然是比不上的，但相对链式的list 要快很多是因为list 是逐个搜索，它搜索的时间是跟容器的大小成正比，而关联容器查找的复杂度基本是Log(N) ，比如如果有1000 个记录，最多查找10 次，1,000,000 个记录，最多查找20 次。容器越大，关联容器相对list 的优越性就越能体现；3，在使用上set 区别于vector,deque,list 的最大特点就是set 是内部排序的，这在查询上虽然逊色于vector ，但是却大大的强于list 。4，在使用上map 的功能是不可取代的，它保存了“键- 值”关系的数据，而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位置，而map 是用字符型关键字来索引元素的位置。在使用上map 也提供了一种类数组操作的方式，即它可以通过下标来检索数据，这是其他容器做不到的，当然也包括set 。（STL 中只有vector 和map 可以通过类数组的方式操作元素，即如同ele[1] 方式）容器适配器 STL中包含三种适配器：栈stack 、队列queue 和优先级priority_queue 。适配器是容器的接口，它本身不能直接保存元素，它保存元素的机制是调用另一种顺序容器去实现，即可以把适配器看作“它保存一个容器，这个容器再保存所有元素” 。STL中提供的三种适配器可以由某一种顺序容器去实现。默认下stack 和queue 基于deque 容器实现，priority_queue 则基于vector 容器实现。当然在创建一个适配器时也可以指定具体的实现容器，创建适配器时在第二个参数上指定具体的顺序容器可以覆盖适配器的默认实现。由于适配器的特点，一个适配器不是可以由任一个顺序容器都可以实现的。

c++使用vector容器pushback的时候，最终只有最后一个数据成功加入容器，前面的数据都丢失了你怎么发现它丢失的？看起来完全没有问题啊

C++STL中list和vector的区别C++ STL 提供了3个序列容器：vector, deque, list
vector 中的元素是顺序存放的，所以随机访问很快,但是要插入和删除，这个时间复杂度就很高了，vector初始化时有一个capacity,如果元素个数超出capacity,那vector就会重新分配一个新的空间，并把旧值复制到新的空间中，释法原空间，这个也要耗费很多时间，所以如果你知道元素的最大值，最好用reserve()函数初始最大空间，避免重新分配空间造成的时间。
deque 几乎所有的操作都和vector一样，出了可以在头添加和删除，多了个push_front(), pop_front();
list 是双链表，元素在内存中是分散的不连续的，它使用指针left,right,指向前一个元素和后一个元素。所以要删除和添加只要动动指针，所以很快，但是因为是不连续的所以要访问一个元素，你只能遍历序列。

STL中front（）引用不是很懂，是否和c++里面引用一个意思。front()说白了就是访问某一个“容器”或者“迭代器”的“第一个元素”；同理 back（）就是访问某一个容器的最后一个元素。至于中间的元素访问，就只能通过迭代器一步一步去查找了。
什么时候用front（），就是当你需要访问某个“容器”的第一个元素的时候，不用去定义一个迭代器进行查找，只需使用 front（）就可以直接访问了。

C++ STL vector 迭代器求助对于vector，有一个简单的规则，就是，push_back()后就不要再引用原来的迭代器，因为，它可能已经失效了。
下面是vector的大致实现。
template class Vector {
public:
Vector() : size_(0), space_(0), elem_(0) { }
//ATTENTION : don't forget explicit
explicit Vector(int size)
: size_(size), space_(size), elem_(new Ty[size]) { }
Vector(const Vector& v);
~Vector() { delete[] elem_; }

Vector& operator=(const Vector& v);

void resize(int newsize); //set new size
void reserve(int newalloc); //reserve space
int capacity() const { return space_; }//return space
//not check
Ty& operator[](int index) { return elem_[index]; }
//overload for const object
const Ty& operator[](int index) const { return elem_[index]; }

int size() const { return size_; }
void push_back(const Ty& d);//add a new element
private:
int size_;
int space_;
Ty* elem_;
};
template void Vector::resize(int newsize)
//make the vector have newsize elements
//initialize each new element with the default value
{
reserve(newsize);
for (int i=size_; i<newsize; ++i) elem_[i] = T();
size_ = newsize;
}
template void Vector::reserve(int newalloc)
{
if (space_<=newalloc) return;

Ty* newptr = new Ty[newalloc];
for (int t=0; t<size_; ++t) newptr[t] = elem_[t];
delete[] elem_;
elem_ = newptr;
space_ = newalloc;
}
template void Vector::push_back(const Ty& d)
//increase vector size by one and initialize the new element with d
{
//first determinate the space
if (space_==0) reserve(10);
else if (size_==space_) reserve(size_*2);

//second initialize the elements
elem_[size_] = d;
++size_;
}
还有，我实在不明白，为什么你会把fprintf和vector一起用，用fstream不好吗？

C++ STL Vector如何存放类的对象？#include #include using namespace std;class A{public:int a;int b;string c;A(int aa,int bb,string cc):a(aa),b(bb),c(cc){}};int main(){vector vec;vec.push_back(new A(123,111,"abcd"));return 0;}测试没有问题，主要string str有问题，还有就是中文字符的分号之类的小错误，还有就是忘了写分号的小错误。
在vector中，怎样删除某个指定值的元素删除vector指定位置的元素，参考如下：
#include
#include
using namespace std;

int main(int argc, char** argv)
{
std::vector vec;
for(int i=0;i<100;i++)
{
vec.push_back(i);
}

printf("10:%d\n",vec[10]);
printf("size:%d\n",vec.size());
printf("**********************************\n");
std::vector::iterator it = vec.begin()+10;
vec.erase(it);

printf("10:%d\n",vec[10]);
printf("size:%d\n",vec.size());
return 0;
}

vector c++ 怎样删除元素1、可以用erase方法删除vector指定位置的元素。2、例程： #include #include using namespace std;int main(int argc, char** argv){ std::vector vec; for(int i=0;i

怎么去除vector中的一个元素clear() 清空所有元素 empty() 判断Vector是否为空（返回true时为空） erase() 删除指定元素 (可以用指针来代替迭代器) iterator erase( iterator loc ); //要删除元素的迭代器 iterator erase( iterator start, iterator end ); //要删除的第一...

vector删除指定位置元素我觉得由于vector是一个动态容器，当你删去一个元素时，容器容量即verSet0.size()会减小，此时可能ii会访问越界。

C++中怎么删除vector中的一个元素

文章插图

【vector pop_back】C++ vector中实际删除元素使用的是容器vecrot中std::vector::erase()方法。C++ 中std::remove()并不删除元素，因为容器的size()没有变化，只是元素的替换。代码：std::vector::erase()函数原型：iterator erase (iterator position);//删除指定元素iterator erase (iterator first, iterator last);//删除指定范围内的元素返回值：指向删除元素(或范围)的下一个元素。positions.erase(positions.begin() + i)注意删除之后vector大小已经变化，循环控制条件要注意变化c.pop_backc的最后一个元素，返回void 。扩展资料：C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。C++语言中定义了丰富的运算符，如算术运算符、关系运算符、逻辑运算符等等，有些运算符需要两个操作数，使用形式为运算符这样的运算符称为二元运算符（或二目运算符）。另一些运算符只需要一个操作数，称为一元运算符（或单目运算符）。运算符具有优先级与结合性。当一个表达式包含多个运算符时，先进行优先级高的运算，再进行优先级低的运算。参考资料来源：百度百科-c++
C++ 如何删除vector中的结构体元素#include #include #include #include using namespace std;typedef struct rect //定义结构体{int id;int length;int width;rect(int i,int l ,int w):id(i),length(l),width(w){};} Rect;int main(){Rect rect(1,2,3);vector vec(2,rect);//定义一个含有2个元素rect的vec容器Rect rect2(3,3,4);vec.push_back(rect2);Rect rect3(4,5,7);vec.push_back(rect3);Rect rect4(6,3,4);vec.push_back(rect4);/**********************删除前遍历输出****************************/for(vector::iterator it=vec.begin();it!=vec.end();++it){cout::iterator it=vec.begin();it!=vec.end();){Rect temp=*it;if(temp.id==4){it=vec.erase(it); //删除元素，返回值指向已删除元素的下一个位置}else++it;}cout<<"/***********split*************/"<<endl;/**********************删除后遍历输出***************************/for(size_t i=0;i!=vec.size();++i){cout<<vec[i].id<<" "<<vec[i].length<<" "<<vec[i].width<<endl;}return 0;}

c++ 如何删除 vector中的第一个元素#include//#include//usingnamespacestd;//typedefstruct{//intid;//intname;//}Student;////////intmain(){//Studentss={12,13};//printf("%d%d\n",ss.id,ss.name);//vectorst;////struct初始化//vectors(2,{12,13});//s(2,ss);//s.push_back(ss);////////inti=1;////while(i<10){//printf("%d,%d",s.front().id,s.front().name);////i++;//}//}#include#include#include#include#includeusingnamespacestd;voidPrintInt(constint&nData){cout<<nData<<endl;}intmain(){vectorvecInt;for(inti=0;i<10;++i){vecInt.push_back(i);}cout<<"向量中的内容为："<<endl;//for_each(vecInt.begin(),vecInt.end(),PrintInt);for(vector::iteratoriter=vecInt.begin();iter!=vecInt.end();++iter){cout<<*iter<<"";}cout<<"\n";cout<<"vectorcontains"<<vecInt.size()<<"elements"<<endl;vecInt.pop_back();//删除最后一个元素cout<<"删除最后一个元素后， vectorcontains"<<vecInt.size()<<"elements"<<endl;vector::iteratork=vecInt.begin();vecInt.erase(k);//删除第一个元素for(vector::iteratoriter=vecInt.begin();iter!=vecInt.end();++iter){cout<<*iter<<"";}cout<<"\n";//vecInt.erase(k);//迭代器k已经失效，会出错cout<<"删除第一个元素后， vectorcontains"<<vecInt.size()<<"elements"<<endl;k=vecInt.begin();vecInt.erase(k);for(vector::iteratoriter=vecInt.begin();iter!=vecInt.end();++iter){cout<<*iter<<"";}cout<<"\n";cout<<"删除第一个元素后，vectorcontains"<<vecInt.size()<<"elements"<<endl;//vecInt.erase(vecInt.begin(),vecInt.end());//删除所有元素//cout<<"删除所有元素后，vectorcontains"<<vecInt.size()<<"elements"<<endl;//输出为0vector::iteratorvecNewEnd=remove(vecInt.begin(),vecInt.end(),5);//删除元素cout<<"删除元素后，vectorcontains"<<vecInt.size()<<"elements"<<endl;cout<<"向量开始到新结束为止的元素："<<endl;//for_each(vecInt.begin(),vecNewEnd,PrintInt);cout<<"向量中的元素："<<endl;//for_each(vecInt.begin(),vecInt.end(),PrintInt);return0;}扩展资料：Vector函数的优点：1、使用的时候无须声明上限，随着元素的增加， Vector的长度会自动增加；2、Vector类提供额外的方法来增加、删除元素，比数组操作高效。Vector函数的缺点：1、时间：运行速度与数组相比较慢。2、空间：clear()无法清空内存。vector的删除功能1、public final synchronized void removeElement(Object obj)从向量中删除obj 。若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。2、public final synchronized void removeAllElement()删除向量中所有的对象。3、public final synchronized void removeElementlAt(int index)删除index所指的地方的对象。4、pop_back()删除最后一个项(C++)
C++ STL删除vector中指定元素心情好+没事做这很难吗？不就是用游标取出然后做一个Value比较吗？有什么纠结的？for (std::vector::iterator iter1 = dvCardReject.begin(); iter1 != dvCardReject.end(); ++iter1) {for (std::vector::iterator iter2 = dvCardAll.begin(); iter2 != dvCardAll.end(); /*注意这里没有++游标*/) {TCard card1 = *iter1;TCard card2 = *iter2;if (card1.GetValue() == card2.GetValue()) {iter2 = dvCardAll.erase(iter2);//找到了就擦除，游标会自动指向下一个}else {iter2++;//value不一样就++查下一个}} }

怎样在c++ 中删除vector最后一个元素

文章插图

c++可以使用 vector 的成员函数 pop_back() 来删除容器尾部的元素。vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说， vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。扩展资料：vector的缺点：1、时间开销较大，运行速度与数组相比较慢。2、clear()无法清空内存。注意：vector属于std命名域的，因此需要通过命名限定。建议在代码量不大，并且使用的命名空间不多的情况下，使用全局的命名域方式：using namespace std函数。vector常用方法：1、c.assign(beg,end) c.assign(n,elem)将（beg; end）区间中的数据赋值给c 。将n个elem的拷贝赋值给c 。传回索引idx所指的数据，如果idx越界，抛出out_of_range 。2、c.back()，传回最后一个数据，不检查这个数据是否存在。3、c.begin()，传回迭代器中的第一个数据地址。4、c.capacity()，返回容器当前已分配的容量。5、c.clear() ，移除容器中所有数据。6、c.empty()，判断容器是否为空。c.end() //指向迭代器中末端元素的下一个，指向一个不存在元素。c.erase(pos)//　删除pos位置的数据，传回下一个数据的位置。c.erase(beg,end)删除[beg,end）区间的数据，传回下一个数据的位置。7、c.front()，传回第一个数据。参考资料来源：百度百科-vector
C++ 如何删除vector中的元素用迭代器和erase方法（vector做删除效率很低哦）举个例子：从一个vector里删除偶数，用迭代器做写入操作时要注意迭代器位置状态#include #include using namespace std;int main(){ vector iv;for (int i=1; i::iterator it=iv.begin(); while( it<iv.end()){if (*it%2==0){it=iv.erase(it);continue; //删除后it已经指向下一个元素了，所以不能++了，直接continue}++it; } for (it=iv.begin(); it<iv.end(); ++it)cout<<*it<<endl; return 0;}

C++ vector要怎麼删除其中一个元素#include using namespace std;void main(void){vector array;array.push_back(1);array.push_back(2);array.push_back(3);array.push_back(4);array.push_back(5);vector::iterator itr = array.begin();while (itr != array.end){if (*itr == 3)array.erase(itr);//删除值为3的元素++itr;}}//若是最后一个可用array.pop_back()

C++删除向量中的一个元素vector v = {0,1,2,3,4,5};for(vector::iterator itr = v.begin(); itr != v.end(); itr++){if(*itr == 3){v.erase(itr);break;}}for(auto ele : v){printf("%d, ", ele);}如果你不要指定删除元素，要指定索引的话，自己再控制一个变量去递增索引来满足要求。
如何使用vector容器的最后一个元素可以使用迭代器it = Int.end() - 1即可实现。

vector a;
vector::iterator iter=a.end();//迭代器指向容器的最后一个元素的后一个位置

获得容器最后一个元素:

cout<<*--iter//最后一个元素的值
<<a.back()// 最后一个元素的值
<<a[a.size()-1];//最后一个元素的值

c++中怎样将vector中的元素倒序输出？正确而优雅的方法应该去使用

reverse_iterator
typedef std::vector vt_type;
vt_type vt;
// insert code ...
for(vt_type::const_reverse_iterator i = vt.rbegin(), isize = vt.rend(); i != isize; ++i)
{
std::cout << *i << std::endl;
}

类似这样

VC/MFCvector如何得到vector中的最后一个元素1、思路可以首先利用length函数，得到vector的长度；然后最后一个元素即对应[长度-1]的元素的位置。2、代码如下：int length=vector1.length();string str=vector1[length-1];