vector（单端数组）和deque（双端数组）

你好 Future！

已于 2024-06-20 18:25:06 修改

阅读量325

点赞数 8

分类专栏： C++补充知识文章标签： c++ 算法开发语言

于 2024-05-21 10:36:46 首次发布

本文链接：https://blog.csdn.net/Nevadas/article/details/139086268

版权

C++补充知识专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1 vector容器

1.1 基本概念

1.1.1 定义

1.1.2 内部结构

1.2 操作

1.2.1 构造vector

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

void myPrint(vector<int> v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}
void test01() {
	//默认构造
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	myPrint(v);
	cout << "默认构造" << endl;

	//通过区间方式构造
	vector<int> v2(v.begin(), v.end());
	myPrint(v2);
	cout << "通过区间方式构造" << endl;

	//n个elem方式构造
	vector<int> v3(5, 10);
	myPrint(v3);
	cout << "n个elem方式构造" << endl;

	//拷贝方式构造
	vector<int> v4(v3);
	myPrint(v4);
	cout << "拷贝方式构造" << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9 默认构造
0 1 2 3 4 5 6 7 8 9 通过区间方式构造
10 10 10 10 10 n个elem方式构造
10 10 10 10 10 拷贝方式构造

1.2.2 vector的赋值

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

void myPrint(vector<int> v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}

	//方式一：=
	vector<int> v2;
	v2 = v;
	myPrint(v2);
	cout << "方式一：=" << endl;

	//方式二：assign
	vector<int> v3;
	v3.assign(v.begin() + 3, v.end());
	myPrint(v3);
	cout << "方式二：assign" << endl;

	//方式三：n个elem方式赋值
	vector<int> v4;
	v4.assign(5, 10);
	myPrint(v4);
	cout << "方式三：n个elem方式赋值" << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9 方式一：=
3 4 5 6 7 8 9 方式二：assign
10 10 10 10 10 方式三：n个elem方式赋值

1.2.3 容量和大小

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

void myPrint(vector<int> v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	myPrint(v);
	cout << endl;

	if (v.empty()) {
		cout << "v为空" << endl;
	}
	else {
		cout << "v不为空" << endl;
		cout << "v的容量为：" << v.capacity() << endl;
		cout << "v中元素的个数为：" << v.size() << endl;
	}

	//重新指定大小
	v.resize(15);	//如果重新指定长度变长，默认用0填充
	myPrint(v);
	cout << endl;

	v.resize(16, 20);	//如果重新指定长度变长，用elem填充
	myPrint(v);
	cout << endl;

	v.resize(5);		//如果重新指定长度变短，末尾元素删除
	myPrint(v);
	cout << endl;
}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9
v不为空
v的容量为：13
v中元素的个数为：10
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 20
0 1 2 3 4

1.2.4 vector的插入和删除

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

void myPrint(vector<int> v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}

void test01() {
	vector<int> v;

	//尾插
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	myPrint(v);	//10 20 30 40
	cout << endl;

	//插入
	v.insert(v.begin() + 1, 5);
	myPrint(v);	//10 5 20 30 40
	cout << endl;

	v.insert(v.begin() + 1, 5, 3);
	myPrint(v);	//10 3 3 3 3 3 5 20 30 40
	cout << endl;

	//尾删
	v.pop_back();
	myPrint(v);	//10 3 3 3 3 3 5 20 30
	cout << endl;

	//删除指定位置
	v.erase(v.begin() + 1);
	myPrint(v);	//10 3 3 3 3 5 20 30
	cout << endl;

	v.erase(v.begin() + 1, v.begin() + 5);	//不包括end
	myPrint(v);	//10 5 20 30
	cout << endl;

	//清空
	v.clear();
	myPrint(v);
	cout << endl;
}
int main() {
	test01();
	return 0;
}

10 20 30 40
10 5 20 30 40
10 3 3 3 3 3 5 20 30 40
10 3 3 3 3 3 5 20 30
10 3 3 3 3 5 20 30
10 5 20 30

1.2.5 vector数据存取

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

void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	
	//at方式访问
	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << " ";
	}
	cout << endl;
	cout << "at方式访问" << endl;

	//[]方式访问
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << " ";
	}
	cout << endl;
	cout << "[]方式访问" << endl;

	cout << "容器中第一个元素是：" << v.front() << endl;
	cout << "容器中最后一个元素是：" << v.back() << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9
