deque<int> b;
 deque<int> a;

for(int i=0; i<20; ++i) {
     a.push_back(i);
}

b.assign(a.begin(), a.begin()+10);

//第一种情况
 a.resize(5);
 cout << a[9] << endl;

//第二种情况
 swap(a,b);
cout << b[8] << endl;


这种在电脑上貌似能正常编译运行， 我现在郁闷的是元素个数已经被截短了，这样操作是否是安全的？
还有就是这种操作是否会在元素个数被截短的时候，内存是否会被释放掉？（如果是的话那上面的操作就一定不安全了^_^）
希望大家能帮忙解决下哈， 有资料分享下就更好了

这样做不安全
resize()函数可以改变向量的大小，并把一些元素初始化为适当类型的0或以无参构造初始化，被减少的类类型元素将引发析构。

如果是简单类型，你resize()减少元素个数，减少的部分可能被保留，就向你现在的情况，但是如果有后续的push_back操作，就可能会覆盖后面的数据了，resize之后相当于使得改变有效数据的范围，只有在size内的才安全,size外的不受保护，随时可能被覆盖,如果你在a.resize(5）后面执行一次a.push_back,那么a[5]的值就被覆盖了

如果是类类型，那就更加不行了，类类型直接析构，即使你没有覆盖操作，数据也可能消失了，举例如下

#include <deque>
#include <iostream>
#include <algorithm>
using namespace std;
class A {
public:
    A (void) {
        cout << "A无参：" << this << endl;
    }
    A (string str, int n):m_str(str),m_n(n) {
        cout << "A构造：" << this << endl;
    }
    A (const A& a) {
        m_str=a.m_str;
        m_n=a.m_n;
        cout << "A拷贝："<<&a<<" -> "<<this<< endl;
    }
    ~A (void) {
        cout << "A析构：" << this << endl;
    }
    friend ostream& operator << (ostream& os,const A& a) {
        return os << '(' << a.m_str << ", " << a.m_n << ')';    
    }
    
private:
    string m_str;
    int m_n;
};

int main (void) {
    int i;
    deque<int> di;
    di.push_back (0);
    di.push_back (1);
    di.push_back (2);
    di.push_back (3);
    di.push_back (4);
    di.resize(3);
    for(i=0; i<5; i++)
    {
        cout << di[i] << endl;
    }    
    
    deque<A> da;
    da.push_back(A("Tom",0));
    da.push_back(A("Jim",1));
    da.push_back(A("Lily",2));
    da.push_back(A("Lucy",3));
    da.push_back(A("Jack",4));
    da.resize(3);
    for(i=0; i<5; i++) {
        cout << da[i] << endl;
    }
    
    return 0;
}

[ 本帖最后由 tongzhipeng 于 2012-5-5 00:12 编辑 ]

调用da.resize(3)时为什么会调用A（）构造函数啊， 能否解释下啊， 谢谢

没写清楚，不好意思
应该在da.resize(3)之前　插一个分割线，这样看的更清楚一点
da.push_back(A("Jack",4));
    cout << "------------------------" << endl;
    da.resize(3);
结果如下：


resize(3)引起了无参构造，原因是为了给新增的部分进行初始化做的准备，你如果将da.resize(3) 改成da.resize(10);就能看到

可以看到无参构造出来的数据拷贝给了所有的新增部分。
resize()函数可以改变向量的大小，并把一些元素初始化为适当类型的0或以无参构造初始化，被减少的类类型元素将引发析构
这句话里的以无参构造初始化，就是这个意思。

[ 本帖最后由 tongzhipeng 于 2012-5-5 19:26 编辑 ]

顶起来，顶起来