c++学习笔记11

最新推荐文章于 2024-07-24 11:32:27 发布

落落落Luo

最新推荐文章于 2024-07-24 11:32:27 发布

阅读量174

点赞数 1

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_41870790/article/details/104094417

版权

c++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

list容器

STL中的链表为双向循环链表

图示：

在这里插入图片描述
由于链表的存储方式不是连续的内存空间，因此链表list中的迭代器只支持前移和后移属于双向迭代器 不可以跳跃式移动
list的优点：
采用动态存储分配，不会在成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list的缺点：
链表灵活，但空间（指针域）和时间（遍历）额外耗费较大
list有一个重要性质，插入和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的

list构造函数

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



void printList(list<int>& l) {
	for (list<int>::iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
//list容器的构造函数
void test01() {
	//创建list容器
	list<int> l1;

	//添加数据
	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	//遍历容器
	printList(l1);

	//区间方式构造
	list<int> l2(l1.begin(), l1.end());
	printList(l2);

	//拷贝构造
	list<int> l3(l2);
	printList(l3);

	//n个elem
	list<int> l4(10, 1000);
	printList(l4);
}
int main() {
	test01();

	system("pause");
	return 0;
}

list赋值交换

#include<iostream>
using namespace std;
#include<list>
//list容器的赋值和交换
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//赋值
void test01() {
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	printList(l1);

	list<int> l2;
	l2 = l1;//operator=
	printList(l2);

	list<int>l3;
	l3.assign(l2.begin(), l2.end());
	printList(l3);

	list<int> l4;
	l4.assign(10, 100);
	printList(l4);


}

//交换
void test02() {
	list<int> l1;

	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	list<int> l2;
	l2.assign(10, 100);

	cout << "交换前--------------" << endl;
	printList(l1);
	printList(l2);

	l1.swap(l2);
	cout << "交换后--------------" << endl;
	printList(l1);
	printList(l2);



}
int main() {

	//test01();
	test02();
	system("pause");
	return 0;
}

list的大小操作

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

void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {

		cout << *it << " ";

	}
	cout << endl;
}
//list容器大小操作
void test01() {
	list<int> l1;
	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	printList(l1);

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

	//重新指定大小
	l1.resize(10,10000);
	printList(l1);

	l1.resize(2);
	printList(l1);

}
int main() {
	test01();
	system("pause");
	return 0;
}

list插入和删除

#include<iostream>
using namespace std;
#include<list>
void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {

		cout << *it << " ";
	}
	cout << endl;
}
//list插入与删除
void test01() {

	list<int>l;
	//尾插
	l.push_back(10);
	l.push_back(20);
	l.push_back(30);

	//头插
	l.push_front(100);
	l.push_front(200);
	l.push_front(300);

	printList(l);

	//尾删
	l.pop_back();
	printList(l);

	//头删
	l.pop_front();
	printList(l);

	//insert插入
	l.insert(l.begin(), 1000);//在第一个迭代器的位置插入1000
	printList(l);

	//删除
	list<int>::iterator it = l.begin();
	l.erase(it);
	printList(l);

	//移除
	l.push_back(10000);
	l.push_back(10000);
	l.push_back(10000);
	l.push_back(10000);
	printList(l);
	l.remove(10000);//所有10000都删掉
	printList(l);

	//清空
	l.clear();
	printList(l);
}
int main() {
	test01();
	system("pause");
	return 0;
}

list的数据存取

#include<iostream>
using namespace std;
#include<list>
//list中的数据存取
void test01() {
	list<int> l1;
	l1.push_back(10);
	l1.push_back(20);
	l1.push_back(30);
	l1.push_back(40);

	//l1[0] 不可以用[]来来访问list容器中的元素

	//l1.at(0) 不可以用at方式来访问list容器中的元素

	//原因 list本质是一个链表，不是用连续的线性空间存储数据，迭代器也不支持随机访问

	cout << "第一个元素为：" << l1.front() << endl;
	cout << "最后一个元素为：" << l1.back() << endl;

	//验证迭代器是不支持随机访问的
	list<int>::iterator it = l1.begin();
	it--;
	it++;//支持双向
	//it = it + 2;//不支持随机访问
}
int main() {
	test01();
	system("pause");
	return 0;
}

list反转和排序

#include<iostream>
using namespace std;
#include<list>
#include<algorithm>
//list容器的反转和排序

void printList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {
	//反转
	list<int> L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	cout << "-----------反转前-----------------" << endl;
	printList(L1); 

	//反转

	L1.reverse();
	cout << "-----------反转后-----------------" << endl;
	printList(L1);
}