at方式访问
0 1 2 3 4 5 6 7 8 9
[]方式访问
容器中第一个元素是：0
容器中最后一个元素是：9

1.2.6 vector互换容器

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

void myPrint(vector<int> v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}

void test01() {
	vector<int> v;
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
		v1.push_back(10 - i);
	}
	cout << "交换前" << endl;
	myPrint(v);
	cout << endl;
	myPrint(v1);
	cout << endl;

	cout << "交换后" << endl;
	v.swap(v1);
	myPrint(v);
	cout << endl;
	myPrint(v1);

}
int main() {
	test01();
	return 0;
}

交换前
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
交换后
10 9 8 7 6 5 4 3 2 1
0 1 2 3 4 5 6 7 8 9

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

void test01() {
	vector<int> v;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
	}
	
	cout << "v中元素的个数为：" << v.size() << endl;
	cout << "v的容量为：" << v.capacity() << endl;
	
	v.resize(3);
	cout << "重新分配元素个数后" << endl;
	cout << "v中元素的个数为：" << v.size() << endl;
	cout << "v的容量为：" << v.capacity() << endl;

	//巧用swap收缩内存
	vector<int>(v).swap(v);
	cout << "v中元素的个数为：" << v.size() << endl;
	cout << "v的容量为：" << v.capacity() << endl;

}
int main() {
	test01();
	return 0;
}

v中元素的个数为：100000
v的容量为：138255
重新分配元素个数后
v中元素的个数为：3
v的容量为：138255
v中元素的个数为：3
v的容量为：3

1.2.7 vector预留空间

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


void test01() {
	vector<int> v;
	int* p = NULL;
	int num = 0;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num += 1;
		}
	}
	cout << "预留空间前开辟了内存次数为：" << num << endl;

}
void test02() {
	vector<int> v;
	v.reserve(10000);
	int* p = NULL;
	int num = 0;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num += 1;
		}
	}
	cout << "预留空间后开辟了内存次数为：" << num << endl;

}
int main() {
	test01();
	test02();
	return 0;
}

预留空间前开辟了内存次数为：30
预留空间后开辟了内存次数为：7

1.2.8 vector的遍历

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

void myPrint(int val){
	cout << val << endl;
}
void test01(){
	//定义vector
	vector<int> v;
	
	//往容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	
	//1遍历
	
	//1.1 方式一while
	//通过迭代器访问容器中的数据
	vector<int>:: iterator itBegin = v.begin();//起始迭代器  指向容器中第一个元素
	vector<int>:: iterator itEnd = v.end();//结束迭代器  指向容器中最后一个元素的下一个位置
	while(itBegin != itEnd){
		cout << *itBegin << endl;
		itBegin ++;
	}
	cout << "方式一----------" << endl;
	
	//1.2 方式二for
	for(vector<int>:: iterator it = v.begin();it != v.end();it++){
		cout << *it << endl;
	}
	cout << "方式二----------" << endl;
	
	//1.3 方式三  利用STL提供遍历算法
	for_each(v.begin(), v.end(), myPrint);
	cout << "方式三----------" << endl;
	
}
int main() {
	test01();
	return 0;
}

10
20
30
40
方式一----------
10
20
30
40
方式二----------
10
20
30
40
方式三----------

1.3 vector存放自定义数据类型

1.3.1 存放自定义数据类型Person

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};


void myPrint(Person val){
	cout << "姓名："<< val.m_Name <<  "年龄："<< val.m_Age  <<endl;
}


