C++ vector声明和赋值的相关函数

简介: C++ vector声明和赋值的相关函数

定义


  向量(Vector)是一个封装了动态大小数组的顺序容器(Sequence Container)。跟任意其它类型容器一样,它能够存放各种类型的对象。可以简单的认为,向量是一个能够存放各种类型的动态数组。



容器特性


1.顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。


2.动态数组

 支持对序列中的任意元素进行快速直接访问,甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。


3.能够感知内存分配器的(Allocator-aware)

 容器使用一个内存分配器对象来动态地处理它的存储需求。



赋值操作

  与容器vector操作相关的函数有很多,函数的目录和简介请点这里《vector相关函数简介》:

#include <iostream>
#include <vector>
#define test(v) {\
  cout<<".size():"<<v.size()<<endl;\
  cout<<".empty():"<<v.empty()<<endl;\
  cout<<".capacity():"<<v.capacity()<<endl;\
  for (auto a:v) cout<<a<<" ";\
  cout<<endl<<endl;\
  }
using namespace std;
int main(void)
{
  vector <int> v; //创建一个存放整型数据的空向量 
  test(v);
  vector <int> va(5); //创建整型数据向量,容量大小5 
  test(va);
  cout<<".max_size():"<<v.max_size()<<endl; //最大容纳元素个数
        //在32/64bit机器上值不同,int/double/string各不相同 
/*1.下标方式 */ 
  va[0]=1;  //声明时指定大小,才能像数组一样赋值 下标 0~4 
  va[1]=2;  //未赋值前元素都是 0 即va[2]va[3]va[4]=0 
  //va[12]=11;  //下标超出指定个数,编译不报错但程序可能会崩溃退出 
  test(va);
/*2.push_back()函数 */ 
  va.push_back(100); //追加一个数100,即va[5]=100,size增1 
  test(va);
  va.resize(11); //重新设置大小大于原值,新值被赋0 
  test(va);
  va.resize(6); //重新设置大小小于原值,弃用多余的元素 
  test(va);
  va.push_back(88); //追加一个数
  va.resize(11); //重新设置大小大于原值,之前弃用的元素可能还在 
  test(va);
  va.push_back(1234);  //追加一个数
  va.push_back(56789);  //追加一个数
  test(va);
  cout<<"============="<<endl;
  vector <string> vb;  //如果声明时不指定大小,不能用下标法赋值 
  test(vb);   
  //vb[0]="c++";  //此时如用下标赋值,程序出错崩溃退出
  vb.push_back("hello"); //size自动增一 
  vb.push_back("c++"); 
  test(vb);
  cout<<".max_size():"<<vb.max_size()<<endl<<endl;
  vb[1]="python"; //此时下标也不能超限 
  test(vb);
/*3.指定相同初值 */  
  vector <int> vc(5,1); //创建容器元素个数为 5,且值均为 1
  test(vc);
/*4.从其它容器复制全部或部分 */   
  vector<int> vd(va); //拷贝va全部元素,也即 (va.begin(),va.end()) 
  test(vd);
  vector<int> ve(va.begin()+5,va.begin()+12); //拷贝7个:va[5]~va[11]
  test(ve);
  vector<int> vf(va.end()-3,va.end()); //拷贝3个:va[11]~va[13]
  test(vf);
/*5.从同类型数组中复制全部或部分 */ 
  int arr[]={0,1,2,3,4,5,6,7,8,9};
  vector<int> vg(arr,arr+3); //从同类型数组中拷贝3个:arr[0]~arr[2]
  test(vg);
  int len=sizeof(arr)/sizeof(arr[0]); //len==10 
  vector<int> vh(arr+6,arr+len); //拷贝4个:arr[6]~arr[9]
  test(vh); 
  //容器、数组的注意起始下标都是0,复制地址区间:“左向左开右闭,右向反之”
  //右向查找 rbegin rend  rbegin=左向的end-1 rend=左向的begin-1
    //或者直接:vector<int> vg={0,1,2,3,4,5,6,7,8,9}; //等于号=可有可无
/*6.insert()函数 */ 
  vector<int> vi; //从其他容器中取数,插入 
  vi.insert(vi.begin(), va.begin(), va.begin() + 4); //拷贝4个:va[0]~va[3]
  test(vi);
  vector<int> vj; //从其他数组中取数,插入 
  vj.insert(vj.begin(), arr+2,arr+8); //拷贝6个:arr[2]~arr[7]
  test(vj);
    //补充:insert(vj.begin()+1,3,2) //在第一元素后插入3个2
/*7.copy()函数 */ 
  vector<int> vk(10); //copy()的目标容器不能为空,需先分配空间且至少>0 
  copy(va.begin(), va.begin() + 4,vk.begin()); //拷贝4个:va[0]~va[3]
  test(vk);
  vector<int> vl;
  vl.reserve(8); //用reserve()预留空间,并不创建空间 
  test(vl);
  copy(arr+2,arr+8,vl.begin()+2); //依旧copy不成功,但程序不会崩溃 
  test(vl);
  vl.insert(vl.begin(),arr,arr+9); //先准备点空间 
  test(vl);
  copy(arr+2,arr+6,vl.begin()+3); //copy成功,并覆盖原来位置上的值 
  test(vl);
/*8.assign()函数 */ 
  vector<int> vm;
  vm.assign(10,2);   //分派10个都为2的元素
  test(vm);
  vm.assign(vl.begin(), vl.begin()+6);  //或从其它容器中分派,覆盖方式 
  test(vm);
  vm.assign(vl.begin()+2, vl.end()); 
  test(vm);
    return 0;
}


