C++学习记录---2

嵌入式小白白

于 2021-09-27 22:26:04 发布

阅读量610

点赞数 1

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

本文链接：https://blog.csdn.net/qq_42025309/article/details/115001980

版权

C/C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本片为提高篇

1、模板

1.1、函数模板

模板的特点：

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的
C++另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制:函数模板和类模板

函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

template 函数声明或定义
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
using namespace std;


/*
模板特点：
1、模板不可以直接使用，它只是一个框架
2、模板的通用并不是万能的
*/

/*比如：简单的交换函数*/
void intSwap(int& a, int& b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
void doubleSwap(double& a, double& b)
{
	double temp;
	temp = a;
	a = b;
	b = temp;
}
//使用函数模板
template <typename T>
void Swap(T& a, T& b)
{
	T temp;
	temp = a;
	a = b;
	b = temp;
}
template <typename T>
void func()
{
	cout << "func()函数调用" << endl;
}

template <typename T>
void arrsork(T arr[], int& len)
{
	int i, j;
	for (int i = 0; i < len; i++)
	{
		for (int j = i; j < len; j++)
		{
			if (arr[i] > arr[j])
			{
				Swap(arr[i], arr[j]);
			}
		}
	}
}

template <typename T>
T addtest(T a, T b)
{
	return a + b;
}

void mytemplate(void)
{
	int a = 56;
	int b = 89;
	char c = 40;
	int arr[10] = { 4,58,1,0,89,56854,4568,23,56,40 };
	int arrint = sizeof(arr)/sizeof(int);
	//	intSwap(a, b);

	//两种方式
	//1、自动类型推导--必须推导出一致的数据类型T,才可以使用
	Swap(a, b);//正确--可以推导出一直的T类型
	addtest<int>(a, c);//显示指定类型--
	//  Swap(a, c);//错误--推导不出一致的T类型

	//2、显示指定类型--模板必须要确定出T的数据类型，才可以使用
	
	Swap<int>(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	addtest<int>(a, c);//显示指定类型--可以发生隐藏式类型转换
	//func(); //错误，模板不能独立使用，必须确定出T的类型 
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板

	arrsork(arr, arrint);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

在这里插入图片描述

总结：

函数模板利用关键字 template
使用函数模板有两种方式：自动类型推导、显示指定类型
模板的目的是为了提高复用性，将类型参数化

注意事项

自动类型推导，必须推导出一致的数据类型T,才可以使用
模板必须要确定出T的数据类型，才可以使用
使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配,优先调用函数模板

#include <iostream>
using namespace std;

/*
1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配,优先调用函数模板
*/
//普通函数
int func1(int &a,int &b)
{
	cout << "普通函数func1--调用" << endl;
	return a + b;
}
//函数模板
template <typename T>
T func1(T& a, T& b)
{
	cout << "函数模板func2--调用" << endl;
	return a + b;
}
template <typename T>
T func1(T& a, T& b, T& c)
{
	cout << "重载函数模板func2--调用" << endl;
	return a + b + c;
}
void Callrules(void)
{
	int a = 89;
	int b = 11;
	int c = 50;
	//普通函数
	cout << "func1 = " << func1(a, b) << endl;

	//函数模板--可以通过空模板参数列表来强制调用函数模板
	cout << "func1 = " << func1<>(a, b) << endl;

	//调用重载的函数模板
	cout << "func1 = " << func1<>(a, b, c) << endl;
}

在这里插入图片描述
注意：：：：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

模板的局限性
局限性：
模板的通用性并不是万能的
在这里插入图片描述

#include <iostream>
using namespace std;

template <class T>
bool func01(T a, T b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

class person
{
public:
	person(string name, int age)
	{
		this->name = name;
		this->age = age;
	}
public:
	string name;
	int age;
};
/*
在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板
*/

//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型 
//具体化优先于常规模板
template<> bool func01(person p1, person p2)
{
	if (p1.name == p2.name && p1.age == p2.age)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void boundedness(void)
{
	int a = 45;
	int b = 96;
	person p1("王二毛", 45);
	person p2("王二毛", 45);

	bool ret;
	ret = func01(a, b);
	if (ret)
		cout << "a == b" << endl;
	else
		cout << "a != b" << endl;

	ret = func01(p1, p2);
	if (ret)
		cout << "p1 == p2" << endl;
	else
		cout << "p1 != p2" << endl;
}

在这里插入图片描述
总结：

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.2、类模板

1.2.1、类模板基本应用

类模板作用：
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：template 类
解释：

template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
using namespace std;

template <typename Typename, typename Typeage>
class person01
{
public:
	person01(Typename name,Typeage age)
	{
		this->name = name;
		this->age = age;
	}
	void show()
	{
		cout << "姓名：" << name << endl;
		cout << "年龄：" << age << endl;
	}
public:
	Typename name;
	Typeage age;
};

void classtemplate(void)
{
	// 指定TypeName 为string类型，TypeAge 为 int类型
	person01<string, int>p1("大壮",52);
	p1.show();
}

在这里插入图片描述

1.2.2、类模板与函数模板区别

类模板与函数模板区别主要有两点：

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

#include <iostream>
using namespace std;

template <class Typename, class Typeage = int>
class person02
{
public:
	person02(Typename name, Typeage age)
	{
		this->name = name;
		this->age = age;
	}
	void show()
	{
		cout << "姓名：" << name << endl;
		cout << "年龄：" << age << endl;
	}
public:
	Typename name;
	Typeage age;
};

2、类模板在模板参数列表中可以有默认参数
void classtemplate01(void)
{
	// 指定TypeName 为string类型，TypeAge 为 int类型
	person02 <string> p1("小壮", 999);//类模板中的模板参数列表 可以指定默认参数		
	p1.show();
}

在这里插入图片描述

总结：

类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数
总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.2.3、类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

#include <iostream>
using namespace std;
class person03
{
public:
	person03()
	{
		cout << "person03---无参构造函数" << endl;
	}
	void show03()
	{
		cout << "person03---show03函数调用" << endl;
	}
};
class person04
{
public:
	person04()
	{
		cout << "person04---无参构造函数" << endl;
	}
	void show04()
	{
		cout << "person04---show04函数调用" << endl;
	}
};
template <class T>
class person05
{
public:
	person05()
	{
		cout << "person05---无参构造函数" << endl;
	}
//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
	void func1()
	{
		name.show03();
	}
	void func2()
	{
		name.show04();
	}
public:
	T name;
};
2、类模板在模板参数列表中可以有默认参数
void classtemplate02(void)
{
	cout << 89898989 << endl;
	// 指定TypeName 为string类型，TypeAge 为 int类型
	person05 <person03> p1;//类模板中的模板参数列表 可以指定默认参数	
	cout << 8989898888989899 << endl;
	p1.func1();
	//p1.func2();//编译会出错，说明函数调用才会去创建成员函数
}
//总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.2.4、类模板对象做函数参数

一共有三种传入方式：

指定传入的类型 — 直接显示对象的数据类型
参数模板化 — 将对象中的参数变为模板进行传递
整个类模板化 — 将这个对象类型模板化进行传递

#include "iostream"
using namespace std;

//3种方式
//1：指定传入类型---直接显示对象的数据类型
//2：参数模板化-----将对象的参数变为模板进行传递
//3：整个类模板化---将这个对象类型模板化进行传递

template <class Typename,class Typeage>
class person06
{
public:
	person06(Typename name,Typeage age)
	{
		this->name = name;
		this->age = age;
	}

	void showmassage()
	{
		cout << "name = " << name << endl;
		cout << "age = " << age << endl;
	}

public:
	Typename name;
	Typeage age;
};

//指定传入类型
void func1_person06(person06<string, int>& p)
{
	p.showmassage();
}

//参数模板化
template <class T1,class T2>
void func2_person06(person06<T1, T2>& p)
{
	p.showmassage();
	cout << "T1的类型为： " << typeid(T1).name() << endl;
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}

//整个类模板化
template <class T>
void func3_person06(T & p)
{
	p.showmassage();
	cout << "T的类型为： " << typeid(T).name() << endl;
}

void classmakefuncpara(void)
{
	person06 <string, int>p1("王一毛", 20);
	person06 <string, int>p2("王二毛", 30);
	person06 <string, int>p3("王三毛", 40);

	func1_person06(p1);
	func2_person06(p2);
	func3_person06(p3);
}

总结：
1、通过类模板创建的对象，可以有三种方式向函数中进行传参
2、使用比较广泛是第一种：指定传入的类型

1.2.5、类模板与继承

当类模板碰到继承时，需要注意一下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

#include "iostream"
using namespace std;


/*
当类模板碰到继承时，需要注意一下几点：
1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
2、如果不指定，编译器无法给子类分配内存
3、如果想灵活指定出父类中T的类型，子类也需变为类模板
*/

template <class T>
class base01
{
public:
	base01()
	{
		cout << "类模板与继承---父类--有参构造函数" << endl;
	/*	this->name = name;*/
	}
	void show()
	{
		cout << "父类--姓名：" << this->name << endl;
	}
public:
	T name;
};

//子类继承-要指定出父类中T的类型
class son1 :public base01<string>
{
public:
	son1(string name)
	{
		cout << "类模板与继承---子类son1--有参构造函数" << endl;
		this->name = name;
	}
	void show()
	{
		cout << "子类son1--姓名：" << this->name << endl;
	}
};

template <class T1,class T2>
class son2 :public base01<T2>
{
public:
	son2(int age)
	{
		cout << "类模板与继承---子类son2--有参构造函数" << endl;
		this->age = age;
	}
	void show()
	{
		cout << "子类son2--姓名：" << this->name << endl;
		cout << "子类son2--年龄：" << this->age << endl;
	}
public:
	T1 age;
};

void classandinherit(void)
{
	son1 s1("大锤");
//	s1.base01::name = "7787987";
	s1.base01::show();
	s1.show();
	
	son2<int,string>s2(89);
	s2.name = "阿三";
	s2.base01<string>::name = "fsfsf";//访问父类模板的成员（函数或者变量），需要加上<string>参数列表
	s2.base01<string>::show();
	s2.show();

}

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

在这里插入图片描述

1.2.6、类外声明类模板的成员函数

#include "iostream"
using namespace std;

/*学习目标：能够掌握类模板中的成员函数类外实现*/

template <class T1,class T2>
class person07
{
public:
	person07(T1 name, T2 age);
	void showinfo();

public:
	T1 name;
	T2 age;
};
template<class T1,class T2>
person07<T1, T2>::person07(T1 name, T2 age)
{
	this->name = name;
	this->age = age;
}

template<class T1,class T2>
void person07<T1, T2>::showinfo()
{
	cout << "姓名：" << this->name << endl;
	cout << "年龄：" << this->age << endl;
}


void classoutsta(void)
{
	person07<string,int> p1("迷糊",25);
	p1.showinfo();
}

在这里插入图片描述

1.2.7、类模板与友元

全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

#include "iostream"
using namespace std;
/*
两种方式：
1、类内实现---常用、比较简单、编译器可以直接识别
2、类外实现
*/

template <class T1, class T2>class person08;//全局函数配合友元 类外实现 - 先做类模板声明、函数声明、下方再做函数模板定义，再做友元

template <class T1,class T2>
void personfriend02(person08<T1, T2>& p)//类外全局函数做友元---要提前声明类
{
	cout << "类外实现友元--姓名：" << p.name << "--年龄：" << p.age << endl;
}

template <class T1,class T2>
class person08
{
	//类内实现
	friend void personfriend01(person08<T1, T2>& p)
	{
		cout << "类内实现友元--姓名：" << p.name << "--年龄：" << p.age << endl;
	}
	//类外实现
	friend void personfriend02<>(person08<T1, T2>& p);

public:
	person08(T1 name, T2 age);
	void showinfo();
private:
	T1 name;
	T2 age;
};

template <class T1,class T2>
person08<T1, T2>::person08(T1 name, T2 age)
{
	this->name = name;
	this->age = age;
}
template <class T1,class T2>
void person08<T1, T2>::showinfo()
{
	cout << "姓名：" << this->name << endl;
	cout << "年龄：" << this->age << endl;
}
void classandfriend(void)
{
	//类内友元--实现
	person08<string, int> p1("联合国", 89);
	p1.showinfo();
	personfriend01(p1);

	//类外友元--实现
	person08<string, int> p2("黑寡妇", 784);
	p2.showinfo();
	personfriend02(p2);
}

在这里插入图片描述

2、STL初识

2.1、基本概念

STL(Standard Template Library,标准模板库)
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接。
STL 几乎所有的代码都采用了模板类或者模板函数

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
算法：各种常用的算法，如sort、find、copy、for_each等 3. 迭代器：扮演了容器与算法之间的胶合剂。
仿函数：行为类似函数，可作为算法的某种策略。
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理。

容器：置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表等

这些容器分为序列式容器和关联式容器两种:

序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)
算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

迭代器：容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、!、=
输出迭代器	对数据的只写访问	只写、支持++
向前迭代器	读写操作、并能向前推进迭代器	读写、支持++、==、!、=
双向迭代器	读写操作，并能向前和向后操作	读写，支持++、–
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、–、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器
例子：

#include <iostream>
using namespace std;

#include <vector>
#include <algorithm>


void vectorprintf(int val)
{
	cout << val << " ";
}

void vectortest(void)
{
	//创建vector容器对象，并且通过模板参数指定容器中存放的数据类型
	vector<int> v;

	//向容器中存放数据
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i * 10);
	}

	//每个容器都有自己的迭代器，迭代器是用来遍历容器中的元素的
	//v.begin()返回迭代器，这个迭代器指向的是容器中第一个数据
	//v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
	//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型

	//第一种遍历方式
	vector<int>::iterator pbegin = v.begin();
	vector<int>::iterator pend = v.end();
	while (pbegin != pend)
	{
		cout << *pbegin << " ";
		pbegin++;
	}
	cout << endl;
	//第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	//第三种遍历方式
	//使用STL提供的标准遍历算法 需要包含头文件 algorithm
	for_each(v.begin(), v.end(), vectorprintf);
	cout << endl;
}

在这里插入图片描述

2.2、vector容器嵌套容器

#include <iostream>
using namespace std;

#include <vector>

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

public:
	string name;
	int age;
};
/*
1、person10 类
2、person10* 类
3、vector<int> 类
*/

void userdefinedvector(void)
{
	/*1、person10 类*/
	//创建容器
	cout << "person10  类部分-----------*****" << endl;
	vector<person10> v1;
	//创建容器成员
	person10 p1("悟空", 2);
	person10 p2("悟净", 22);
	person10 p3("悟能", 222);
	person10 p4("悟傻", 2222);
	//添加
	v1.push_back(p1);
	v1.push_back(p2);
	v1.push_back(p3);
	v1.push_back(p4);
	//打印
	for (vector<person10>::iterator it = v1.begin(); it != v1.end(); it++)
	{
		//cout << "姓名：" << (*it).name << " 年龄：" << (*it).age << endl;
		cout << "姓名：" << it->name << " 年龄：" << it->age << endl;
	}

	/*2、person10* 类*/
	cout << "person10 * 类部分-----------*****" << endl;
	vector<person10*> v2;
	person10 p5("哥哥", 5);
	person10 p6("武松", 55);
	person10 p7("大朗", 555);
	person10 p8("金莲", 5555);
	//添加
	v2.push_back(&p5);
	v2.push_back(&p6);
	v2.push_back(&p7);
	v2.push_back(&p8);
	//打印
	for (vector<person10*>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		//cout << "姓名：" << (*it).name << " 年龄：" << (*it).age << endl;
		cout << "姓名：" << (*it)->name << " 年龄：" << (*it)->age << endl;
	}

	/*3、vector<int> 类 部分*/
	cout << "嵌套 vector<int> 类部分-----------*****" << endl;
	vector <vector<int>> v3;
	//创建容器成员
	vector<int> son1;
	vector<int> son2;
	vector<int> son3;
	vector<int> son4;
	//赋值
	for (int i = 0; i < 10; i++)
	{
		son1.push_back(i + 10);
		son2.push_back(i + 100);
		son3.push_back(i + 1000);
		son4.push_back(i + 10000);
	}
	//添加到容器中
	v3.push_back(son1);
	v3.push_back(son2);
	v3.push_back(son3);
	v3.push_back(son4);

	//打印
	for (vector < vector<int> >::iterator it = v3.begin(); it != v3.end(); it++)
	{
		for (vector< int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}

	cout << "嵌套 vector<person10> 类部分-----------*****" << endl;
	vector <vector<person10>> v4;
	vector<person10> son5;
	vector<person10> son6;
	vector<person10> son7;

	person10 son5_1("aaa", 111);
	person10 son5_2("bbb", 222);
	person10 son5_3("ccc", 333);

	person10 son6_1("ddd", 444);
	person10 son6_2("eee", 555);
	person10 son6_3("fff", 666); 

	person10 son7_1("ggg", 777);
	person10 son7_2("hhh", 888);
	person10 son7_3("iii", 999);

	//添加
	son5.push_back(son5_1);
	son5.push_back(son5_2);
	son5.push_back(son5_3);

	son6.push_back(son6_1);
	son6.push_back(son6_2);
	son6.push_back(son6_3);

	son7.push_back(son7_1);
	son7.push_back(son7_2);
	son7.push_back(son7_3);

	v4.push_back(son5);
	v4.push_back(son6);
	v4.push_back(son7);

	for (vector<vector<person10>>::iterator it = v4.begin(); it != v4.end(); it++)
	{
		for (vector<person10>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << "姓名：" << vit->name << " 年龄：" << vit->age << endl;
		}
		cout << endl;
	}
}

在这里插入图片描述

3、STL-常用容器

3.1、string容器

3.1.1、string赋值操作

string基本概念
本质：string是C++风格的字符串，而string本质上是一个类
string和char * 区别：

char * 是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

特点：

string 类内部封装了很多成员方法，例如：查找find，拷贝copy，删除delete 替换replace，插入insert
string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

构造函数原型：

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化

功能描述：给string字符串进行赋值
赋值的函数原型：

string& operator=(const char* s); //char*类型字符串赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串

简单例子：

#include <iostream>
using namespace std;

/*
string& operator=(const char* s); //char*类型字符串 赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串
*/

void stringbase(void)
{
	string s1;
	s1.assign("hello world", 5);
	cout << s1 << endl;
	
	s1.assign("5655656");
	cout << s1 << endl;

	s1.assign(10, '6');
	cout << s1 << endl;
}

在这里插入图片描述

3.1.2、string字符串拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型：

string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n); //字符串s中从pos开始的n个字符连接到字符串结尾

例子：

#include <iostream>
using namespace std;

/*
string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n); //字符串s中从pos开始的n个字符连接到字符串结尾
*/

//字符串拼接
void stringappend(void)
{
	string s1 = "我";
	s1 += "是";
	cout << s1 << endl;
	s1 += ':';
	cout << s1 << endl;
	string s2 = "王大锤";
	s1 += s2;
	cout << s1 << endl;
	s1.append(",我今年");
	cout << s1 << endl;
	s1.append("12568912",2);
	cout << s1 << endl;
	s1.append("腻害岁了。", 4, 6);//从第4个字符开始，截取6个字符（注意一个汉字占用两个字符）---拼接到s1尾部
	cout << s1 << endl;
}

在这里插入图片描述

3.1.3、string字符串查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定的位置替换字符串
函数原型：
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s

#include <iostream>
using namespace std;

/*
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s
*/

void stringfindandreplace(void)
{
	string str = "abcdefggfedcba";
	int pos = str.find("de");
	if (pos == -1)
		cout << "未找到" << endl;
	else
		cout << "pos = " << pos << endl;

	//从str字符串的8位置开始查找，查找字符串"abc"前两个字符(ab)在str字符串中出现的位置
	pos = str.find("cba",8,2);
	if (pos == -1)
		cout << "未找到" << endl;
	else
		cout << "pos = " << pos << endl;

	pos = str.rfind("de"); 
	if (pos == -1)
		cout << "未找到" << endl;
	else
		cout << "pos = " << pos << endl;
	//从str字符串的第1个位置开始的后2个字符使用1111进行替换-->a1111defde(也就是把bc替换成1111)
	str.replace(1,2,"1111");
	cout << str << endl;
}

在这里插入图片描述

3.1.4、string字符串比较

功能描述：字符串之间的比较
比较方式：字符串比较是按字符的ASCII码进行对比

= 返回 0
> 返回 1
< 返回 -1

函数原型：

int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较

#include <iostream>
using namespace std;


void stringcmp(void)
{
	string s1 = "hello"; 
	string s2 = "aello"; 
	int ret = s1.compare(s2); 
	if (ret == 0) 
	{ 
		cout << "s1 等于 s2" << endl; 
	}
	else if (ret > 0) 
	{
		cout << "s1 大于 s2" << endl;
	}
	else
	{ 
		cout << "s1 小于 s2" << endl;
	}
}

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

3.1.5、string存取

string中单个字符存取方式有两种

char& operator[](int n); //通过[]方式取字符
char& at(int n); //通过at方法获取字符

#include <iostream>
using namespace std;

void stringgetandsave(void)
{
	string str = "hello world"; 
	for (int i = 0; i < str.size(); i++) 
	{ 
		cout << str[i] << " "; 
	}
	cout << endl; 
	for (int i = 0; i < str.size(); i++) 
	{
		cout << str.at(i) << " "; 
	}
	cout << endl;
	//字符修改 
	str[0] = 'x'; 
	str.at(1) = 'x';
	cout << str << endl;
}

总结：总结：string字符串中单个字符存取有两种方式，利用 [ ] 或 at

3.1.6、string插入和删除

功能描述：对string字符串进行插入和删除字符操作
函数原型：

string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c); //在指定位置插入n个字符c
string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