void test01(){
	//定义vector
	vector<Person> v;
	
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	
	//往容器中插入数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	
	//1遍历
	
	
	//1.1 方式一while
	//通过迭代器访问容器中的数据
	vector<Person>:: iterator itBegin = v.begin();
	vector<Person>:: iterator itEnd = v.end();
	while(itBegin != itEnd){
		cout << "姓名："<< (*itBegin).m_Name <<  "年龄："<< (*itBegin).m_Age  <<endl;
		itBegin++;
	}
	cout << "方式一----------" << endl;
	
	
	
	//1.2 方式二for
	for(vector<Person>:: iterator it = v.begin(); it != v.end(); it++){
	    cout << "姓名："<< (*it).m_Name <<  "年龄："<< (*it).m_Age  <<endl;
	    //与下行代码等价
        //cout << "姓名："<< it->m_Name <<  "年龄："<< it->m_Age  <<endl;
	}
	cout << "方式二----------" << endl;
	
	
	
	//1.3 方式三  利用STL提供遍历算法
	for_each(v.begin(), v.end(), myPrint);
	cout << "方式三----------" << endl;
	
	
}
int main() {
	test01();
	return 0;
}

姓名：aaa年龄：10
姓名：bbb年龄：20
姓名：ccc年龄：30
姓名：ddd年龄：40
姓名：eee年龄：50
方式一----------
姓名：aaa年龄：10
姓名：bbb年龄：20
姓名：ccc年龄：30
姓名：ddd年龄：40
姓名：eee年龄：50
方式二----------
姓名：aaa年龄：10
姓名：bbb年龄：20
姓名：ccc年龄：30
姓名：ddd年龄：40
姓名：eee年龄：50
方式三----------

for_each（在algorithm头文件中）的声明：

1.3.2 存放自定义数据类型Person指针

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};


void myPrint(Person val){
	cout << "姓名："<< val.m_Name <<  "年龄："<< val.m_Age  <<endl;
}


void test01(){
	//定义vector
	vector<Person*> v;
	
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	
	//往容器中插入数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	for(vector<Person*>:: iterator it = v.begin(); it != v.end(); it++){
	    cout << "姓名："<< (**it).m_Name <<  "年龄："<< (**it).m_Age  <<endl;
	}
	
}
int main() {
	test01();
	return 0;
}

姓名：aaa年龄：10
姓名：bbb年龄：20
姓名：ccc年龄：30
姓名：ddd年龄：40
姓名：eee年龄：50

1.3.3 vector嵌套vector

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

void test01(){
	//定义vector
	vector< vector<int> > v;
	
	//创建小容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	
	//往小容器中插入数据
	for(int i = 0;i < 4;i++){
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}
	
	//往大容器中插入数据
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	
	
	for(vector< vector<int> >:: iterator it = v.begin(); it != v.end(); it++){
		for(vector<int>:: iterator vit = (*it).begin(); vit != (*it).end(); vit++){
			cout << *vit << " ";
		}
		cout <<endl;
	}
}
int main() {
	test01();
	return 0;
}

2 deque容器

2.1 基本概念

2.1.1 定义

2.1.2 内部结构

2.2 操作

2.2.1 构造deque

构造方法与vector完全相同

#include <iostream>
#include <deque>
using namespace std;

void myPrint(const deque<int>&d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		//*it = 100; 容器中的数据不可以修改了
		cout << *it << " ";
	}
}
void test01() {
	//默认构造
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	myPrint(d1);
	cout << "默认构造" << endl;

	//通过区间方式构造
	deque<int> d2(d1.begin(), d1.end());
	myPrint(d2);
	cout << "通过区间方式构造" << endl;

	//n个elem方式构造
	deque<int> d3(5, 10);
	myPrint(d3);
	cout << "n个elem方式构造" << endl;

	//拷贝方式构造
	deque<int> d4(d3);
	myPrint(d4);
	cout << "拷贝方式构造" << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9 默认构造
0 1 2 3 4 5 6 7 8 9 通过区间方式构造
10 10 10 10 10 n个elem方式构造
10 10 10 10 10 拷贝方式构造

2.2.2 deque的赋值

赋值方法与vector完全相同

#include <iostream>
#include <deque>
using namespace std;

void myPrint(const deque<int>&d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
}
void test01() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}

	//方式一：=
	deque<int> d2;
	d2 = d1;
	myPrint(d2);
	cout << "方式一：=" << endl;

	//方式二：assign
	deque<int> d3;
	d3.assign(d1.begin() + 3, d1.end());
	myPrint(d3);
	cout << "方式二：assign" << endl;

	//方式三：n个elem方式赋值
	deque<int> d4;
	d4.assign(5, 10);
	myPrint(d4);
	cout << "方式三：n个elem方式赋值" << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9 方式一：=
