本片为提高篇
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-常用算法
后续在写,忙不过来了