C++核心编程(三十)容器(vector)

vector容器的构造

1)默认无参构造
2）区间构造:将另一个vector的区间的值赋值个新创建的vector从而构造
3）以化n个elem初始化构造
4）拷贝构造：将另外一个vector容器的值复制一份给新创建的vector

#include
#include
using namespace std;
void init_v4_(vector<int> &v4_i_,int i)
{
      v4_i_[0]=5-i;//相当于v4[i][0]
      v4_i_[1]=i;//相当于v4[i][1]
        
}
int main()
{
    vector<int> v;//默认无参构造
    for(int i=0;i<10;i++)
    {
       v.push_back(i);
    }

    vector<int> v1(v.begin(),v.end());//区间构造，[v.begin(),v.end());
    for(int i=0;i<10;i++)
    {
        cout<<*(v1.begin()+i)<<endl;
    }

    vector<int> v2(10,1);//赋值n个elem的方式构造；这里设置的n=10,elem=1；

     for(int i=0;i<10;i++)
    {
        cout<<*(v2.begin()+i)<<endl;
    }

    vector<int>v3(v2);//拷贝构造
      for(int i=0;i<10;i++)
    {
        cout<<*(v3.begin()+i)<<endl;       
    }

    vector<vector<int>> v4(5,vector<int>(2,1));//构造一个5行2列，初始值全为一的容器
        for(int i=0;i<5;i++)
        {
            init_v4_(*(v4.begin()+i),i);//*(v4.begin()+i)相当于v4[i];
            cout<<"v4_0"<<v4[i][0]<<endl;
          cout<<"v4_1"<<v4[i][1]<<endl;
        }
       


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

vector容器的插入和删除

	vector<int> v;
	int pos=0;
    int elem=6;
    int count=3;
    int start=0;
    int end=1;
1
2
3
4
5
6

1）尾插法： v.push_back(elem);//尾部插入元素
2)尾删法: v.pop_back();//尾部删除最后一个元素
3)向pos位置插入elem元素:v.insert(v.begin()+pos,elem);//向pos的位置插入元素elem
4)向pos位置插入n个elem元素:v.insert(v.begin()+pos,count,elem);//向pos的位置插入count个elem元素
5)删除pos的位置的元素: v.erase(v.begin()+pos);//删除pos位置的元素
6)删除[star,end)区间的元素:v.erase(v.begin()+start,v.begin()+end);//删除[start,end)区间的元素,注意是左闭右开
7)清空元素:v.clear();//清空容器

#include
#include
using namespace std;
int main()
{
    int pos=0;
    int elem=6;
    int count=3;
    int start=0;
    int end=1;
    vector<int> v;
    v.push_back(1);//尾部插入元素
    v.pop_back();//尾部删除最后一个元素
    v.insert(v.begin()+pos,elem);//向pos的位置插入元素elem
    v.insert(v.begin()+pos,count,elem);//向pos的位置插入count个elem元素
    v.erase(v.begin()+pos);//删除pos位置的元素
    v.erase(v.begin()+start,v.begin()+end);//删除[start,end)区间的元素,注意是左闭右开
    v.clear();//清空容器
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

vector容器中的访问

 	int n=0;
  vector<int> v;
1
2

1）通过at函数访问：v.at(n)//通过at函数访问，返回第n个元素
2)通过重载运算符[]访问:v[n]//通过重载运算符[]访问,返回第n个元素
3)通过front函数访问:v.front()//通过front函数访问，返回首元素
4)通过back函数访问v.back()//通过back函数访问，返回尾元素

#include
#include
using namespace std;
int main()
{
    int n=0;
    vector<int> v;
    v.push_back(1);
    cout<<v.at(n)<<endl;//通过at函数访问，返回第n个元素
    cout<<v[n]<<endl;//通过重载运算符[]访问,返回第n个元素
    cout<<v.front()<<endl;//通过front函数访问，返回首元素
    cout<<v.back()<<endl;//通过back函数访问，返回尾元素

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

vector容器的互换

vector<int> v1;
vector<int> v2;
1
2

1）将v1,v2容器互换:v1.swap(v2)

测试例子:

#include
#include
using namespace std;
int main()
{
    vector<int> v1;
    vector<int> v2;
    for(int i=0;i<2;i++)
    {
    v1.push_back(i);
    v2.push_back(1-i);
    }
    for(int i=0;i<2;i++)
    {
    cout<<"v1 "<<i<<"  "<<v1[i]<<endl;
    }
     for(int i=0;i<2;i++)
    {
    cout<<"v2 "<<i<<"  "<<v2[i]<<endl;
    }
    v1.swap(v2);

   for(int i=0;i<2;i++)
    {
    cout<<"v1 "<<i<<"  "<<v1[i]<<endl;
    }
    for(int i=0;i<2;i++)
    {
    cout<<"v2 "<<i<<"  "<<v2[i]<<endl;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

应用场景：收缩内存

#include
#include
using namespace std;
int main()
{
    vector<int> v;
    for(int i=0;i<1000;i++)
    {
        v.push_back(i);
    }
    //容器的容量是动态扩展的，可能比实际存放的数据所占内存大；
    //而且是一片连续的空间，当原来的空间不满足的时候重新寻找新的一片空间，不一定会在原来位置上扩展
    cout<<"v的容量"<<v.capacity()<<endl;
    cout<<"v的大小"<<v.size()<<endl;
	v.resize(3);//重新指定容器的大小；如果容器位置上原来不存在元素，会初始化元素为0；
				//注意是指定大小不是容量；
    cout<<"v的容量"<<v.capacity()<<endl;
    cout<<"v的大小"<<v.size()<<endl;
    vector<int>(v).swap(v);//通过和匿名对象进行容器互换实现收缩内存；匿名对象的生命周期只在本行
    cout<<"v的容量"<<v.capacity()<<endl;
     cout<<"v的大小"<<v.size()<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

vector的预留空间

预留空间可以减少内存动态扩展的次数
1）预留空间:v.reserve(n);//预留空间中内存无法直接访问，不会自己初始化；

下面有两个检测内存动态扩展次数的例子:
例1：原理是检测容量是否变化
例2：原理是检测容器首地址是否发生变化；
例1：

#include
#include
using namespace std;
int main()
{
    int num=0;
    vector<int> v;
    int temp=v.capacity();
    for(int i=0;i<1000;i++)
    {
        v.push_back(i);
        if(v.capacity()!=temp)
        {
            temp=v.capacity();
            num++;
        }
    }
      cout<<num<<endl;
}
打印结果为11；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

例2：

#include
#include
using namespace std;
int main()
{
    int num=0;
    int *p=NULL;
    vector<int> v;
    for(int i=0;i<1000;i++)
    {
        v.push_back(i);
        if(p!=&v[0])
        {
            p=&v[0];
            num++;
        }
    }
      cout<<num<<endl;
}
打印结果为11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

下面是测试使用reserve的例子:

#include
#include
using namespace std;
int main()
{
    int num=0;
    vector<int> v;
    int temp=v.capacity();
    v.reserve(1000);
    for(int i=0;i<1000;i++)
    {
        v.push_back(i);
        if(v.capacity()!=temp)
        {
            temp=v.capacity();
            num++;
        }
    }
      cout<<num<<endl;
}
打印结果为1；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21