3 4 5 6 7 8 9 方式二：assign
10 10 10 10 10 方式三：n个elem方式赋值

2.2.3 大小

deque无容量，其他的与vector完全相同

#include <iostream>
#include <deque>
using namespace std;

void myPrint(const deque<int>&d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
}
void test01() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	myPrint(d1);
	cout << endl;

	if (d1.empty()) {
		cout << "d1为空" << endl;
	}
	else {
		cout << "d1不为空" << endl;
		cout << "d1中元素的个数为：" << d1.size() << endl;
	}

	//重新指定大小
	d1.resize(15);	//如果重新指定长度变长，默认用0填充
	myPrint(d1);
	cout << endl;

	d1.resize(16, 20);	//如果重新指定长度变长，用elem填充
	myPrint(d1);
	cout << endl;

	d1.resize(5);		//如果重新指定长度变短，末尾元素删除
	myPrint(d1);
	cout << endl;
}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9
d1不为空
d1中元素的个数为：10
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0
0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 20
0 1 2 3 4

2.2.4 deque的插入和删除

deque比vector以下三个操作（红框标注）

#include <iostream>
#include <deque>
using namespace std;

void myPrint(const deque<int>& d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
}

void test01() {
	deque<int> d1;
	deque<int> d2(3,999);
	//尾插
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_back(40);
    //头插
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);
	d1.push_front(400);
	cout << "尾插后" << endl;
	myPrint(d1);	//400 300 200 100 10 20 30 40
	cout << endl;

	//插入
	d1.insert(d1.begin() + 1, 5);
	cout << "插入后" << endl;
	myPrint(d1);	//400 5 300 200 100 10 20 30 40
	cout << endl;

	d1.insert(d1.begin() + 1, 5, 3);
	myPrint(d1);	//400 3 3 3 3 3 5 300 200 100 10 20 30 40
	cout << endl;

	d1.insert(d1.begin(), d2.begin(), d2.end());
	myPrint(d1);	//999 999 999 400 3 3 3 3 3 5 300 200 100 10 20 30 40
	cout << endl;

	//尾删
	d1.pop_back();
	cout << "尾删后" << endl;
	myPrint(d1);	//999 999 999 400 3 3 3 3 3 5 300 200 100 10 20 30
	cout << endl;
	//头删
	d1.pop_front();
	cout << "头删后" << endl;
	myPrint(d1);	//999 999 400 3 3 3 3 3 5 300 200 100 10 20 30
	cout << endl;

	//删除指定位置
	d1.erase(d1.begin() + 1);
	cout << "删除指定位置后" << endl;
	myPrint(d1);	//999 400 3 3 3 3 3 5 300 200 100 10 20 30
	cout << endl;

	d1.erase(d1.begin() + 1, d1.begin() + 5);	//不包括end
	myPrint(d1);	//999 3 3 5 300 200 100 10 20 30
	cout << endl;

	//清空
	d1.clear();
	cout << "清空后" << endl;
	myPrint(d1);
	cout << endl;
}
int main() {
	test01();
	return 0;
}

尾插后
400 300 200 100 10 20 30 40
插入后
400 5 300 200 100 10 20 30 40
400 3 3 3 3 3 5 300 200 100 10 20 30 40
999 999 999 400 3 3 3 3 3 5 300 200 100 10 20 30 40
尾删后
999 999 999 400 3 3 3 3 3 5 300 200 100 10 20 30
头删后
999 999 400 3 3 3 3 3 5 300 200 100 10 20 30
删除指定位置后
999 400 3 3 3 3 3 5 300 200 100 10 20 30
999 3 3 5 300 200 100 10 20 30
清空后

