当前位置： 首页 > news >正文

【语法】C++的vector

news 来源：原创 2025/5/3 14:23:26

目录

默认成员函数

迭代器

 vector的扩容：

reserve:

resize:

at:

 增删：

push_back和pop_back

 insert和erase

查改：

find:

​编辑

sort: 

在C语言中，想要存储非连续的数据，通常会用数组(array)，例如int arr[20]，arr中就可以存储20个int类型数据，但arr这个数组它的上限就永远是20，不会动态增长。

在C++中，STL中的vector容器就很好的弥补了这点，它是一个可以动态增长的顺序表容器，本篇文章会说明vector最常用的十几种接口函数

默认成员函数

vector的默认成员函数有4个，分别是构造函数，拷贝构造函数，析构函数和赋值运算符重载函数

vector<int> v1;//默认构造函数
vector<int> v2(114, 514);//将114个514存入v2(不常用，了解即可)

vector<int> v3(v2);//拷贝构造函数

vector<int> v4;
v4 = v3;//赋值运算符重载

和string的默认成员函数大差不差

那么string和vector<char>有什么区别呢？

他们两者都是用来存储字符的数组，但string一般是用来存储一串连续的数据，而vector一般用来存储不连续的多个数据

例如，当你想要存储40个人的身份证号时，可以用40个string对象分别存储，而存储40个人的年龄时，就可以用一个vector来存储

这也说明了为什么vector里没有<<和>>，append这种运算符重载函数，因为vector不需要，能用到这两种运算符重载的数据都会去选择string

和string一样，vector也可以尾插

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);

 上述代码就是将1,2,3,4依次尾插到v1中

迭代器

对于vector，有3种方法可以输出其中的数据

1.operator[]+size()

vector也是支持[]重载的

再加上size()函数用来读取vector中的数据总个数

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
for (int i = 0; i < v1.size(); i++)
{
    cout << v1[i] << " ";
}

输出结果：

2.迭代器

对于每个STL中的容器都有迭代器，vector当然也不例外

迭代器一共有三种类型，分别是普通迭代器，反向迭代器和只读(const)迭代器

普通迭代器：

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::iterator it = v1.begin();
while(it != v1.end())
{
    cout << *it << " ";
    it++;
}

输出结果和上面的一样 

vector<int>::iterator 就是int类型的vector的迭代器类型

begin和end分别返回的是该对象起始位置和结束位置的迭代器

3.范围for

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
for(auto e : v1)
{
    cout << e << " ";
}

 输出和上面的一样

范围for本质上还是迭代器，auto e中的auto就会被替换成后面v1的迭代器类型，即vector<int>::iterator，并赋值成v1.begin()，它会自动加加，直到==v1.end()。

迭代器不仅可以正向遍历，还可以反向遍历

反向迭代器：

rbegin和rend也就是reverse_begin和reverse_end的意思，即翻转之后的begin和end

但可以看到，他们的返回值类型都是reverse_iterator，即翻转后的迭代器类型

所以直接将一个普通的迭代器变量复制成rbegin会报错

这时候就要用到上面提到的reverse_iterator

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::reverse_iterator rit = v1.rbegin();//反向迭代器
while(rit != v1.rend())
{
    cout << *rit << " ";
    rit++;
}

输出结果：

 只读(const)迭代器:

void printv(const vector<int>& v)
{
    vector<int>::const_iterator cit = v.begin();
    while(cit != v.end())
    {
        cout << *cit << " ";
        cit++;
    }
}
int main()
{
    vector<int> v1;//默认构造函数
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    printv(v1);
 }

就好比上面这个程序，我的printv函数的参数是const vector<int>&类型，这是因为一般来说传参都喜欢用&用来提高效率，而为了防止改变原数据，又会在前面加上const，在这种情况下， 想要用普通迭代器的话会报错，因为这就属于权限放大了，由const变成了非const(具体可以去搜权限放大缩小问题)。

对于这种情况，就需要用到const_iterator