运行结果如下:

.size():0
.empty():1
.capacity():0
.size():5
.empty():0
.capacity():5
0 0 0 0 0
.max_size():4611686018427387903
.size():5
.empty():0
.capacity():5
1 2 0 0 0
.size():6
.empty():0
.capacity():10
1 2 0 0 0 100
.size():11
.empty():0
.capacity():12
1 2 0 0 0 100 0 0 0 0 0
.size():6
.empty():0
.capacity():12
1 2 0 0 0 100
.size():11
.empty():0
.capacity():12
1 2 0 0 0 100 88 0 0 0 0
.size():13
.empty():0
.capacity():24
1 2 0 0 0 100 88 0 0 0 0 1234 56789
=============
.size():0
.empty():1
.capacity():0
.size():2
.empty():0
.capacity():2
hello c++
.max_size():2305843009213693951
.size():2
.empty():0
.capacity():2
hello python
.size():5
.empty():0
.capacity():5
1 1 1 1 1
.size():13
.empty():0
.capacity():13
1 2 0 0 0 100 88 0 0 0 0 1234 56789
.size():7
.empty():0
.capacity():7
100 88 0 0 0 0 1234
.size():3
.empty():0
.capacity():3
0 1234 56789
.size():3
.empty():0
.capacity():3
0 1 2
.size():4
.empty():0
.capacity():4
6 7 8 9
.size():4
.empty():0
.capacity():4
1 2 0 0
.size():6
.empty():0
.capacity():6
2 3 4 5 6 7
.size():10
.empty():0
.capacity():10
1 2 0 0 0 0 0 0 0 0
.size():0
.empty():1
.capacity():8
.size():0
.empty():1
.capacity():8
.size():9
.empty():0
.capacity():9
0 1 2 3 4 5 6 7 8
.size():9
.empty():0
.capacity():9
0 1 2 2 3 4 5 7 8
.size():10
.empty():0
.capacity():10
2 2 2 2 2 2 2 2 2 2
.size():6
.empty():0
.capacity():10
0 1 2 2 3 4
.size():7
.empty():0
.capacity():10
2 2 3 4 5 7 8
--------------------------------
Process exited after 0.5482 seconds with return value 0
请按任意键继续. . .


size和capacity的区别


size()函数返回的是已用空间大小,capacity()返回的是总空间大小,capacity()-size()则是剩余的可用空间大小。当 size()==capacity(),说明 vector 目前的空间已被用完,如果再添加新元素,则会引起 vector 空间的动态增长。