bool myCompare(int v1,int v2) {
	//降序    就让第一个数 > 第二个数
	return v1 > v2;	 
}
//排序
void test02() {
	list<int> L1;
	L1.push_back(20);
	L1.push_back(10);
	L1.push_back(50);
	L1.push_back(40);
	L1.push_back(30);

	//排序
	cout << "-----------排序前-----------------" << endl;
	printList(L1);

	//所有不支持随机访问迭代器的容器，不可以使用标准算法 
	//不支持随机访问迭代器的容器内部会提供对应的一些算法
	//sort(L1.begin(), L1.end());
	L1.sort();//默认从小到大 升序
	cout << "-----------排序后-----------------" << endl;
	printList(L1);

	L1.sort(myCompare);//降序
	printList(L1);

}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

排序案例

#include<iostream>
using namespace std;
#include<list>
//list容器排序案例  对自定义的数据类型  做排序

//按照年龄进行升序，如果年龄相同按照身高进行降序
class Person {
public:
	string m_Name;
	int m_Age;
	int m_Height;//身高

	Person(string name,int age,int height) {
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}

};

//指定排序规则
bool comparePerson(Person &p1,Person &p2) {
	//按年龄升序
	if (p1.m_Age == p2.m_Age) {
		//年龄相同 按照身高降序
		return p1.m_Height > p2.m_Height;

	}
	return p1.m_Age < p2.m_Age;
}
void test01() {
	list<Person> L;//创建容器

	//准备数据
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 40, 170);
	Person p4("张飞", 25, 190);
	Person p5("赵云", 35, 160);
	Person p6("关羽", 35, 200);

	//插入数据
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);

	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << it->m_Name << "\t" << it->m_Age << "\t" << it->m_Height << endl;
	}

	//排序
	cout << "排序后：------------------" << endl;
	L.sort(comparePerson);//自定义类型排序 必须指定规则
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
		cout << it->m_Name << "\t" << it->m_Age << "\t" << it->m_Height << endl;
	}
}
int main() {
	test01();
	system("pause");
	return 0;
}

set/multiset 容器

简介：

所有元素都会在插入时自动被排序

本质：

set/multiset属于关联式容器，底层结构是用二叉树实现

set和multiset的区别：

set不允许容器中有重复的元素
multiset允许容器中有重复的元素

set容器的构造和赋值操作

#include<iostream>
using namespace std;
#include<set>
//set容器构造和赋值
void printSet(const set<int> &s) {
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {
	set<int>s1;
	//插入数据只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);


	//遍历容器
	//所有元素插入时自动排序
	//set不允许插入重复的值
	printSet(s1);

	//拷贝构造
	set<int> s2(s1);
	printSet(s2);

	//赋值
	set<int> s3;
	s3 = s2;
	printSet(s3);

}
int main() {
	test01();
	system("pause");
	return 0;
}

set容器大小和交换

#include<iostream>
using namespace std;
#include<set>
void printSet(const set<int>& s) {
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
//set容器大小和交换操作
//大小
void test01() {
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	printSet(s1);

	//判空
	if (s1.empty()) {
		cout << "s1为空" << endl;
	}
	else {
		cout << "s1不为空" << endl;
		cout << "s1的大小为：" << s1.size() << endl;
	}
}

//交换
void test02() {
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	set<int> s2;
	s2.insert(100);
	s2.insert(200);
	s2.insert(300);
	s2.insert(400);

	cout << "交换前:" << endl;
	cout << "----------------------------------------" << endl;
	printSet(s1);
	printSet(s2);

	cout << "交换后：" << endl;
	cout << "----------------------------------------" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);


}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

set容器的插入和删除

#include<iostream>
using namespace std;
#include<set>
void printSet(const set<int>& s) {
	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << " ";

	}
	cout << endl;
}
//set容器的插入和删除
void test01() {
	set<int> s1;

	//插入
	s1.insert(30);
	s1.insert(10);
	s1.insert(20);
	s1.insert(40);

	//遍历
	printSet(s1);

	//删除
	s1.erase(s1.begin());
	printSet(s1);

	//删除的重载版本
	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);


}
int main() {
	test01();
	system("pause");
	return 0;
}

set的查找和统计

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

//set容器 查找和统计

//查找
void test01() {

	
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int>::iterator pos=s1.find(30);
	if (pos != s1.end()) {
		cout << "找到元素：" << *pos << endl;
	}
	else {
		cout << "未找到元素" << endl;
	}
}



//统计
void test02() {
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	//统计30的个数
	int num = s1.count(30);//对于set而言 统计的结果要么是0要么是1
	cout << "num= " << num << endl;


}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