除此之外，迭代器的反向和只读特性还可以同时拥有，即const_reverse_iterator，只读反向迭代器

 假设有个vector对象是vec：

 vector的扩容：

和string一样，vector也有size和capacity接口，分别用来调用该对象所存储的数据个数和容量

vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
cout << v1.size() << endl << v1.capacity() << endl;

输出结果： 

 也就是说size是5，capacity是8，那么vector的capacity增长策略是怎么样的呢？

void Test()
{
    size_t sz;
    vector<int> v;
    sz = v.capacity();
    cout << "capacity的变化:\n";
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
        }
    }
}

该函数用于测试逐个插入数据直到100，capacity的变化

输出结果(VS环境)：

 

可以看到规律大概是1.5倍，只不过会向下取整

但如果换到别的环境下测试，例如Linux和GCC编译器：

现在的增长策略又是2倍了

不同环境下的增长策略不一样，那么到底是1.5倍的策略更好还是2倍的策略更好？ 

如果把插入的数据从100改到1067,就会发现2倍的扩容会浪费更多的空间

 但是2倍的又比1.5倍的扩容次数要少，所以说各有千秋

1.5倍不浪费空间，但浪费时间

2倍不浪费时间，但浪费空间

reserve:

前面说到不断的开辟更大的空间会消耗很多时间，那有没有什么办法可以提高效率呢？

void Test()
{
    size_t sz;
    vector<int> v;
	v.reserve(1066);//在插入数据之前开辟好1066个空间
    sz = v.capacity();
    cout << "capacity的变化:\n";
    for (int i = 0; i < 1066; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
        }
    }
}

输出结果：

可以看到，这次capacity就没有变化了

这是因为上面代码在原来的基础上加了一行v.reserve(1066)，就直接把对象v的容量一次性扩到了1066，自然就不需要再额外扩容了 

resize:

reserve是可以开辟到更大的容量，而resize是将值增长或减少到一个值，也就是val，如果不给，默认就是0

若n比原本的size大：

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
	vector<int> v;
	for (int i = 0; i < 5; i++)
	{
		v.push_back(i);
	}
	v.resize(10);
	print(v);
	cout << v.capacity() << endl;
	v.resize(15,114);
	print(v);
	cout << v.capacity() << endl;
	return 0;
}

输出结果:

一开始v有5个数据，后面resize到了10个，而且没有指定val的值，所以默认就是0，第一行的后面就多了5个0，第二行输出的是当前capacity，可以看到是10

后面就resize成了15，但这次指定了val是114，所以第三行输出后面就又跟了5个114，第四行输出的是当前capacity，可以看到是20。即：若capacity超出，也会自动扩容capacity

若n比原来的size小：

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
	vector<int> v;
	for (int i = 0; i < 15; i++)
	{
		v.push_back(i);
	}
	v.resize(10);
	print(v);
	cout << v.capacity() << endl;
	v.resize(5);
	print(v);
	cout << v.capacity() << endl;
	return 0;
}

输出结果：

可以看到，当n小于当前size时，会直接删除n后面的数据，但capacity不会缩小

at:

vector<int> v;
for (int i = 0; i < 10; i++)
	v.push_back(i);
v[10] = 2;

上面所示代码中，v有10个元素，下标到9，但我调用了v[10]，这里就非法访问了

但如果用at接口呢

vector<int> v;
for (int i = 0; i < 10; i++)
	v.push_back(i);
v.at(10) = 2;

可以看到，虽然也报了错，但这是报的异常，只要补异常就不会报错了

 增删：

push_back和pop_back

push_back一开始已经讲过，就是尾插数据

pop_back是尾删数据

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.pop_back();
    print(v);
    return 0;
}

输出结果：

 insert和erase

 可以发现vector的insert和string的不一样，vector的第一个参数是传的迭代器

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.insert(v.begin(), 0);//头插一个元素
    v.insert(v.begin(),-1);//头插一个元素
    v.insert(v.end(), 5);//尾插一个元素
    print(v);
    return 0;
}

