std::vector::resize
Resizes the container so that it contains n elements.
调整容器使其包含n个元素。
If n is smaller than the current container size, the content is reduced to its first n elements,
removing those beyond (and destroying them).
如果n小于当前的容器大小(通过size获得，而不是capacity),那么将会只是保留前n个元素，移除多余的元素（并且销毁他们)
例子:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vi={1,2,3,4,5,6,7};
int mcapacity=vi.capacity();
int msize=vi.size();
cout<<"size="<<msize<<",capcity="<<mcapacity<<endl;
vi.resize(3);
cout<<"after resize(3):"<<endl;
for(auto it=vi.begin();it!=vi.end();++it)
cout<<*it<<endl;
cout<<"size="<<msize<<",capcity="<<mcapacity<<endl;
cout<<"try to access vi[5] now,vi[5]="<<vi[5]<<endl;
}
运行结果：
可以看到，resize(3)之后，只保留了前3个元素，其容量和大小都没有改变.
但是发现vi[5]还是可以访问并且得到正确的数据，并没有销毁里面的数据，这里可能是编译器的实现问题。（这样个人觉得可能会导致数据泄露，使用时需要注意）
If n is greater than the current container size, the content is expanded by inserting
at the end as many elements as needed to reach a size of n. If val is specified, the new elements are initialized as copies of val, otherwise, they are value-initialized.
如果n大于当前容器的大小，那么容器将会从尾部开始增长至大小n,如果指定了val的值，那么新增长的元素的值将会被初始化为val的一个拷贝，否则将会时元素值类型的默认值。
例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vi={1,2,3};
cout<<"at first ,vi:"<<endl;
for(auto it=vi.begin();it!=vi.end();++it)
cout<<*it<<" ";
cout<<endl;
vi.resize(7);
cout<<"after resize ,vi:"<<endl;
for(auto it=vi.begin();it!=vi.end();++it)
cout<<*it<<" ";
cout<<endl;
}
可以看到，如果不知道val的值，那么将会是int类型的默认值0!
下面使指定val为999的情况。即vi.resize(7,999);
If n is also greater than the current container capacity, an automatic reallocation
of the allocated storage space takes place.
如果n大于当前容器的容量(通过capacity获得),那么容器将会自动重分配空间以适应其增长。
例子:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vi={1,2,3};
cout<<"size="<<vi.size()<<" ,capacity="<<vi.capacity()<<endl;
cout<<"at first ,vi:"<<endl;
for(auto it=vi.begin();it!=vi.end();++it)
cout<<*it<<" ";
cout<<endl;
vi.resize(30,999);
cout<<"size="<<vi.size()<<" ,capacity="<<vi.capacity()<<endl;
cout<<"after resize ,vi:"<<endl;
for(auto it=vi.begin();it!=vi.end();++it)
cout<<*it<<" ";
cout<<endl;
}
结果：
Notice that this function changes the actual content of the container by inserting or erasing elements from it.
需要注意的是如果增长或者截断数组会改变其实际的内容.(修改size以及capacity)。
下面使我测试的例子:
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> vi={1,2,3,5,6,7,8,9,10,11,12};
cout<<"vi adress="<<&vi<<endl;
cout<<"size="<<vi.size()<<" ,capacity="<<vi.capacity()<<endl;
vi.resize(1000);
cout<<"vi adress="<<&vi<<endl;
cout<<"size="<<vi.size()<<" ,capacity="<<vi.capacity()<<endl;
vi.resize(2);
cout<<"vi adress="<<&vi<<endl;
cout<<"size="<<vi.size()<<" ,capacity="<<vi.capacity()<<endl;
}
结果：
Parameters
- n
- New container size, expressed in number of elements.
Member type size_type is an unsigned integral type.
-
新容器的大小，表现为元素的个数
-
n是一个无符号整型.
- val
- Object whose content is copied to the added elements in case that n is greater than the current container size.
If not specified, the default constructor is used instead.
Member type value_type is the type of the elements in the container, defined in vector as
an alias of the first template parameter (T). -
val为当n大于当前容器大小需要增长时，新的元素的值为val的拷贝。
-
如果不特别指定，那么将使用元素类型的默认构造器构造新的元素。
-
其类型由vector的第一个模版参数指定。
Return Value
none
If a reallocation happens, the storage is allocated using the container’s allocator, which may throw exceptions on
failure (for the default allocator, bad_alloc is thrown if the allocation request does not succeed).
无返回值。
如果发生重分配，那么使用容器的分配器的过程中如果分配失败可能会发生异常（例如对于默认分配器allocator,当分配不成功使会抛出bad_alloc异常）。
Example
|
|
Output:
myvector contains: 1 2 3 4 5 100 100 100 0 0 0 0
|
Complexity
Linear on the number of elements inserted/erased (constructions/destructions).
增加或者截断时，时间或空间复杂度为线性复杂度（构造/析构）
If a reallocation happens, the reallocation is itself up to linear in the entire vector size.
如果发生重分配,重分配将复制整个数组到新数组也将需要线性时间//好像不太对。。。。
Iterator validity
In case the container shrinks, all iterators, pointers and references to elements that have not been removed remain valid after the resize and refer to the same elements they were referring to before the call.
假设是收缩的情况下，所有的迭代器，指针以及引用在resize之后并不会移动，因此都保此有效，都指向之前其所指向的元素。
If the container expands, the end iterator is invalidated and, if it has to reallocate storage,
all iterators, pointers and references related to this container are also invalidated.
如果使扩展的情况，那么超尾迭代器将变得无效，并且如果发生了重分配（超出了capacity），那么所有的迭代器，指针以及引用都将失效。
Data races
The container is modified.
If a reallocation happens, all contained elements are modified.
Otherwise, none of the elements before n is accessed, and concurrently accessing or modifying them is safe.
容器将被修改。
如果发生重分配，容器内所有元素都将被修改（这里修改的是地址么？）；
否则，前n个元素不会被访问，同时访问以及修改他们都是安全的。
Exception safety
If n is less than or equal to the size of the container, the function never throws
exceptions (no-throw guarantee).
如果n小于或者等于容器的size,那么不会抛出异常。
If n is greater and a reallocation happens, there are no changes in the container in case of exception (strong guarantee) if the type of the elements is either copyable or no-throw moveable.
如果n大于容器的size，并且发生了重分配，如果元素的复制构造器以及移动构造器都不会抛出异常，那么其抛出异常的规则不变。//这句翻译的不太好。
Otherwise, if an exception is thrown, the container is left with a valid state (basic guarantee).
否则，如果抛出一个异常，容器将留在一个有效的状态？？？还是将这个异常留给
//翻译的不好的地方请多多指导，可以在下面留言或者点击左上方邮件地址给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。
转载请注明出处：http://blog.csdn.net/qq844352155
2014-8-13
于GDUT