#include <iostream>
using namespace std;



void stringinsertanderase(void)
{
	string str = "hello";
	str.insert(1, "111");
	cout << str << endl; 
	str.erase(1, 3); //从1号位置开始删除3个字符 
	cout << str << endl;
}

总结：插入和删除的起始下标都是从0开始

3.1.7、string子串

功能描述：从字符串中获取想要的子串
函数原型：

string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串

#include <iostream>
using namespace std;

void stringson(void)
{
	string str = "abcdefg"; 
	string subStr = str.substr(1, 3);//从1位置开始向后数3个，返回 
	cout << "subStr = " << subStr << endl; 
	string email = "hello@sina.com"; 
	int pos = email.find("@"); 
	string username = email.substr(0, pos);
	cout << "username: " << username << endl;
}

在这里插入图片描述

3.2、vector容器

3.2.1、 vector构造函数

功能：

vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

在这里插入图片描述

vector容器的迭代器是支持随机访问的迭代器

功能描述：

创建vector容器

函数原型：

vector v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

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

/*
vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。
*/
void vectorprintf01(vector<int>&v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void vectorconstructor(void)
{
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	vectorprintf01(v1);

	vector<int >v2(v1.begin(), v1.end());
	vectorprintf01(v2);

	vector<int > v3(10, 100); //构造函数将10个100拷贝给本身
	vectorprintf01(v3);

	vector<int >v4(v2);
	vectorprintf01(v4);
}

在这里插入图片描述

3.3、deque容器

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关

在这里插入图片描述
deque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

#include <iostream>
using namespace std;
#include <deque>
#include <algorithm>
void dequeprintf(int dnum, deque<int>& d)
{
	if (d.empty())
	{
		cout << "d" << dnum <<"为空" << endl;
		return;
	}

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

void dequeuse(void)
{
	//deque<T> deqT; //默认构造形式
	//deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
	//deque(n, elem); //构造函数将n个elem拷贝给本身。
	//deque(const deque & deq); //拷贝构造函数
	cout << endl << "deque构造函数部分" << endl;
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i + 10);
	}
	dequeprintf(1, d1);

	deque<int> d2(d1.begin(), d1.end());
	dequeprintf(2, d2);

	deque<int> d3(10, 99);
	dequeprintf(3, d3);

	deque<int> d4(d3);
	//或者deque<int> d4 = d3;
	dequeprintf(4, d4);

	cout << endl << "deque赋值操作部分" << endl;
	//deque& operator=(const deque & deq); //重载等号操作符
	//assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
	//assign(n, elem); //将n个elem拷贝赋值给本身。

	deque<int> d5;
	d5 = d1;
	dequeprintf(5, d5);

	deque<int> d6;
	d6.assign(d1.begin(), d1.end());
	dequeprintf(6, d6);

	deque<int> d7;
	d7.assign(10, 55);
	dequeprintf(7, d7);

	
	//deque.empty();判断容器是否为空
	//deque.size();返回容器中元素的个数
	//deque.resize(num);重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
	//deque.resize(num, elem);重新指定容器的长度为num,若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
cout << endl << "deque大小操作部分" << endl;
	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1的大小是：" << d1.size() << endl;
	}
	d1.resize(15);//重新指定容器d1的大小
	cout << "d1的大小是：" << d1.size() << endl;
	dequeprintf(1,d1);

	d1.resize(20, 42);//重新指定容器d1的大小,容器变长，变长部分使用42进行填充
	cout << "d1的大小是：" << d1.size() << endl;
	dequeprintf(1,d1);

	//两端插入操作：
	//push_back(elem); //在容器尾部添加一个数据
	//push_front(elem); //在容器头部插入一个数据
	//pop_back(); //删除容器最后一个数据
	//pop_front(); //删除容器第一个数据

	//指定位置操作：
	//insert(pos, elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
	//insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值。
	//insert(pos, beg, end); //在pos位置插入[beg,end)区间的数据，无返回值。
	//clear(); //清空容器的所有数据
	//erase(beg, end); //删除[beg,end)区间的数据，返回下一个数据的位置。
	//erase(pos); //删除pos位置的数据，返回下一个数据的位置。
	cout << endl << "deque插入和删除部分" << endl;

	d1.push_back(7525);//尾插
	d1.push_front(456);//头插
	dequeprintf(1, d1);

	d1.pop_back();//尾删
	d1.pop_front();//头删
	dequeprintf(1, d1);

	d1.insert(d1.begin()+2, 8845);
	d1.insert(d1.begin() + 5, 2, 321);
	dequeprintf(1, d1);

	d1.erase(d1.begin() + 5, d1.begin() + 7);
	d1.erase(d1.begin() + 2);
	dequeprintf(1, d1);

	/*d1.clear();
	dequeprintf(1, d1);*/


	//at(int idx); //返回索引idx所指的数据
	//operator[]; //返回索引idx所指的数据
	//front(); //返回容器中第一个数据元素
	//back(); //返回容器中最后一个数据元素
	cout << endl << "deque 数据存取部分" << endl;
	
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}
	cout << endl;
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1[i] << " ";
	}
	cout << endl;
	cout << "d1容器中的第一个数据元素是：" << d1.front() << endl;
	cout << "d1容器中的最后一个数据元素是：" << d1.back() << endl;

	//利用算法实现对deque容器进行排序
	//sort(iterator beg, iterator end) //对beg和end区间内元素进行排序
	//总结：sort算法非常实用，使用时包含头文件 algorithm即可
	cout << endl << "deque 排序部分" << endl;
	sort(d1.begin(), d1.end());
	cout << "d1进行sort()排序之后的结果是：";
	dequeprintf(1, d1);
}