set和multiset的区别

#include< iostream>
using namespace std;
#include<set>
//set容器和multiset容器的区别
void test01() {
	set<int> s;
	pair<set<int>::iterator,bool> ret= s.insert(10);
	if (ret.second) {
		cout << "第一次插入成功" << endl;
	}
	else {
		cout << "第一次插入失败" << endl;
	}
	
	ret=s.insert(10);
	if (ret.second) {
		cout << "第二次插入成功" << endl;
	}
	else {
		cout << "第二次插入失败" << endl;
	}

	multiset<int> ms;
	//允许插入重复的值
	ms.insert(10);
	ms.insert(10);

	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

pair对组创建

成对出现的数据，利用对组可以返回两个数据

#include<iostream>
using namespace std;

//pair对组的创建
void test01() {

	//第一种方式
	pair<string, int> p("Tom", 20);
	cout << "姓名：" << p.first << "年龄：" << p.second << endl;

	//第二种方式
	pair<string, int> p2 = make_pair("Jerry", 30); 
	cout << "姓名：" << p2.first << "年龄：" << p2.second << endl;
}
int main() {
	test01();
	
	system("pause");
	return 0;
}

set容器排序

利用仿函数可以改变排序规则

存放内置数据类型排序代码：

#include<iostream>
using namespace std;
#include<set>
//set容器的排序规则

//仿函数
class MyCompare {
public:
	bool operator()(int v1, int v2)const {//仿函数
		return v1 > v2;
	}
};
void test01() {
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(50);

	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则从大到小	
	set<int, MyCompare> s2;
	s2.insert(10);
	s2.insert(40);
	s2.insert(30);
	s2.insert(20);
	s2.insert(50);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

}

int main() {
	test01();
	system("pause");
	return 0;
}

存放自定义数据类型排序代码：

#include<iostream>
using namespace std;
#include<set>
//set容器排序，存放自定义数据类型
class Person {
public:
	string m_Name;
	int m_Age;

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

class comparePerson {
public:
	bool operator()(const Person &p1,const Person &p2)const {
		//按照年龄  降序
		return p1.m_Age > p2.m_Age;
	}

};
void test01() {
	//自定义的数据类型 都会指定排序规则
	set<Person, comparePerson> s;
	Person p1("刘备", 24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++) {
		cout << "姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
	}




}
int main() {
	test01();

	system("pause");
	return 0;
}

map/multimap容器

简介：

map中所以元素都是pair
pair第一个元素为key（键值），起到索引作用，第一个元素为value（实值）
所有元素都会根据元素的key自动排序

本质：

map/multimap 属于关联式容器，底层结构是二叉树

优点：

可以根据key值快速找到value值

map和multimap的区别：

map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素

map容器的构造和赋值

map中所有元素成对出现必须用对组

#include<iostream>
using namespace std;
#include<map>
void printMap(map<int,int> &m) {
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
		cout << "key= " << it->first << "value= " << it->second << endl;
	}
	cout << endl;
}
//map容器 构造和赋值
void test01() {
	//创建map容器
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));//匿名对组作为参数放入容器
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(2, 30));
	m.insert(pair<int, int>(4, 40));

	printMap(m);

	//拷贝构造
	map<int, int> m2(m);
	printMap(m2);

	//赋值
	map<int, int> m3;
	m3 = m2;
	printMap(m3);


}
int main() {
	test01();
	system("pause");
	return 0;
}

map大小和交换

#include<iostream>
using namespace std;
#include<map>
//map容器的大小和交换

void printMap(map<int, int>& m) {
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {

		cout << "key= " << it->first << "value= " << it->second << endl;
	}
	cout << endl;

}
//大小
void test01() {
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	if (m.empty()) {
		cout << "m为空" << endl;
	}
	else {
		cout << "m不为空" << endl;
		cout << "m的大小为：" << m.size() << endl;
	}
}

//交换
void test02() {
	map<int, int> m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));


	map<int, int> m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));


	cout << "交换前：" << endl;
	printMap(m);
	printMap(m2);

	m.swap(m2); 
	cout << "交换后：" << endl;
	printMap(m);
	printMap(m2);
}



int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

map插入和删除

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

