【语法】C++的vector

青瓦梦滋2025-03-25 9:13

目录

默认成员函数

迭代器

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个，分别是构造函数，拷贝构造函数，析构函数和赋值运算符重载函数

cpp 复制代码 
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也可以尾插

cpp 复制代码 
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中的数据总个数

cpp 复制代码 
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)迭代器

普通迭代器：

cpp 复制代码 
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

cpp 复制代码 
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

cpp 复制代码 
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)迭代器:

cpp 复制代码 
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接口，分别用来调用该对象所存储的数据个数和容量

cpp 复制代码 
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增长策略是怎么样的呢？

cpp 复制代码 
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:

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

cpp 复制代码 
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大：

cpp 复制代码 
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小：

cpp 复制代码 
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:

cpp 复制代码 
vector<int> v;
for (int i = 0; i < 10; i++)
	v.push_back(i);
v[10] = 2;

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

但如果用at接口呢

cpp 复制代码 
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是尾删数据

cpp 复制代码 
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的第一个参数是传的迭代器

cpp 复制代码 
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一样直接传无参了

cpp 复制代码 
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

cpp 复制代码 
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函数)，第三个形参则是要找的数据

cpp 复制代码 
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函数底层是用快排实现的)

cpp 复制代码 
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;
}

输出结果：

相关推荐
她说彩礼65万5 小时前
WPF Binding方式详解
java·开发语言·wpf
佚明zj6 小时前
【C++】内存模型分析
开发语言·前端·javascript
鹿九丸7 小时前
STL之list
服务器·c语言·c++·windows·list
嘤国大力士7 小时前
C++11&QT复习 （五）
数据库·c++·qt
爽帅_8 小时前
【C++】STL库_list 的模拟实现
开发语言·c++
二十雨辰8 小时前
[学成在线]07-视频转码
java·开发语言·mysql
yngsqq8 小时前
加载dll插件自动提示文字信息——cad c#二次开发
开发语言·c#
郭涤生8 小时前
第10章:优化数据结构_《C++性能优化指南》notes
数据结构·c++·笔记·性能优化
kanhao1009 小时前
Python中的 `super().__init__()` 详解
开发语言·python
还是鼠鼠9 小时前
认识 Express.js：Node.js 最流行的 Web 框架
开发语言·前端·javascript·vscode·node.js·json·express
热门推荐
01第五章 动态规划02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04苍穹外卖面试总结05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06如何在WPS和Word/Excel中直接使用DeepSeek功能072024广东省职业技能大赛云计算赛项实战——Ansible部署Zabbix08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑10SQL 集合运算