3.4、栈和队列（stack && queue）

3.4.1、栈（stack）

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口
在这里插入图片描述
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop

功能描述：栈容器常用的对外接口
构造函数：

stack stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

赋值操作：

stack& operator=(const stack &stk); //重载等号操作符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

3.4.2、队列（queue）

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

在这里插入图片描述
队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop

功能描述：栈容器常用的对外接口
构造函数：

queue que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

赋值操作：

queue& operator=(const queue &que); //重载等号操作符

数据存取：

push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

#include <iostream>
using namespace std;
#include <stack>
#include <queue>
class person11
{
public:
	person11(string name, string task)
	{
		this->name = name;
		this->task = task;
	}

public:
	string name;
	string task;
};

/*堆和栈*/
void stackandqueue(void)
{
	/*stack*/
	/*
	赋值操作：
	stack& operator=(const stack &stk); //重载等号操作符
	数据存取：
	push(elem); //向栈顶添加元素
	pop(); //从栈顶移除第一个元素
	top(); //返回栈顶元素
	大小操作：
	empty(); //判断堆栈是否为空
	size(); //返回栈的大小
	*/
	stack<int> s;
	if (s.empty())
	{
		cout << "s-栈是空的，清插入数据" << endl;
	}

	//入栈--插入数据
	for (int i = 0; i < 10; i++)
	{
		s.push(i * 10);
	}
	if (s.empty())
	{
		cout << "s-栈是空的，清插入数据" << endl;
		return;
	}
	else
		cout << "堆栈的大小是：" << s.size() << endl;
	//出栈
	cout << "栈顶的元素是：";
	while (!s.empty())
	{
		cout << s.top() << " ";//返回栈顶的元素
		s.pop(); //移除栈顶的元素
	}
	cout << endl;
	cout << "栈的大小是：" << s.size() << endl;



	/*queue--队列*/
	queue<person11>q;
	//定义成员
	person11 p1("悟空", "保护唐曾");
	person11 p2("悟净", "挑担");
	person11 p3("悟能", "吃");
	person11 p4("唐曾", "献爱心");

	//添加到队列
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	//打印
	cout << "队列大小是：" << q.size() << endl;
	while (!q.empty())
	{
		cout << "返回队列的首个元素的姓名：" << q.front().name << " 任务：" << q.front().task << endl;
		
		cout << "返回队列的最后一个元素的姓名：" << q.back().name << " 任务：" << q.back().task << endl;
		cout  << endl;
		q.pop();//移除首个元素
	}
	cout << "队列大小是：" << q.size() << endl;
}