void printMap(map<int,int> & m) {
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
		cout << "key= " << it->first << " value= " << it->second << endl;
	}
	cout << endl;
}
//map容器的插入和删除
void test01() {

	map<int, int> m;
	//插入
	//第一种
	m.insert(pair<int, int>(1, 10));

	//第二种
	m.insert(make_pair(2, 20));

	//第三种
	m.insert(map<int, int>::value_type(3, 30));

	//第四种
	m[4] = 40;

	//不建议用[]去插入 用途 可以用key来访问到value
	cout << m[4] << endl;
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	//按照key删除  不能按照value删除
	m.erase(3);
	printMap(m);

	//清空
	//m.erase(m.begin(), m.end());
	m.clear();
	printMap(m);


}
int main() {
	test01();
	system("pause");
	return 0;
}

map查找和统计

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

//map容器中的查找和统计
void test01() {
	//查找
	map<int, int> m;
	m.insert(make_pair(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(3, 40));

	map<int, int>::iterator pos = m.find(3);

	if (pos != m.end()) {
		cout << "查到了元素key:  " << pos->first << " value :" << pos->second << endl;
	}
	else {
		cout << "未找到元素" << endl;
	}

	//统计
	//map不允许插入重复的key元素，count统计而言 结果要么是0要么是1
	//multimap的count统计可能大于1
	int num = m.count(3);
	cout << "num= " << num << endl;


}
int main() {
	test01();
	system("pause");
	return 0;
}

map容器排序

内置数据类型用仿函数改变排序规则：

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

//仿函数
class MyCompare {
public:
	bool operator()(int v1,int v2) const{
		//降序
		return v1 > v2;
	}
};
//map容器排序
void test01() {
	map<int, int, MyCompare> m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {

		cout << "key= " << it->first << " value= " << it->second << endl;
	}


}
int main() {
	test01();
	system("pause");
	return 0;
}

自定义数据类型用仿函数改变排序规则

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

//Person类
class Person {
public:
	string m_Name;
	int m_Age;


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

//仿函数

struct MyCompare {
public:
	bool operator()(const int &p1,const int &p2)const  {
		//降序
		return p1 > p2;
	}
};

//map容器排序
void test01() {
	map<int, Person, MyCompare> m;

	Person p1("虎虎", 15);
	Person p2("打包", 16);
	Person p3("问问", 10);
	Person p4("头阿", 19);
	Person p5("虎虎", 17);
	m.insert(pair<int, Person>(1, p1));
	m.insert(pair<int, Person>(2, p2));
	m.insert(pair<int, Person>(3, p3));
	m.insert(pair<int, Person>(4, p4));
	m.insert(pair<int, Person>(5, p5));

	for (map<int, Person, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {

		cout  <<"key= "<<it->first<< " value= " << (it->second).m_Name << " " << (it->second).m_Age << endl;
	}


}
int main() {
	test01();
	system("pause");
	return 0;
}

案例-员工分组

#include<iostream>
using namespace std;
#include<vector>
#include<map>
#include<ctime>
# define CEHUA 0
# define MEISHU 1
# define YANFA 2

class Worker {
public:
	string m_Name;
	int m_Salary;
};

void createWorker(vector<Worker> &v) {

	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++) {
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];

		worker.m_Salary = rand() % 10000 + 10000;//10000~19999
		//将员工放入到容器中
		v.push_back(worker);
	}
}

//员工的分组
void setGroup(vector<Worker>& v, multimap<int, Worker>& m) {
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++) {
		//产生随机的部门编号
		int deptId = rand() % 3;//0 1 2

		//将员工插入到分组中
		m.insert(make_pair(deptId, *it));

	}
}

void showWorkerByGroup(multimap<int, Worker>& m) {
	cout << "策划部门：" << endl;

	multimap<int, Worker>::iterator pos = m.find(CEHUA);
	int count = m.count(CEHUA);//统计策划部门具体的人数
	int index = 0;
	for (; pos != m.end() && index<count; pos++,index++) {
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}

	cout << "-----------------------------------------" << endl;
	cout << "美术部门：" << endl;

	pos = m.find(MEISHU);
	count = m.count(MEISHU);//统计策划部门具体的人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}

	cout << "-----------------------------------------" << endl;
	cout << "研发部门：" << endl;

	pos = m.find(YANFA);
	count = m.count(YANFA);//统计策划部门具体的人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.m_Salary << endl;
	}
}
int main() {

	//随机数种子
	srand((unsigned int)time(NULL));
	//1.创建员工
	vector<Worker> vWorker;
	createWorker(vWorker);

	//2.员工分组
	multimap<int, Worker> mWorker;
	setGroup(vWorker, mWorker);

	//3.分组显示员工
	showWorkerByGroup(mWorker);

	测试
	//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++) {
	//	cout << "姓名：" << it->m_Name << "\t月薪：" << it->m_Salary << endl;
	//}

	system("pause");
	return 0;
}