输出结果：

 可以看到，erase传的也是迭代器

因为没有缺省值，所以就不能再像string一样直接传无参了 

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.insert(v.begin(), 0);//头插一个元素
    v.insert(v.begin(),-1);//头插一个元素
    v.insert(v.end(), 5);//尾插一个元素
    v.erase(v.begin());//头删
    v.erase(v.end());//尾删
    print(v);
    return 0;
}

可以看到先头删再尾删，看着没有问题

但实际上会出现内存错误

这是因为end()迭代器是返回的最后一个数+1的位置，这个位置是没有元素的

所以要尾删的话，需要传end()-1

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.insert(v.begin(), 0);//头插一个元素
    v.insert(v.begin(),-1);//头插一个元素
    v.insert(v.end(), 5);//尾插一个元素
    v.erase(v.begin());//头删
    v.erase(v.end()-1);//尾删
    print(v);
    return 0;
}

输出结果： 

查改：

find:

虽然vector里没有find函数(string里有)，但std,即全局中，有find函数，这是算法里的，包含于<algorithm>头文件(这个单词翻译过来就是算法的意思)

可以看到三个形参中，前两个形参是迭代器类型，分别表示起始位置和结束位置，需要特别注意的是，只要是这种传迭代器区间的形参，都传的是左闭右开区间(包括下面要讲到的sort函数)，第三个形参则是要找的数据

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    vector<int>::iterator pos = find(v.begin(), v.end(), 5);//左闭右开区间
    if(pos != v.end())//用来判断是否找到
    {
        v.erase(pos);
    }
    print(v);
    return 0;
}

输出结果：

那么代码中下面的if判断是怎么来判断是否找到的呢？

这是find函数的具体实现，可以发现，若这个左闭右开区间内没有找到，最后返回是last，也就是第二个参数(开区间的迭代器)，所以pos只要不等于开区间的迭代器，就代表找到了

sort: 

本篇就先只介绍第一行的sort，两个形参也是左闭右开的迭代器类型(sort函数底层是用快排实现的)

void print(const vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

int main()
{
    vector<int> v;
    v.push_back(3);
    v.push_back(1);
    v.push_back(6);
    v.push_back(8);
    v.push_back(7);
    v.push_back(9);
    v.push_back(4);
    v.push_back(6);
    sort(v.begin(), v.end());//传左闭右开区间
    print(v);
    return 0;
}

输出结果：

相关文章：

  • 芋道uniapp用户端
  • scNET：整合scRNA-seq和PPI用于学习基因和细胞的embedding
  • ecovadis评级的认可性
  • SpringBoot 开发入门—Springboot基础框架汇总
  • CI/CD(五) 安装helm
  • 【秣厉科技】LabVIEW工具包——OpenCV 教程（12）：机器学习
  • 【一起学Rust | Tauri2.0框架】深入浅出 Tauri 2.0 应用调试：从新手到专家的蜕变
  • 企业建设——访问控制模型
  • python如何随机选取n个不同的数字
  • ESP32-C3物联网方案，智能设备创新升级，无线交互控制通信应用
  • Off-Road-Freespace-Detection配置pytorch2.0.0
  • 数据库概述
  • 合宙780E开发学习-Lua语法速查
  • vector和list区别
  • 个股场外期权参与条件有哪些要求？
  • Android 系统进程启动Activity方法说明
  • 一步部署FTP虚拟用户
  • ES数据过多，索引拆分
  • SBOM风险预警 | 恶意NPM组件开展木马投毒攻击，目标针对国内泛互企业
  • 前端面试整理
  • 长三角铁路今日预计发送418万人次，持续迎来出行客流高峰
  • 2025五一档首日电影票房破亿
  • 5月起，这些新规将施行
  • “面具女孩”多次恐吓电梯内两幼童，当事女孩及家长道歉后获谅解
  • 智能终端出海服务创新联合体成立
  • 住房和城乡建设部办公厅主任李晓龙已任部总工程师