在这里插入图片描述

3.5、list容器

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
STL中的链表是一个双向循环链表

在这里插入图片描述
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list的缺点：

链表灵活，但是空间(指针域) 和时间（遍历）额外耗费较大

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中List和vector是两个最常被使用的容器，各有优缺点

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

void listproject(void);

void listprintf(list<int>& l)
{
	if (l.empty())//判断是否为空
	{
		cout << "该容器为空" << endl;
		return;
	}

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

bool myCompare(int val1, int val2)
{
	return val1 > val2;
}

void listtest(void)
{
	/*构造函数*/
	//list<T> lst; //list采用采用模板类实现,对象的默认构造形式：
	//list(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
	//list(n, elem); //构造函数将n个elem拷贝给本身。
	//list(const list & lst); //拷贝构造函数。
	list <int> l1;
	//尾插
	for (int i = 0; i < 10; i++)
	{
		l1.push_back(i*10);
	}
	//头插
	for (int i = 0; i < 10; i++)
	{
		l1.push_front(i+10);
	}
	cout << "l1 = ";
	listprintf(l1);
	
	list<int>l2(l1.begin(),l1.end());
	cout << "l2 = ";
	listprintf(l2);

	list <int>l3(10, 999);
	cout << "l3 = ";
	listprintf(l3);

	list <int>l4(l3);
	cout << "l4 = ";
	listprintf(l4);

	/*赋值和交换*/
	//assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
	//assign(n, elem); //将n个elem拷贝赋值给本身。
	//list& operator=(const list & lst); //重载等号操作符
	//swap(lst); //将lst与本身的元素互换。
	list<int>l5;
	l5.assign(l1.begin(), l1.end());
	cout << "l5 = ";
	listprintf(l5);

	list<int>l6;
	l6.assign(10,88);
	cout << "l6 = ";
	listprintf(l6);

	list<int>l7;
	l7 = l6;
	cout << "l7 = ";
	listprintf(l7);

	cout << "l4与l6交换以后:" << endl;
	l6.swap(l4);
	cout << "l4 = ";
	listprintf(l4);
	cout << "l6 = ";
	listprintf(l6);

	/*容器大小*/
	//size(); //返回容器中元素的个数
	//empty(); //判断容器是否为空
	//resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
	如果容器变短，则末尾超出容器长度的元素被删除。
	//resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
	如果容器变短，则末尾超出容器长度的元素被删除。
	cout << "l1的大小是：" << l1.size() << endl;
	l2.resize(10);
	cout << "重新指定l2的大小：= ";
	listprintf(l2);

	/*list 插入和删除*/
	//push_back(elem);//在容器尾部加入一个元素
	//pop_back();//删除容器中最后一个元素
	//push_front(elem);//在容器开头插入一个元素
	//pop_front();//从容器开头移除第一个元素
	//insert(pos, elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
	//insert(pos, n, elem);//在pos位置插入n个elem数据，无返回值。
	//insert(pos, beg, end);//在pos位置插入[beg,end)区间的数据，无返回值。
	//clear();//移除容器的所有数据
	//erase(beg, end);//删除[beg,end)区间的数据，返回下一个数据的位置。
	//erase(pos);//删除pos位置的数据，返回下一个数据的位置。
	//remove(elem);//删除容器中所有与elem值匹配的元素。
	list<int>::iterator it = l5.begin();
	it++;
	it++;
	l5.insert(it, 8888);
	cout << "l5 = ";
	listprintf(l5);

	l5.insert(++l5.begin(), 2, 77777);
	cout << "l5 = ";
	listprintf(l5);
	l5.erase(++l5.begin(), it);
	cout << "l5 = ";
	listprintf(l5);
	l5.clear();
	cout << "l5 = ";
	listprintf(l5);

	/*list 数据存取*/
	//front(); //返回第一个元素。
	//back(); //返回最后一个元素。
	cout << "l1的第一个元素是：" << l1.front() << endl;
	cout << "l1的最后一个元素是：" << l1.back() << endl;

	/*list的反转和排序*/
	//reverse(); //反转链表
	//sort(); //链表排序--默认从小到大
	cout << "l2反转之后的内容是：";
	l2.reverse();
	listprintf(l2);

	cout << "l1 = ";
	l1.sort();//从小到大
	listprintf(l1);

	cout << "l1 = ";
	l1.sort(myCompare);//从大到小
	listprintf(l1);

	listproject();

}
class person12
{
public:
	person12(string name, int age, int height)
	{
		this->name = name;
		this->age = age;
		this->height = height;
	}
public:
	string name;
	int age;
	int height;

};
bool campareperson12(person12& p1, person12& p2)
{
	if (p1.age == p2.age)
		return p1.height > p2.height;
	else
		return p1.age < p2.age;
}
void listproject(void)
{
	int tempage = 0;
	int tempheight = 0;

	list<person12>p;
	person12 p1("悟空", 1825, 18000);
	person12 p2("悟净", 25, 25);
	person12 p3("悟能", 8741, 1589);
	person12 p4("唐曾", 25, 12);
	person12 p5("如来", 25, 188000);
	person12 p6("观音", 48595, 2895);
	person12 p7("二郎神", 1024, 7859);
	person12 p8("哮天犬", 25, 4564);
	person12 p9("雷震子", 763210, 7859);
	person12 p10("哪吒", 25, 74582);

	//添加进列表	
	p.push_back(p1);
	p.push_back(p2);
	p.push_back(p3);
	p.push_back(p4);
	p.push_back(p5);
	p.push_back(p6);
	p.push_back(p7);
	p.push_back(p8);
	p.push_back(p9);
	p.push_back(p10);

	for (list<person12>::iterator it = p.begin(); it != p.end(); it++)
	{
		cout << "姓名：" << it->name << "\t年龄：" << it->age << "\t身高：" << it->height << endl;
	}
	cout << "-----------------------------------------------" << endl;
	p.sort(campareperson12);
	for (list<person12>::iterator it = p.begin(); it != p.end(); it++)
	{
		cout << "姓名：" << it->name << "\t年龄：" << it->age << "\t身高：" << it->height << endl;
	}
}

在这里插入图片描述

3.6、set和multiset容器

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


void setprintf(set<int>& s)
{
	if (s.empty())//判断是否为空
	{
		cout << "该容器为空" << endl;
		return;
	}

	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
//创建仿函数
class mycampare
{
public:
	bool operator()(int v1, int v2)const
	{
		return v1 > v2;
	}
};
class person13
{
public:
	person13(string name, int age, int height)
	{
		this->name = name;
		this->age = age;
		this->height = height;
	}

public:
	string name;
	int age;
	int height;
};
class mycampareperson13
{
public:
	bool operator()(const person13 &p1, const person13 &p2)const
	{
		return p1.age > p2.age;
	}
};
//所有元素都会在插入时自动被排序
//set/multiset属于关联式容器，底层结构是用二叉树实现
//set和multiset区别：
//set不允许容器中有重复的元素
//multiset允许容器中有重复的元素
void setest(void)
{
	/*构造函数*/
	//构造：
	//set<T> st; //默认构造函数：
	//set(const set & st); //拷贝构造函数
	//赋值：set& operator=(const set & st); //重载等号操作符

	set<int>s1;


	//插入11个数据，其中有两个89
	s1.insert(89);
	s1.insert(47);
	s1.insert(86);
	s1.insert(35);
	s1.insert(59);
	s1.insert(46);
	s1.insert(73);
	s1.insert(64);
	s1.insert(21);
	s1.insert(89);
	s1.insert(36);

	cout << "s1的大小是：" << s1.size() << endl;
	setprintf(s1);
	set<int>s2(s1);
	setprintf(s2);
	set<int>s3;
	s3 = s1;
	setprintf(s3);
	/*
	set容器插入数据时用insert
	set容器插入数据的数据会自动排序
	*/


	/*set大小和交换*/
	//统计set容器大小以及交换set容器
	//size(); //返回容器中元素的数目
	//empty(); //判断容器是否为空
	//swap(st); //交换两个集合容器
	s1.swap(s3);
	setprintf(s1);
	setprintf(s3);

	/* set插入和删除*/
	//insert(elem); //在容器中插入元素。
	//clear(); //清除所有元素
	//erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
	//erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
	//erase(elem); //删除容器中值为elem的元素。
	s1.erase(++s1.begin());
	setprintf(s1);

	/*set查找和统计*/
	//find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
	//count(key); //统计key的元素个数
	set<int>::iterator pos = s1.find(73);
	if (pos != s1.end())
	{
		cout << "数据查找成功：" << *pos << endl;
	}
	else
	{
		cout << "暂无该数据" << endl;
	}
	int num = s1.count(86); 
	cout << "num = " << num << endl;

	//set不可以插入重复数据，而multiset可以
	//set插入数据的同时会返回插入结果，表示插入是否成功
	//multiset不会检测数据，因此可以插入重复数据
	s1.insert(89);

	pair<set<int>::iterator, bool> ret = s1.insert(89);
	if (ret.second)
	{
		cout << "插入成功" << endl;
	}
	else
		cout << "插入失败" << endl;
	
	multiset<int> m1;
	m1.insert(10);
	m1.insert(10);
	for (multiset<int>::iterator it = m1.begin(); it != m1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	/*对组pair*/
	/*两种方式*/
	//第一种方式
	pair<string, int> p1("大锤", 52);
	cout << "姓名：" << p1.first << " 年龄：" << p1.second << endl;

	pair<string, int>p2 = make_pair("大猫", 20);
	cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;

	/*set排序*/
	//默认升序
	//降序实现（使用仿函数）
	set<int, mycampare> s4;
	s4.insert(89);
	s4.insert(47);
	s4.insert(86);
	s4.insert(35);
	s4.insert(59);
	s4.insert(46);
	s4.insert(73);
	s4.insert(64);
	s4.insert(21);
	s4.insert(89);
	s4.insert(36);
	for (set<int, mycampare>::iterator it = s4.begin(); it != s4.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	//自定义数据类型--对于自定义数据类型，set必须指定排序规则才可以插入数据
	set<person13,mycampareperson13>s5;
	person13 p4("悟空", 1825, 18000);
	person13 p5("悟净", 25, 25);
	person13 p6("悟能", 8741, 1589);
	s5.insert(p4);
	s5.insert(p5);
	s5.insert(p6);
	for (set<person13, mycampareperson13>::iterator it = s5.begin(); it != s5.end(); it++)
	{
		cout << "姓名：" << it->name << " 年龄：" << it->age << " 身高：" << it->height << endl;
	}
	cout << endl;
}

在这里插入图片描述

3.7、map/ multimap容器

map基本概念

简介：map中所有元素都是pair

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

本质：map/multimap属于关联式容器，底层结构是用二叉树实现。

优点：

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

map和multimap区别：

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

#include <iostream>
using namespace std;
#include <map>
#include <vector>
#include <time.h>

void empgroup(void);

void mapprintf(map<int, int>& m)
{
	if (m.empty())
	{
		cout << "该容器为空" << endl;
		return;
	}

	for (map<int, int>::iterator i = m.begin(); i != m.end(); i++)
	{
		cout << i->second << " ";
	}
	cout << endl;
}

class mapcampare
{
public:
	bool operator()(int a, int b)const
	{
		return a > b;
	}
};

void maptest(void)
{
	map<int, int>m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(10, 80));
	m1.insert(pair<int, int>(2, 50));
	m1.insert(pair<int, int>(4, 20));
	m1.insert(pair<int, int>(3, 70));
	mapprintf(m1);
	/*
	size(); //返回容器中元素的数目
	empty(); //判断容器是否为空
	swap(st); //交换两个集合容器
	*/
	cout << "map容器的大小是：" << m1.size() << endl;
	map<int, int>m2;
	m2.insert(make_pair(24,678));
	m2.insert(make_pair(2,34));
	m2.insert(make_pair(45,670));
	m2.insert(make_pair(89,3456));
	m2.insert(make_pair(20,531));
	mapprintf(m2);
	/*m2.swap(m1);
	mapprintf(m1);
	mapprintf(m2);*/
	m2.erase(m2.begin());
	m2.erase(20); 
	mapprintf(m2);

	map<int, int>::iterator pos = m2.find(89);
	if (pos != m2.end())
	{
		cout << "查找成功：" << "key = " << pos->first << "  value = " << pos->second << endl;
	}
	else
	{
		cout << "查找失败" << endl;
	}

	//map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则
	map<int, int, mapcampare> m3;
	m3.insert(make_pair(1, 56));
	m3.insert(make_pair(2, 48));
	m3.insert(make_pair(3, 23));
	for (map<int, int, mapcampare>::iterator it = m3.begin(); it != m3.end(); it++)
	{
		cout << it->second << " ";
	}
	cout << endl;
	empgroup();
}
class mapworker
{
public:
	/*mapworker() {};
	mapworker(string name, int salary)
	{
		this->name = name;
		this->salary = salary;
	}*/

public:
	string name;
	int salary;
};

void creatworkermassage(vector<mapworker>&v)
{
	string allname = "abcdefghij";
	
	for (int i = 0; i < 10; i++)
	{
		mapworker worker;
		worker.name = "员工";
		worker.name += allname[i];
		worker.salary = rand() % 10000 + 10000;
		v.push_back(worker);

	}
}

void insertworker(vector<mapworker>& v, multimap<int, mapworker>& m)
{

	for (vector<mapworker>::iterator i = v.begin(); i != v.end(); i++)
	{
		int num = rand() % 3;
		cout << " " << num;
		m.insert(make_pair(num, *i));
	}
	cout << endl;
}

void showmapmassage(multimap<int,mapworker>&m)
{
	int count = 0;
	multimap<int, mapworker>::iterator pos;
	cout << "市场部" << endl;
	pos = m.find(0);
	count = m.count(0);
 	for (int i=0;pos!=m.end()&&i<count; i++, pos++)
	{
		cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;
	}

	cout << "工程部" << endl;
	pos = m.find(1);
	count = m.count(1);
	for (int i = 0; pos != m.end() && i < count; i++, pos++)
	{
		cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;
	}

	cout << "董事办" << endl;
	pos = m.find(2);
	count = m.count(2);
	for (int i = 0; pos != m.end() && i < count; i++, pos++)
	{
		cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;
	}
}
void empgroup(void)
{
	/*srand((unsigned int)time(NULL));*/
	vector<mapworker> v;
	multimap<int, mapworker> m;
	creatworkermassage(v);
	insertworker(v, m);
	showmapmassage(m);
}

在这里插入图片描述

4、STL-函数对象

4.1、函数对象

函数对象概念

重载函数调用操作符的类，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：

函数对象(仿函数)是一个类，不是一个函数

特点：

函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

#include <iostream>
using namespace std;

/*
-函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
-函数对象超出普通函数的概念，函数对象可以有自己的状态
-函数对象可以作为参数传递
*/

class myprintf
{
public:
	myprintf()
	{
		count = 0;
	}

	int operator()(int a, int b)
	{
		return a + b;
	}
	void operator()(string test)
	{
		cout << test << endl;
		count++;
	}

public:
	int count;
};

void test03func(myprintf& mp, string ddd)
{
	mp(ddd);
}

void func_obj(void)
{
	myprintf mp1;
	cout << mp1(3, 5) << endl;

	mp1("4656565");
	mp1("4df6565");
	mp1("4355465");
	mp1("46dfhfg");
	test03func(mp1, "65656");
	cout << "调用次数是：" << mp1.count << endl;
}

在这里插入图片描述

4.2、谓词

概念：

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词

#include <iostream>
using namespace std;

#include <vector>
#include <algorithm>
#include <time.h>
/*
概念：
返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
*/

//创建谓词
class predicate
{
public:
	bool operator()(int val)//一元谓词
	{
		return val > 5;
	}
	bool operator()(int v1, int v2)//二元谓词
	{
		return v1 > v2;
	}
};

void predicateprintf(vector<int>& v)
{
	for (vector<int>::iterator i = v.begin(); i != v.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
}

void predicatetest(void)
{
	//srand((unsigned int)time(NULL));
	int score = 0;
	vector<int> v1;
	for (int i = 0; i < 15; i++)
	{
		
		score = rand() % 20;
		v1.push_back(score);
	}

	//一元谓词
	vector<int>::iterator pos = find_if(v1.begin(),v1.end(), predicate());
	if (pos != v1.end())
	{
		cout << "找到大于5的数" << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
	cout << "排序前：";
	predicateprintf(v1);

	cout << "排序后：";
	sort(v1.begin(),v1.end());
	predicateprintf(v1);

	cout << "排序后：";
	sort(v1.begin(), v1.end(),predicate());
	predicateprintf(v1);
}

在这里插入图片描述

4.3、内建函数对象

概念：

STL内建了一些函数对象

分类:

算术仿函数
关系仿函数
逻辑仿函数

用法：

这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件 #include

#include <iostream>
using namespace std;

#include <functional>
#include <algorithm>
#include <vector>

void functionaltest(void)
{
	/*
	算数仿函数
	
	template<class T> T plus<T> //加法仿函数
	template<class T> T minus<T> //减法仿函数
	template<class T> T multiplies<T> //乘法仿函数
	template<class T> T divides<T> //除法仿函数
	template<class T> T modulus<T> //取模仿函数
	template<class T> T negate<T> //取反仿函数
	*/
	negate<int>n;
	cout << "取反仿函数（negate）:" << n(80) << endl;
	plus<int>p;
	cout << "加法仿函数（plus）:" << p(80, 20) << endl;
	minus<int>mi;
	cout << "减法仿函数（minus）:" << mi(80, 20) << endl;
	multiplies<int>mu;
	cout << "乘法仿函数（multiplies）:" << mu(80, 20) << endl;
	divides<int>d;
	cout << "除法仿函数（divides）:" << d(80, 35) << endl;
	modulus<int>mo;
	cout << "取模仿函数（余数modulus）:" << mo(80, 30) << endl;

	/*
	关系仿函数

	template<class T> bool equal_to<T> //等于
	template<class T> bool not_equal_to<T> //不等于
	template<class T> bool greater<T> //大于
	template<class T> bool greater_equal<T> //大于等于
	template<class T> bool less<T> //小于
	template<class T> bool less_equal<T> //小于等于
	*/
	vector<int>v1;
	int num;
	for (int i = 0; i < 10; i++)
	{
		num = rand() % 50;
		v1.push_back(num);
	}
	cout << "排序前";
	for (vector<int>::iterator i = v1.begin(); i != v1.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;

	sort(v1.begin(), v1.end(), greater<int>());

	cout << "排序后";
	for (vector<int>::iterator i = v1.begin(); i != v1.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;

	/*
	逻辑仿函数

	template<class T> bool logical_and<T> //逻辑与
	template<class T> bool logical_or<T> //逻辑或
	template<class T> bool logical_not<T> //逻辑非
	*/
	vector<bool>v2;
	v2.push_back(true);
	v2.push_back(false);
	v2.push_back(true);
	v2.push_back(false);

	for (vector<bool>::iterator i = v2.begin(); i != v2.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;

	//逻辑非
	//需要包含 算法和内建（algorithm和functional） 头文件
	vector<bool>v3;
	v3.resize(v2.size());
	transform(v2.begin(), v2.end(), v3.begin(), logical_not<bool>());
	for (vector<bool>::iterator i = v3.begin(); i != v3.end(); i++)
	{
		cout << *i << " ";
	}
	cout << endl;
}

在这里插入图片描述

5、STL-常用算法

后续在写，忙不过来了

嵌入式小白白

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++学习记录---2

本片为提高篇1、模板1.1、函数模板模板的特点：模板不可以直接使用，它只是一个框架模板的通用并不是万能的C++另一种编程思想称为泛型编程，主要利用的技术就是模板C++提供两种模板机制:函数模板和类模板函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。template 函数声明或定义解释：template — 声明创建模板typename — 表面其后面的符号是一种数据类型，可以用class代替T — 通用的数
复制链接

扫一扫