resize和reverse的区别


reserve()只修改capacity大小,不修改size大小;resize()既修改capacity大小,也修改size大小。reserve(n)预先分配一块较大的指定大小的内存空间,这样当指定大小的内存空间未使用完时,是不会重新分配内存空间的,这样便提升了效率。只有当 n>capacity()时,调用 reserve(n)才会改变 vector 容量。resize()成员函数只改变元素的数目,不改变 vector 的容量。



size和max_size的区别


size()是向量的大小,当前存入的元素个数;max_size是此类向量在当前平台上能处理的最大元素个数,存放数据类型不同值就不同,所在平台是32还是64位值也不同。




其他重点摘要:


1. 空的 vector即empty()==true时,size()和 capacity()都为 0。


2. 当空间大小不足时,新分配的空间大小为原空间大小的 2 倍。


3. 使用 reserve()预先分配一块内存后,在空间未满的情况下,不会引起重新分配,从而提升了效率。


4. 当 reserve()分配的空间比原空间小时,是不会引起重新分配的。


5. resize()函数只改变容器的元素数目,未改变容器大小。


6. 用 reserve(size_type)只是扩大 capacity 值,这些内存空间可能还是“野”的,如果此时使用“[ ]”来访问,则可能会越界。而 resize(size_type new_size)会真正使容器具有 new_size 个对象。



目录
打赏
0
0
0
0
74
分享
相关文章
【c++丨STL】vector的使用
本文介绍了C++ STL中的`vector`容器,包括其基本概念、主要接口及其使用方法。`vector`是一种动态数组,能够根据需要自动调整大小,提供了丰富的操作接口,如增删查改等。文章详细解释了`vector`的构造函数、赋值运算符、容量接口、迭代器接口、元素访问接口以及一些常用的增删操作函数。最后,还展示了如何使用`vector`创建字符串数组,体现了`vector`在实际编程中的灵活性和实用性。
114 4
C++ 中 std::array<int, array_size> 与 std::vector<int> 的深入对比
本文深入对比了 C++ 标准库中的 `std::array` 和 `std::vector`,从内存管理、性能、功能特性、使用场景等方面详细分析了两者的差异。`std::array` 适合固定大小的数据和高性能需求,而 `std::vector` 则提供了动态调整大小的灵活性,适用于数据量不确定或需要频繁操作的场景。选择合适的容器可以提高代码的效率和可靠性。
81 0
【c++丨STL】vector模拟实现
本文深入探讨了 `vector` 的底层实现原理,并尝试模拟实现其结构及常用接口。首先介绍了 `vector` 的底层是动态顺序表,使用三个迭代器(指针)来维护数组,分别为 `start`、`finish` 和 `end_of_storage`。接着详细讲解了如何实现 `vector` 的各种构造函数、析构函数、容量接口、迭代器接口、插入和删除操作等。最后提供了完整的模拟实现代码,帮助读者更好地理解和掌握 `vector` 的实现细节。
51 0
在 C++中,realloc 函数返回 NULL 时,需要手动释放原来的内存吗?
在 C++ 中,当 realloc 函数返回 NULL 时,表示内存重新分配失败,但原内存块仍然有效,因此需要手动释放原来的内存,以避免内存泄漏。
|
3月前
|
【C++打怪之路Lv9】-- vector
【C++打怪之路Lv9】-- vector
35 1
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
137 6
|
3月前
|
C++
C++ 多线程之线程管理函数
这篇文章介绍了C++中多线程编程的几个关键函数,包括获取线程ID的`get_id()`,延时函数`sleep_for()`,线程让步函数`yield()`,以及阻塞线程直到指定时间的`sleep_until()`。
54 0
|
3月前
|
C++之打造my vector篇(下)
C++之打造my vector篇(下)
44 0
|
3月前
|
C++之打造my vector篇(上)
C++之打造my vector篇(上)
43 0
|
19天前
|
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
61 19
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等