2.2.5 deque数据存取

数据存取与vector完全相同

#include <iostream>
#include <deque>
using namespace std;

void myPrint(const deque<int>& d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
}

void test01() {
	deque<int> d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}

	//at方式访问
	for (int i = 0; i < d1.size(); i++) {
		cout << d1.at(i) << " ";
	}
	cout << "at方式访问" << endl;

	//[]方式访问
	for (int i = 0; i < d1.size(); i++) {
		cout << d1[i] << " ";
	}
	cout << "[]方式访问" << endl;

	cout << "容器中第一个元素是：" << d1.front() << endl;
	cout << "容器中最后一个元素是：" << d1.back() << endl;

}
int main() {
	test01();
	return 0;
}

0 1 2 3 4 5 6 7 8 9 at方式访问
0 1 2 3 4 5 6 7 8 9 []方式访问
容器中第一个元素是：0
容器中最后一个元素是：9

2.2.6 deque排序

对于支持随机访问的迭代器的容器，都可以用sort方法直接对其进行排序

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

void myPrint(const deque<int>& d) {
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
}

void test01() {
	deque<int> d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_back(40);
	d1.push_front(100);
	d1.push_front(200);
	d1.push_front(300);
	d1.push_front(400);

	cout << "排序前" << endl;
	myPrint(d1);	//400 300 200 100 10 20 30 40
	cout << endl;

	//默认排序规则：从小到大
	sort(d1.begin(), d1.end());
	cout << "排序后" << endl;
	myPrint(d1);	//400 300 200 100 10 20 30 40
	cout << endl;
}
int main() {
	test01();
	return 0;
}

排序前
400 300 200 100 10 20 30 40
排序后
10 20 30 40 100 200 300 400

3 案例

#include<iostream>
#include<vector>
#include<deque>
#include<string>
#include<cstdlib>
#include<algorithm>
using namespace std;

//选手类
class Person 
{
public:
    Person(string name, float score) {
        this->m_Name = name;
        this->m_Score = score;
    }
    string m_Name;
    float m_Score;
};

void createPerson(vector<Person> &v) {
    string s = "ABCDE";
    float score = 0.0;  //初始化成绩为0
    for (int i = 0; i < 5; i++) {
        string name = "选手";
        name += s[i];
        Person p(name,score);
        v.push_back(p);
    }
}

void setScore(vector<Person> &v) {
    deque<int> d;   //用来存储十名评委对一名选手打出的成绩
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
        float sum = 0.0;
        //十个评委对一名选手打分
        for (int i = 0; i < 10; i++) {
            int num = rand() % 41 + 60; //控制数的范围在60-100之间
            sum += num;
            d.push_back(num);
        }
        //排序分数
        sort(d.begin(), d.end());
        //去除最高分和最低分
        sum -= d.back();
        sum -= d.front();
        d.pop_back();
        d.pop_front();

        //求平均值
        float ave = sum / d.size();
        (*it).m_Score = ave;
        d.clear();
    }
}

int main() {
    //1.创建初始化的五名选手
    vector<Person> v;
    createPerson(v);
    /*
    测试
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
        cout << "姓名：" << (*it).m_Name << " 成绩：" << (*it).m_Score << endl;
    }
    */

    //2.计算每名选手的平均成绩
    setScore(v);
    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
        cout << "姓名：" << (*it).m_Name << " 平均成绩：" << (*it).m_Score << endl;
    }
    return 0;
}

选手A 平均成绩：78.625
姓名：选手B 平均成绩：82.5
姓名：选手C 平均成绩：74.75
姓名：选手D 平均成绩：80.625
姓名：选手E 平均成绩：77.375

你好 Future！

关注

8
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
vector（单端数组）和deque（双端数组）

vector容器和deque容器的详细介绍，课后附案例。
复制链接

扫一扫

专栏目录