vector（动态容器）

vector（动态容器）

1–容器的创建

#include <iostream>
#include <vector>
#include<array>
using namespace std;

int main()
{
    // 1-容器创建
//  a ---不带长度的创建
    vector<int> object_1; 

    //在创建了空容器后可以使用reserve,     容器的容量是动态分配的
    object_1.resize(100);
    object_1.reserve(20);
    /*这样就设置了容器的内存分配，即至少可以容纳 20 个元素。注意，如果 vector 的容量在执行此语句之前，
    已经大于或等于 20 个元素，那么这条语句什么也不做；另外，调用 reserve() 不会影响已存储的元素，
    也不会生成任何元素，即 values 容器内此时仍然没有任何元素。
    */

    cout << "容量   "<<object_1.capacity() << "大小  " << object_1.size() << endl;
    cout << "**************" << endl;
    object_1.reserve(200);
    object_1.resize(100);
    cout << object_1.capacity() << "  " << object_1.size() << endl;

     //b-----带长度的创建,默认初始化为0
    vector<int> object_2(100);
    // vector<int>object_4(5,3);//第二个参数指定初始化的值，第一个值指定初始化值的个数 ，这两个参数可以是变量
   //c-----带初始化的创建
    vector<int> object_3{1, 2, 3, 4, 5, 6, 7}; 

    //d------通过存储元素类型相同的其它 vector 容器，也可以创建新的 vector 容器，例如：
    vector<int> object_4(object_3);
    cout << "i4 :  ";
    for (auto i4 : object_4)
    {
        cout << i4 << "  ";
    }


    //e--------在此基础上，如果不想复制其它容器中所有的元素，可以用一对指针或者迭代器来指定初始值的范围，例如：
    vector<int> object_5(object_3.begin(), object_3.begin() + 3);
    cout << endl;
    cout << "i5 :  ";
    for (auto i5 : object_5)
    {
        cout << i5 << "  ";
    }


    cout << endl;
    cout << "i7 :  ";
    array<int,3>a_1{1,2,3};
    array<int,3>a_2{4,5,6};
    // vector<int >object_7(a_2);//对于vector以外的容器，不能使用拷贝构造，但可以使用迭代器或者指针 
    vector<int >object_7(a_1.begin(),a_1.begin()+3);
        for (auto i7 : object_7)
    {
        cout << i7 << "  ";
    }
object_3.begin(), object_3.begin() + 3);
  cout << endl;
    cout << "i8 :  ";
 //采用指针---从数组中获得初值
int b[7]={1,2,3,4,5,6,7};
vector<int> object_8(b,b+7);
      for (auto i8 : object_8)
    {
        cout << i8 << "  ";
    }
    //f---------对于空的容器，不能使用迭代器初始化,
     cout << endl;
    cout << "i6 :  ";
    vector <int>object_6;
    for(auto i6=object_6.begin();i6!=object_6.end();i6++)
    {
      *i6=*i6++;
      cout<<*i6;

    }//可见没有打印结果。

}

2 -容器的初始化

//对于不带长度的创建，只能采取push_back（）,进行尾插
//初始化
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    vector<string> str;
    // for(auto i=str.begin();i<str.end();i++)//空容器不能使用迭代器，
    // {
    //     str.push_back("aaa  ");
    // }
//    for (auto ii : str)
//    cout << ii << "   ";

// for(auto i: str)//本质也是迭代器
// {
//     str.push_back("aaa");
// }
//    for (auto ii : str)
//    cout << ii << "   ";
    for (int i = 0; i < 3; i++) 
    {
        str.push_back("aaa  " + to_string(i));
    }

   for (auto ii : str)
   cout << ii << "   ";


cout<<endl;
//带长度的容器初始化，可以使用数组的方式,超出长度的初始化需要通过push_back()方法
vector<int >num(5);
for(int i=0;i<num.size();i++)
{
    num[i]=i;
}
   for (auto ii : num)
   cout << ii << "   ";
}

3-vector容器的操作

#include<vector>
vector<int> a,b;
//b为向量，将b的0-2个元素赋值给向量a
a.assign(b.begin(),b.begin()+3);
//a含有4个值为2的元素
a.assign(4,2);
//返回a的最后一个元素
a.back();
//返回a的第一个元素
a.front();
//返回a的第i元素,当且仅当a存在
a[i];
//清空a中的元素
a.clear();
//判断a是否为空，空则返回true，非空则返回false
a.empty();
//删除a向量的最后一个元素
a.pop_back();
//删除a中第一个（从第0个算起）到第二个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）结束
a.erase(a.begin()+1,a.begin()+3);
//在a的最后一个向量后插入一个元素，其值为5
a.push_back(5);
//在a的第一个元素（从第0个算起）位置插入数值5,
a.insert(a.begin()+1,5);
//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
a.insert(a.begin()+1,3,5);
//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）
a.insert(a.begin()+1,b+3,b+6);
//返回a中元素的个数
a.size();
//返回a在内存中总共可以容纳的元素个数
a.capacity();
//将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10);
//将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.resize(10,2);
//将a的容量扩充至100，
a.reserve(100);
//b为向量，将a中的元素和b中的元素整体交换
a.swap(b);
//b为向量，向量的比较操作还有 != >= > <= <
a==b;
//替换下标为2的元素
a.emplace(a.begin()+2,100);
//和push_back()相似的尾部插入的函数。但是效率快
a.emplace_back()
 

注意：vector的插入和删除的position 左闭右开，右边的位置是不被包括的

vector 使用resize 方法和reserve方法之后，会销毁旧的空间，所以迭代器的值会改变，所以要重新定义一次迭代器的指向

#include <iostream>
using namespace std;
#include <vector>
int main()
{

    vector<int> aa{1, 2, 3, 4, 5};
    auto i = aa.begin();
    auto j = aa.end();
    while (i != j)
    {
        cout << *i << " ";
        i++;
    }
     aa.resize(8);//额外增加的三个数据初始化为0
    //aa.reserve(8);//不会改变原有数据


cout<<endl<<"***************"<<endl;


    auto ii = aa.begin();//重新定义迭代器
    auto jj = aa.end();
    while (ii != jj)
    {
       cout << *ii << " ";
        ii++;
    }
}

vector的swap方法只能交换同样类型大小的vector容器

4-利用swap函数收缩大小（resize方法多删少补，但删去一个元素之后，其容量不会变小）

#include <iostream>
using namespace std;
#include <vector>
void print(vector<int>&vv)
{
    cout<<"容量" <<vv.capacity()<< "大小："<<vv.size()<<endl;
}
int main()
{
  
 vector<int> aa{1, 2, 3, 4, 5};
 print(aa);
aa.resize(8);
 print(aa);
aa.pop_back();aa.pop_back();aa.pop_back();aa.pop_back();aa.pop_back();aa.pop_back();
 print(aa);
vector<int>(aa).swap(aa);//匿名对象会根据对象aa实际的大小拷贝一个匿名对象，然后匿名对象的大小就是实际的size，然后匿名对象调用swap函数，交换实际的空间，完成空间的收缩，匿名对象的生命结束，交换后的空间销毁。
    //这里也可以使用 aa.shrink_to_fit();将内存减少到等于当前元素实际所使用的大小。
 print(aa);
}

//输出结果
容量5大小：5
容量10大小：8
容量10大小：2
容量2大小：2

5-利用reserve预留空间提高程序效率

#include <iostream>
using namespace std;
#include <vector>
void print(vector<int>&vv)
{
    cout<<"容量" <<vv.capacity()<< "大小："<<vv.size()<<endl;
}
int main()
{
  

vector<int>aa;
// aa.reserve(100000);
int *address=nullptr;
int num=0;

for(auto i=0;i<100000;i++)
{
aa.push_back(99);
if((&aa[0]!=address))
{
address=&aa[0];
num++;
}

}

cout<<num;
}
//num的输出结果是18，可见容器aa的地址改变了18次，也就是经历了18次扩大容量
//我们一开始就使用reserve方法预留一定大小的空间，就不必在运行时多次扩容.

6-vector的常用算法

 #include<algorithm>
 //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
 sort(a.begin(),a.end());
 //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
 reverse(a.begin(),a.end());
  //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
 copy(a.begin(),a.end(),b.begin()+1);
 //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
  find(a.begin(),a.end(),10);


使用sort排序：需要头文件#include<algorithm>，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
    return a>b;
}
调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。 

7-用swap方法强行释放STL Vector所占内存

template < class T> void ClearVector( vector<T>& v )
{
  vector<T>vtTemp;
  vtTemp.swap( v );
}
如
  vector<int> v ;
  nums.push_back(1);
  nums.push_back(3);
  nums.push_back(2);
  nums.push_back(4);
  vector<int>().swap(v);