零、GDB 调试选项
GDB 调试选项
-
启动程序调试： 使用
gdb命令启动GDB调试器，并在后面加上要调试的可执行文件名称，如：gdb my_program。 -
设置断点： 使用
break或b命令设置断点。例如，break main在程序的main函数处设置断点。 -
运行程序： 使用
run或r命令来运行程序。可以在run命令后加上程序的参数。 -
单步调试： 使用
step或s命令进行单步调试。step命令进入函数，next或n命令跳过函数。 -
打印变量： 使用
print或p命令来打印变量的值。例如，print x会打印变量x的值。 -
显示源代码： 使用
list命令来显示源代码。list命令默认显示当前行及其附近的源代码。 -
查看堆栈： 使用
backtrace或bt命令查看函数调用堆栈。 -
查看寄存器值： 使用
info registers或i r命令来查看寄存器的值。 -
查看内存内容： 使用
x命令来查看内存的内容。例如，x/10x addr查看从地址addr开始的十六进制内容。 -
设置条件断点： 使用
break if命令设置条件断点。例如，break main if i == 5会在main函数中i等于5时设置断点。 -
查看线程信息： 使用
info threads命令查看当前程序的所有线程信息。 -
附加到正在运行的进程： 使用
attach命令可以附加到正在运行的进程进行调试。 -
分析崩溃信息： 在程序崩溃时，使用
core命令或-c选项可以加载核心转储文件进行调试。
一、linux配置Git
sudo apt install git#下载安装Git
git --version#查看Git版本
1.配置用户名与邮箱
完成安装后就可以开始配置git了，通过下面的两条命令来配置用户名和邮箱（这里的邮箱地址我用的是我的github账号下的邮箱）
#添加用户名和邮箱
git config --global user.name "JACKEY666911"
git config --global user.email "1401885521@qq.com"
#查看添加后的结果
git config email.id
git config user.name
2.生成git的密钥
1.建立密钥文件
ssh-keygen -C "1401885521@qq.com" -t rsa
2.复制密钥到Github上
cd ~/.ssh
用ls查看文件列表
打开id_rsa.pub文件将里面内容全部复制；
vim id_rsa.pub
复制后登录我们的github账号,添加上述秘钥
然后测试连接
ssh -T git@github.com
二、Git的使用
0.git的四区五态
- workspace：工作区
- staging area：暂存区/缓存区
- local repository：版本库或本地仓库
- remote repository：远程仓库
文件的5种状态：
- 未修改（Origin）
- 已修改（Modified）
- 已暂存（Staged）
- 已提交（Committed）
- 已推送（Pushed）
工作区中的文件初始的状态是未修改，当我们修改文件后，其状态改变为已修改，git diff可以查看已经修改但未暂存的文件。(git diff后输入q可以退出)
通过git add命令可以把已修改的文件添加到暂存区，git diff --cached可以查看已暂存，但未提交的文件。
通过git commit进行代码提交到本地仓库，git diff {本地分支} {远程分支}可以查看已提交本地，但未推送到远程的分支。
通过git push命令将本地分支推送到远程分支。
1.在GitHub上创建仓库
- 登陆GitHub，然后找到“New”按钮，创建一个新的仓库，如下图
2.GIT基本命令
本地命令
#初始化仓库
git init
git init myrepo
#将文件添加到暂存库
git add .
git add first.txt
#提交暂存区到本地仓库
git commit -m "xxxx"
#查看git当前状态，显示有变更的文件
git status
#比较文件的不同，即暂存区和工作区的差异
git diff
git rm filename
#将文件从暂存区和工作区中删除。
#git rm 后恢复文件
git rm d.c
#使用git reset重置所有缓存区操作
git reset
#重置完成之后在使用git checkout命令将文件取消操作
git checkout d.c
撤销回滚
git reset
#git reset重置所有缓存区操作
git reset --hard
git reset --hard 要回滚id
git reset --hard #进行已修改或者暂存，但未提交文件的回退
git reset --hard origin/master #进行已提交，但未推送的版本回退
git reset --hard HEAD^ #先回退到上一个版本
--soft 、--mixed以及--hard是三个恢复等级。
#使用--soft就仅仅将头指针恢复，已经add的暂存区以及工作空间的所有东西都不变。
#如果使用--mixed，就将头恢复掉，已经add的暂存区也会丢失掉，工作空间的代码什么的是不变的。
#如果使用--hard，那么一切就全都恢复了，头变，aad的暂存区消失，代码什么的也恢复到以前状态。
#将文件撤销回到最近一次修改的状态
git checkout --file
#从本地仓库拉取文件,放弃特定文件中的本地更改
git checkout HEAD
分支相关
git创建分支
#创建分支
git branch dev
#切换分支
git checkout #切换参数，通常用来切换分支仓库
git checkout dev
#切换分支
git checkout master
#git checkout -b参数来创建一个分支，创建完成分支后会自动切换过去
git checkout -b dev
git分支查看
#查看当前属于哪个分支
git branch
#查看当前所有分支
git branch -a
git修改分支名称
git branch -m 分支名 新的分支名
git合并分支
#当我们新建分支并做完工作之后，想要把分支提交至master，只需要切换到master仓库，并执行git merge 分支名
git checkout master
git merge dev
git删除本地分支
git branch -D
git删除远程分支
git push origin --delete 远程分支名
查询和提交历史
#查看提交记录
git log
#查看单个文件可回滚版本
git log filename
#单个文件回滚
git reset 1a1e91bf37add6c3914ebf20428efc0a7cea33f3 min.c
#查看看所有分支的所有操作记录（包括（包括commit和reset的操作），包括已经被删除的commit记录。
git reflog
git ls-files
#查看暂存区的文件
更新和发布
#远程仓库操作
git remote
#查看远程仓库详细信息
git remote -v
#从远程获取代码库到本地仓库,但不要集成到HEAD中
git fetch/clone
#把远程全部分支拉取下来，同时也包括这些分支的仓库版本，log日志等，这个操作不会进行合并
git fetch xxxx
#下载远程代码并合并
git pull
#上传远程代码并合并
git push
两个新命令
git switch
#switch是用来切换分支与新增分支的
#切换分支
git switch dev
#合并一个分支必须加上-b
git switch -b dev
#创建分支则是-c
git switch -c dev
git restore
#撤销提交与修
#将文件从暂存区删除
git restore file
3.本地仓促和远程仓库
1.删除远程仓库地址
git remote remove origin
可以通过一下命令查看是否删除成功，无内容输出意味着已经删除成功了！
git remote -v
2.我们可以将本地仓库的内容推送到你github仓库。使用该命令，连接到github上的仓库(远程仓库关联)：
1)通过SSH的方法
git branch -M main#第一步
git remote add origin git@github.com:用户名/仓库名.git#第二步
git remote add origin git@github.com:JACKEY666911/my-first-repo.git
2）通过HTTPS的方法
先获取github的token，然后执行下面的操作
git remote add origin https://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@github.com/用户名/仓库名.git
git remote add origin https://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@github.com/JACKEY666911/HttpServer.git
git remote set-url origin https://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@github.com/JACKEY666911/HttpServer.git
git remote set-url origin https://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@github.com/JACKEY666911/wulala.git
将这个SSH链接复制到git remote add origin后面，origin是本地仓库在远程仓库的别名，可以修改。下面结果显示成功关联。
3.将本地仓库push到远程仓库，远程仓库就能看到本地仓库的内容
git push -u origin main/master
push：将本地仓库与远程仓库合并
-u：将本地仓库分支与远程仓库分支一起合并，就是说将master的分支也提交上去，这样你就可以在远程仓库上看到你在本地仓库的master中创建了多少分支，不加这个参数只将当前的master与远程的合并，没有分支的历史记录，也不能切换分支
origin：远程仓库的意思，如果这个仓库是远程的那么必须使用这个选项
master：提交本地matser分支仓库
#之后的提交
git push origin master
4.git将远程仓库关联到本地和拉取指定分支、切换远程分支
远程关联到本地时，可以用git clone，上传的代码在远程仓库中有一个默认的main和master，由于我们最初上传的分支是master，所以github给我们创建了一个新的分支叫master，并没有关联到mian中，我们拉取时，默认拉取的是main分支
git clone -b分支名 仓库地址来指定分支
git clone -b master git@github.com:JACKEY666911/my-first-repo.git
本地仓库pull远程仓库的内容，Github上修改的内容可以被pull到本地仓库
git pull origin1 main
三、CMake
cmake重要指令和常用变量
CMakeLists.txt 内容
#制定cmake最小版本要求
cmake_minimum_required (VERSION 2.8)
#制定工程名称
project (learn_cmake)
#生成可执行文件
add_executable(hello hello.cpp)
#显示定义变量,定义变量SRC，其值为sayhello.cpp hello.cpp
set(SRC sayhello.cpp hello.cpp)
#向工程添加多个特定的头文件搜索路径
include_directories
include_directories(./inc_dir1 ./inc_dir2)
#把dir目录中的所有源文件都储存在var变量中
aux_source_directory(dir var)
aux_source_directory(. SRC_LIST)
#向工程添加多个特定的库文件搜索路径
link_directories(./lib)
#生成动态库和静态库
add_library(lib_name STATIC/SHARED src)
# 参数lib_name：是要生成的库名称，
# 参数STATIC/SHARED：指定生成静态库或动态库，
# 参数src：指明库的生成所需要的源文件
#LIBRARY_OUTPUT_PATH 是cmake系统变量，项目生成的库文件都放在这个目录下。这里我指定库生成到lib目录
#PROJECT_BINARY_DIR是cmake系统变量，是执行cmake命令的目录
set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/../lib)
#添加编译选项
add_compile_options(-Wall -O2 -std=c++11)
#为target添加需要链接的共享库
target_link_linraries(main hello)
#在当前工程中添加存放源文件的子目录
#添加src子目录，src中需要有CMakeLists.txt
add_subdirectory(src)
常用变量
sudo vim /etc/vim/vimrc
四、共享文件夹消失解决
sudo apt install open-vm-tools
sudo vim /etc/fstab
.host:/ /mnt/hgfs fuse.vmhgfs-fuse allow_other 0 0#添加到最后一行
五、shell命令
网络安装和卸载
sudo apt install "包的名称"
sudo apt-get purge "包的名称"
sudo apt-get remove "包的名称"
软件包下载的路径
/var/cache/apt/archives/
本地安装
sudo dpkg -x 软件包全称 目标名称
sudo dpkg -i
apt-get download libevent-dev#下载安装包到本地，不安装
#解压命令
sudo apt-get install libevent-dev
安装sqlite3
SQLite下载页面,从源代码区下载 sqlite-autoconf-\*.tar.gz。
使用以下shell命令
$ tar xvzf sqlite-autoconf-3071502.tar.gz
$ cd sqlite-autoconf-3071502
$ ./configure
$ make
$ make install
很重要的一步
sudo apt-get install sqlite3-dev#安装库
六、vscode远程连接ubuntu
1.在vscode中下载ssh插件
ssh jack@192.168.4.62
一直下一步，然后输入ubuntu的用户密码
2.免密钥
在git.bash中输入下面的命令，生成密钥
ssh-keygen -t rsa -C "jack@192.168.4.62" -f ~/.ssh/ubuntu_rsa#生成ssh的私钥和公钥
将密钥拷贝到远程主机当中
ssh-copy-id -i ~/.ssh/linux_rsa.pub linux@192.168.4.55
最后在vscode的ssh配置文件中添加密钥路径
最后，重启vscode
七、HTTP
HTTP URL
通过HTTP或者HTTPS协议 请求的资源由统一资源标示符（Uniform Resource Identifiers）来标识。
http://host[":"port][abs_path]
http://www.haogu.com:8080/news/index.php?boardID=5&ID=24618&page=1#name
- 协议部分：该URL的协议部分为“http：”，这代表网页使用的是HTTP协议。在Internet中可以使用多种协议，如HTTP，FTP等等本例中使用的是HTTP协议。在"HTTP"后面的“//”为分隔符。
- 域名部分：该URL的域名部分为“www.hg-zn.com”。一个URL中，也可以使用IP地址作为域名使用。
- 端口部分：跟在域名后面的是端口，域名和端口之间使用“:”作为分隔符。端口不是一个URL必须的部分，如果省略端口部分，将采用默认端口80，8080端口是被用于WWW代理服务的，可以实现网页浏览，经常在访问某个网站或使用代理服务器的时候，会加上":8080"端口号。另外Apache Tomcat web server安装后，默认的服务端口就是8080.
- 虚拟目录部分：从域名后的第一个“/”开始到最后一个“/”为止，是虚拟目录部分。虚拟目录也不是一个URL必须的部分。本例中的虚拟目录是“/news/”
- 文件名部分：从域名后的最后一个“/”开始到“？”为止，是文件名部分，如果没有“?”,则是从域名后的最后一个“/”开始到“#”为止，是文件部分，如果没有“？”和“#”，那么从域名后的最后一个“/”开始到结束，都是文件名部分。本例中的文件名是“index.asp”。文件名部分也不是一个URL必须的部分，如果省略该部分，则使用默认的文件名。
- 参数部分：从“？”开始到“#”为止之间的部分为参数部分，又称搜索部分、查询部分。本例中的参数部分为“username=lisi&password=24618&page=1”。参数可以允许有多个参数，参数与参数之间用“&”作为分隔符。
- 锚部分：从“#”开始到最后，都是锚部分,#是用来指导浏览器动作的，#后面的字符串，都会被浏览器解析为位置标识符。本例中的锚部分是“name”。锚部分也不是一个URL必须的部分。
HTTP请求
1.请求行由请求Method, URI 字段和HTTP Version三部分构成
GET /example.html HTTP/1.1 (CRLF)
POST /chapter17/user.html HTTP/1.1
get请求:
将请求参数追加在url后面，不安全
url长度限制get请求方式数据的大小
没有请求体
post请求：
请求参数在请求体处，较安全。
请求数据大小没有显示
只有表单设置为method=“post”才是post请求
常见get请求:地址栏直接访问、、等
HTTP协议的方法有：
GET： 请求获取Request-URI所标识的资源
POST： 在Request-URI所标识的资源后增加新的数据
HEAD： 请求获取由Request-URI所标识的资源的响应消息报头
PUT： 请求服务器存储或修改一个资源，并用Request-URI作为其标识
DELETE： 请求服务器删除Request-URI所标识的资源
TRACE： 请求服务器回送收到的请求信息，主要用于测试或诊断
CONNECT： 保留将来使用
OPTIONS： 请求查询服务器的性能，或者查询与资源相关的选项和需求
**2.HTTP请求头:消息报头由一系列的键值对组成，允许客户端向服务器端发送一些附加信息或者客户端自身的信息，**主要包括：
3.HTTP请求正文
只有在发送POST请求时才会有请求正文，GET方法并没有请求正文。
HTTP响应
**1.状态行也由三部分组成，包括HTTP协议的版本，状态码，以及对状态码的文本描述。**例如：
HTTP/1.1 200 OK （CRLF）
状态代码有三位数字组成，第一个数字定义了响应的类别，且有五种可能取值：
1xx：指示信息 - 表示请求已接收，继续处理
2xx：成功 - 表示请求已被成功接收、理解、接受
3xx：重定向 - 要完成请求必须进行更进一步的操作
4xx：客户端错误 - 请求有语法错误或请求无法实现
5xx：服务器端错误 - 服务器未能实现合法的请求
200： OK - 客户端请求成功 400： Bad Request - 客户端请求有语法错误，不能被服务器所理解
2.HTTP响应报头，响应头也是用键值对k：v。
服务器通过响应头来控制浏览器的行为，不同的头浏览器操作不同
3.HTTP响应正文
服务器发送给浏览器的正文，即我们真正要的“干货” ；响应体，响应体是服务器回写给客户端的页面正文，浏览器将正文加载到内存，然后解析渲染 显示页面内容
application/json ：
application/json 这个Content-Type作为响应头大家肯定不陌生。
实际上，现在越来越多的人把它作为请求头，用来告诉服务端消息主体是序列化后的 JSON 字符串。由于 JSON 规范的流行，除了低版本 IE 之外的各大浏览器都原生支持 JSON.stringify，服务端语言也都有处理 JSON 的函数，使用 JSON 不会遇上什么麻烦。 JSON 格式支持比键值对复杂得多的结构化数据，这一点也很有用。
POST http://39.108.107.149:8080/vk/app/rest/ddp/vkIndexsService/queryVkIndxs HTTP/1.1
Content-Type: application/json
cache-control: no-cache
Postman-Token: 5014bc39-0777-49d5-bb8a-73db9a981e49
User-Agent: PostmanRuntime/7.1.1
Accept: */*
Host: 39.108.107.149:8080
cookie: JSESSIONID=6CD80B7028062D9190717CEE001C3194
accept-encoding: gzip, deflate
content-length: 132
Connection: keep-alive
Content-Type 为json数据格式的响应正文
{
"name":"828验证继承",
"getresultType":"2",
"createTime":"Tue Sep 11 2018 00:00:00 GMT+0800 (中国标准时间)"
}
八、JSON
JSON是一种轻量型的数据交换格式。
JSON是独立于任何编程语言的。
1.Vaule 类，用于封装类
// 序列化得到的字符串有样式 -> 带换行 -> 方便阅读
// 写配置文件的时候
std::string toStyledString() const;
2.FastWriter类：将Value对象中的数据序列化为字符串
// 将数据序列化 -> 单行
// 进行数据的网络传输
std::string Json::FastWriter::write(const Value& root);
3.Reader用于解析Json，反序列化, 将json字符串 解析成 Value 类型
bool Json::Reader::parse(const std::string& document,
Value& root, bool collectComments = true);
参数:
- document: json格式字符串
- root: 传出参数, 存储了json字符串中解析出的数据
- collectComments: 是否保存json字符串中的注释信息
// 通过begindoc和enddoc指针定位一个json字符串
// 这个字符串可以是完成的json字符串, 也可以是部分json字符串
bool Json::Reader::parse(const char* beginDoc, const char* endDoc,
Value& root, bool collectComments = true);
// write的文件流 -> ofstream
// read的文件流 -> ifstream
// 假设要解析的json数据在磁盘文件中
// is流对象指向一个磁盘文件, 读操作
bool Json::Reader::parse(std::istream& is, Value& root, bool collectComments = true);
./natapp -authtoken=eb5f3477db7465bb
http://5zs246.natappfree.cc/post
http://qdqbav.natappfree.cc
{
"code": 23021,
"flag":0xF,
"mode":0x1,
"username": "111111",
"password": "326578",
}
{
"code": 23021,
"flag":0xF,
"mode":0x1,
"id":001,
"name": "111111",
"gender": "male",
"phone":"152...."
}
//查询员工信息：回应客户端
[
"SQLITE_ERR",
"NOTFOUND_ERR",
"SUCESS",
{
"year": 2023,
"month": 7,
"day": 6,
"id": 001,
"name": "何子豪",
"gender": "男",
"phone":"15254699874"
}
...
]
//查询打卡记录：回应客户端
[
"SQLITE_ERR",
{
"year": 2023,
"month": 7,
"day": 6,
"id": 001,
"name": "何子豪",
"date": "2023-07-06 08:25:32"
}
...
]
[
"NOTFOUND_ERR",
{
"year": 2023,
"month": 7,
"day": 6,
"id": 001,
"name": "何子豪",
"date": "2023-07-06 08:25:32"
}
...
]
[
"SUCESS",
{
"year": 2023,
"month": 7,
"day": 6,
"id": 001,
"name": "何子豪",
"date": "2023-07-06 08:25:32"
}
...
]
4.JSON格式的语法
sudo apt-get install libjsoncpp-dev
git clone git@github.com:DaveGamble/cJSON.git
mkdir build
cd build
cmake ..
make
sudo make install
sudo ln -s /usr/local/lib/libcjson.so.1.7.16 /usr/lib/libcjson.so.1.7.16
sudo ln -s /usr/local/lib/libcjson.so.1 /usr/lib/libcjson.so.1
sudo ln -s /usr/local/lib/libcjson.so /usr/lib/libcjson.so
sudo ln -s /usr/local/lib/pkgconfig/libcjson.pc /usr/lib/pkgconfig/libcjson.pc
# ln为硬链接
#ln -s 为符号链接，也叫软连接
cp /usr/local/include/cjson/cJSON.h /usr/include/cjson/
Object，对象以左大括号开始，以右大括号结束，对象中是一系列的name/value对，name和value以冒号（:）分隔，每一对name/value之间以逗号（,）分隔。如下图所示：
Array，数组以左中括号（[）开始，以右中括号（]）结束，数组中是一系列有序的value值，value值之间以逗号（,）分隔。
Name必须是字符串。
Value可以是字符串，数字，布尔值，null，或者是对象和数组。如下图所示：
九、sqlite
sql的指令格式：所有sql指令都是以分号(;)结尾，两个减号(–)则表示注释。
.open employee.db#打开数据库
sqlite3 employee.db#创建打开数据库
.headers on#显示列的名称
.mode column#按照列显示
csv 逗号分隔的值
column 左对齐的列
html HTML 的 <table> 代码
insert TABLE 表的 SQL 插入（insert）语句
line 每行一个值
list 由 .separator 字符串分隔的值
tabs 由 Tab 分隔的值
tcl TCL 列表元素
.separator STRING#改变输出模式和 .import 所使用的分隔符
.separator ","#以逗号分隔
.schema TABLE#命令来查看指定的数据表的结构
.import FILE TABLE#导入来自 FILE 文件的数据到 TABLE 表中
.output FILENAME#输出重定向到文件
.output stdout#输出重定向到屏幕
#==================================================================================#
#打开sqlte的数据库文件，将数据表内容导出.csv文件中
sqlite3 employee.db
#可以将下面的命令写进.sql脚本
sqlite> .headers on
sqlite> .mode csv
sqlite> .output data.csv
sqlite> SELECT * FROM employee;
sqlite> .output stdout // 输出重定向
#==================================================================================#
#通过命令行的方式
>sqlite3 -header -csv employee.db "select * from employee;" > employee.csv
sqlite3 -html employee.db "select * from employee" > liu.htm#以html的格式输出
#==================================================================================#
#如果写了一个query.sql包含查询数据的sql脚本，则可以执行此脚本文件将数据导出到CSV文件
>sqlite3 -header -csv employee.db <query.sql> data.csv
#==================================================================================#
#==================================================================================#
sqlite3 employee.db .dump > employee.sql#将sqlite中指定的数据表以SQL创建脚本的形式导出
#==================================================================================#
#==================================================================================#
#将.csv或者文本文件文件的数据导入到数据库，可以写一个.sql脚本
PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
.separator ","
.import data.txt employee
sqlite> .headers on
sqlite> .mode column
select * from employee;
COMMIT;
#==================================================================================#
#==================================================================================#
#创建表
create table if not exists employee(year integer, month integer, day integer,
id integer primary key, name text);
insert into employee(year,month,day,id,name)values(2023, 7, 0x1, 001, "何子豪");#插入数据
insert into employee values(2023, 7, 0x2, 002, "邓玉宏");
insert into employee values(2023, 7, 3, 003, "白雨洁");
insert into employee values(2023, 7, 4, 004, "孟志祥");
insert into employee values(2023, 7, 5, 005, "范诗杰");
insert into employee values(2023, 7, 6, 006, "李俊辉");
insert into employee1 values(2023, 7, 7, 007, "李辉");
#==================================================================================#
#==================================================================================#
#查询数据
select * from employee;
select id,name from employee
select * from employee where WHERE CONDITION-1 {AND|OR} CONDITION-2;#条件查询
select * from employee where id in (1, 2, 3);
select * from employee where id between 1 and 3;
select count (*) from employee;#查询记录数目
#==================================================================================#
#==================================================================================#
update employee set month=6, day=29 where name = "何子豪";#更改数据
update employee set id=1 where name = "何子豪";
delete from employee where id between 7 and 10;#删除指定数据
drop table employee;#删除表
#==================================================================================#
table2 as a join table3 as b on a.id=b.id;
select a.id, a.name, a.workdate, a.gonedate,b.fingerID from table3 a join table2 b using(id) where a.month
十、libevent使用
1.事件驱动、高性能、轻量级，适用于网络
2.跨平台
3.支持多种I/O多路复用技术
4.支持IO事件、信号事件、时间事件
sudo apt-get install libevent-dev
libevent是一个事件驱动框架，可以用于处理网络通信等I/O操作。其中，事件处理(Event)和缓冲区( bufferevent)处理是两个不同的组件。
事件处理（event）
主要负责监听文件描述符上的事件，并在事件发生时调用相应的回调函数进行处理例如，一个TCP连接建立成功后，事件处理器可以监听该连接上是否有可读、可写或异常事件发生，并在事件发生时触发相应的回调函数进行数据处理。
缓冲区处理（bufferevent）
则是对事件处理的补充，它提供了对I/O数据的缓冲和处理功能当事件处理器检测到某个文件描述符可读时，缓冲区处理器会从该文件描述符读取一定量的数据并将其缓存在内存中，然后通过回调函数对缓存数据进行处理。类似地，当事件处理器检测到某个文件描述符可写时，缓冲区处理器会将已缓存的数据写入文件描述符中。
1.libevent框架理解
1)libevent框架
- 创建一个事件处理框架，（一个事件集合）
- 创建一个事件，初始化对应的回调函数**
- 事件添加到事件上下文中
- 开始事件循环，等待激活事件
- 将激活事件添加到激活队列，调用回调函数（一个事件对应一个回调）
- 释放资源
Create a new HTTP server
要用到的API
/*
libevent将该请求解析为struct evhttp_request结构体表示，并调用用户设置的请求处理函数进行处理。
struct evhttp_request结构体定义了HTTP请求的各个字段，如请求行、请求头、请求正文等。
*/
struct evhttp_request {
int major; // 主版本号
int minor; // 次版本号
enum evhttp_cmd_type type; // 请求方法（GET、POST等）
char *uri; // 请求URI
struct evkeyvalq *input_headers;// 请求头
struct evbuffer *input_buffer; // 请求正文
};
enum evhttp_cmd_type {
EVHTTP_REQ_GET = 1 << 0,
EVHTTP_REQ_POST = 1 << 1,
EVHTTP_REQ_HEAD = 1 << 2,
EVHTTP_REQ_PUT = 1 << 3,
EVHTTP_REQ_DELETE = 1 << 4,
};
1.用于创建一个新的事件处理器对象（event_base），它没有任何参数，返回一个指向新创建的event_base对象的指针。
struct event_base *base = event_base_new();
/*
创建一个新的事件处理器对象（`event_base`）
return:，返回一个指向新创建的`event_base`对象的指针
*/
2.event_base_free()用于释放事件处理器对象（event_base）所占用的资源
struct event_base *base = event_base_new();
// 使用base处理事件...
event_base_free(base);
3.event_new()用于创建一个新的事件对象（struct event）
struct event *
event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)
/*
参数
base：指向事件处理器对象（event_base）的指针，表示新创建的事件对象将与该事件处理器相关联。
fd：表示该事件对象关注的文件描述符。
events：表示该事件对象关注的事件类型，可选值包括EV_READ、EV_WRITE、EV_SIGNAL等。
callback：表示该事件对象在触发时需要执行的回调函数。
arg：回调函数的传入参数。
返回一个指向新创建的struct event对象的指针
*/
/*
events参数可以用来指定一个事件（struct event）关注的事件类型。可选的事件类型包括：
EV_TIMEOUT：超时事件，当计时器到达指定时间时触发。
EV_READ：读事件，当文件描述符上有可读数据时触发。
EV_WRITE：写事件，当文件描述符可写入数据时触发。
EV_SIGNAL：信号事件，当指定的信号被触发时触发。
EV_PERSIST：持久事件，使得事件对象在处理完毕后不会自动删除，可以用于周期性地执行某个任务。
这些事件类型可以通过按位或运算组合使用，表示事件对象同时关注多个事件类型。例如，将一个事件对象设置为关注读、写和超时事件，可以使用以下代码：
*/
short events = EV_READ | EV_WRITE | EV_TIMEOUT;
4.event_free()用于释放事件对象（struct event）所占用的资源。它有一个参数，即需要释放的struct event对象的指针。
struct event_base *base = event_base_new();
int fd = ... ; // 一个文件描述符
short events = EV_READ | EV_PERSIST;
struct event *ev = event_new(base, fd, events, my_callback, NULL);
// 使用ev处理事件...
event_free(ev);
5.event_add()用于将事件对象（struct event）添加到指定的事件处理器（event_base）中等待触发。
int event_add(struct event *ev, const struct timeval *tv)
ev：需要添加到事件处理器中的事件对象的指针。
timeout：表示等待事件触发的超时时间，可以为NULL表示不进行超时等待。当timeout参数为0时，表示事件处理器在等待事件触发时不会进行任何超时等待。程序会一直阻塞在event_base_dispatch()函数调用中，直到有事件触发或者调用了event_base_loopbreak()函数或event_base_loopexit()函数来终止事件循环。
6.event_del()用于将事件对象（struct event）从事件处理器（event_base）中删除，使其不再等待触发。
event_del()用于将事件对象（struct event）从事件处理器（event_base）中删除，使其不再等待触发。
7.event_base_dispatch()是libevent库中的一个函数，用于启动事件处理器（event_base）并进入事件循环，等待事件对象触发。
int event_base_dispatch(struct event_base *event_base)
{
return (event_base_loop(event_base, 0));
}
8.event_base_loopbreak()用于终止事件处理器（event_base）的事件循环。
int event_base_loopbreak(struct event_base *event_base)
base：需要终止事件循环的事件处理器对象的指针。
9.evutil_make_socket_nonblocking()用于将 socket 设置为非阻塞模式
int evutil_make_socket_nonblocking(evutil_socket_t fd)
/*
该函数的实现原理是通过调用 fcntl() 或者 ioctlsocket() 来将 socket 设置为非阻塞模式。如果操作成功，则返回 0；否则返回一个负数错误码。
*/
10.evutil_make_listen_socket_reuseable() 用于设置 socket 地址重用选项。
int evutil_make_listen_socket_reuseable(evutil_socket_t sock)
/*
在 TCP 协议中，默认情况下，在端口被占用后，如果再次绑定该端口会返回错误。设置地址重用选项可以允许多个进程或线程同时监听同一端口号。
该函数的实现原理是通过调用 setsockopt() 函数来设置 SO_REUSEADDR 选项。如果操作成功，则返回 0；否则返回一个负数错误码。
*/
1.添加Http事件
struct evhttp *evhttp_new(struct event_base *base);
/*
Create a new HTTP server
return:a pointer to a newly initialized evhttp server structure or NULL on error
base:the event base to receive the HTTP events
*/
2.配套的free
void evhttp_free(struct evhttp* http);
/*
Free the previously created HTTP server.
http:the evhttp server object to be freed
*/
3.给http服务器绑定IP和端口
int evhttp_bind_socket(struct evhttp *http, const char *address, ev_uint16_t port);
/*
Binds an HTTP server on the specified address and port.
return:0 on success, -1 on failure.
http:a pointer to an evhttp server object
address:a string containing the IP address to listen on
port:the port number to listen on
*/
4.用于设置通用回调函数
void evhttp_set_gencb(struct evhttp *http,
void (*cb)(struct evhttp_request *, void *), void *arg);
/*
用于设置通用回调函数
第一个参数是指向 evhttp 结构体的指针，表示要设置回调函数的 HTTP 服务器；
第二个参数是指向回调函数的指针，该回调函数的原型为 void (*cb)(struct evhttp_request *, void *)，其中第一个参数是指向当前 HTTP 请求的指针，第二个参数是传递给 evhttp_set_gencb() 函数的第三个参数；
第三个参数是传递给回调函数的上下文参数 cbarg，它可以是任何数据类型的指针；
*/
5.针对特殊的URI设置回调函数
int evhttp_set_cb(struct evhttp *http, const char *path,
void (*cb)(struct evhttp_request *, void *), void *cb_arg);
/*
Set a callback for a specified URI
第一个参数是指向 evhttp 结构体的指针，表示要设置回调函数的 HTTP 服务器；
第二个参数是字符串类型的 URI，表示要注册回调函数的 URI；
第三个参数是指向回调函数的指针，该回调函数的原型为 void (*cb)(struct evhttp_request *, void *)，其中第一个参数是指向当前 HTTP 请求的指针，第二个参数是传递给 evhttp_set_cb() 函数的第四个参数；
第四个参数是传递给回调函数的上下文参数 cbarg，它可以是任何数据类型的指针
*/
void http_cb(struct evhttp_request *req, void *arg)
{
//1.获取request的请求信息
//从request对象获取请求的uri对象
const struct evhttp_uri* evhttp_uri = evhttp_request_get_evhttp_uri(req);
return ;
}
1.
struct evhttp_uri *
evhttp_uri_parse(const char *source_uri)
/*
返回一个指向 evhttp_uri 结构体的指针，该结构体包含了 URI 的各个组成部分（包括协议、主机名、端口号、路径、查询参数和片段标识符等）
*/
struct evhttp_uri {
unsigned flags;
char *scheme; /* scheme; e.g http, ftp etc */
char *userinfo; /* userinfo (typically username:pass), or NULL */
char *host; /* hostname, IP address, or NULL */
int port; /* port, or zero */
#ifndef _WIN32
char *unixsocket; /* unix domain socket or NULL */
#endif
char *path; /* path, or "". */
char *query; /* query, or NULL */
char *fragment; /* fragment or NULL */
};
2.
int evhttp_uri_get_port(const struct evhttp_uri *uri)
{
return uri->port;
}
函数返回一个整数，表示 URI 的端口号。如果 URI 中没有明确指定端口号，则返回默认值（HTTP 协议默认端口为 80，HTTPS 协议默认端口为 443）
http://ffmpeg.club/index.html?id=1 -->> 80
3.
const char * evhttp_uri_get_host(const struct evhttp_uri *uri)
{
return uri->host;
}
函数返回一个字符串指针，指向 URI 的主机名部分。如果 URI 中没有明确指定主机名，则返回空指针。
http://ffmpeg.club/index.html?id=1 -->> ffmpeg.club
4.
const char *
evhttp_uri_get_query(const struct evhttp_uri *uri)
{
return uri->query;
}
evhttp_uri_get_query() 用于获取 URI 的查询部分，获取路径后面的参数。
http://ffmpeg.club/index.html?id=1 -->> id=1
const char *evhttp_request_get_uri(const struct evhttp_request *req);
/*
返回HTTP 请求的 URI。
URI 是客户端在请求服务器时发送的字符串，该字符串通常包含一个主机名、路径和查询字符串。例如，对于 “http://127.0.0.1/foo?bar=baz” 这样的请求，URI 将是 “/foo?bar=baz”。
*/
enum evhttp_cmd_type evhttp_request_get_command(const struct evhttp_request *req);
/*
函数返回一个枚举类型evhttp_cmd_type 值,表示 HTTP 请求使用的方法类型。
枚举类型包括以下值：
EVHTTP_REQ_GET: 使用 GET 方法。
EVHTTP_REQ_POST: 使用 POST 方法。
EVHTTP_REQ_HEAD: 使用 HEAD 方法。
EVHTTP_REQ_PUT: 使用 PUT 方法。
EVHTTP_REQ_DELETE: 使用 DELETE 方法。
EVHTTP_REQ_OPTIONS: 使用 OPTIONS 方法。
EVHTTP_REQ_TRACE: 使用 TRACE 方法。
EVHTTP_REQ_CONNECT: 使用 CONNECT 方法。
EVHTTP_REQ_PATCH: 使用 PATCH 方法。
*/
struct evkeyvalq *evhttp_request_get_input_headers(struct evhttp_request *req);
/*
Returns the intput header
返回struct evhttp_request中的请求头
*/
struct evkeyvalq *evhttp_request_get_output_headers(struct evhttp_request *req);
/*
Returns the output headers
返回的是服务器回应客户端的头部信息，它是一个链表，内容是键值对，struct evkeyvalq记录的是链表evkeyval的节点地址
*/
struct evkeyval {
TAILQ_ENTRY(evkeyval) next;
char *key;
char *value;
};
#define TAILQ_ENTRY(type)
struct {
struct type *tqe_next; /* next element */
struct type **tqe_prev; /* address of previous next element */
};
struct evkeyvalq {
struct evkeyval *tqh_first;
struct evkeyval **tqh_last;
}；
struct evbuffer *evhttp_request_get_input_buffer(struct evhttp_request *req);
/*
返回struct evhttp_request中的请求正文
*/
1.size_t evbuffer_get_length(const struct evbuffer *buf);
/*
Returns the total number of bytes stored in the evbuffer,返回evbuffer中的字节数量
*/
2. int evbuffer_remove(struct evbuffer *buf, void *data, size_t datlen);
/*
Read data from an evbuffer and drain the bytes read:从 evbuffer 读取数据并耗尽读取的字节数
return:the number of bytes read, or -1 if we can't drain the buffer.成功返回已读取的字节数，失败返回-1
*/
int evhttp_add_header(struct evkeyvalq *headers, const char *key, const char *value);
/*
return:0 on success, -1 on failure
第一个参数是指向 evkeyvalq 结构体的指针，表示要添加头部的头部列表；
第二个参数是字符串类型的键名，表示要添加的头部的名称；
第三个参数是字符串类型的键值，表示要添加的头部的值。
*/
/*
（1）如果某个键已经存在于头部列表中，则会将现有键值对的值替换为新的值。
（2）如果要添加多个具有相同名称的头部，请使用逗号分隔它们的值。例如，可以使用"Accept-Encoding: gzip, deflate"来同时添加两个Accept-Encoding头部。
*/
struct evbuffer *evhttp_request_get_output_buffer(struct evhttp_request *req);
/*
函数返回一个指向 evbuffer 结构体的指针，该结构体代表了 HTTP 请求的输出缓冲区。可以使用 evbuffer_add() 函数将内容添加到缓冲区中。
*/
void evhttp_send_reply(struct evhttp_request *req,
int code,
const char *reason,
struct evbuffer *databuf)
/*
用于向客户端发送 HTTP 响应。
第一个参数是指向 evhttp_request 结构体的指针，表示要发送响应的 HTTP 请求；
第二个参数是整数类型的状态码，表示响应的状态码；
第三个参数是字符串类型的原因短语，表示状态码的原因短语；
第四个参数是指向 evbuffer 结构体的指针，表示响应正文的内容。
*/
十一、在linux使用人脸识别的SDK
1.准备工作，在linux安装3个库
1.安装libcurl库
sudo apt-get install libcurl4-openssl-dev#
dpkg -s libcurl4-openssl-dev#检查安装情况
2.安装openssl库
sudo apt-get install openssl
dpkg -s openssl#检查安装情况
3.安装jsoncpp库
sudo apt-get install libjsoncpp-dev
dpkg -slibjsoncpp-dev#检查安装情况
4.安装libssl-dev
sudo apt-get install libssl-dev
dpkg -slibssl-dev#检查安装情况
2.编译时注意事项
g++ ** -std=c++11 -lcurl -lcrypto -ljsoncpp
3.在源代码中添加头文件
#include"face.h"
4.z在源代码中使用aip命名空间
using namespace aip
注意：
在aip-cpp-sdk-4.16.5中base文件夹中http.h中的#include<json/json.h>修改为#include<jsoncpp/json/json.h>
在aip-cpp-sdk-4.16.5中base文件夹中base.h中的#include"json/json.h"修改为#include"jsoncpp/json/json.h"
5.client的创建，连接百度AI云平台的钥匙
#include "face.h"
// 设置APPID/AK/SK
std::string app_id = "你的 App ID";
std::string api_key = "你的 Api key";
std::string secret_key = "你的 Secret Key";
aip::Face client(app_id, api_key, secret_key);
6.将Qt客户端传过来的Base64格式的图片通过 client.search()函数发送给百度云，然后定义一个Json的Value实例化对象接受返回的数据。
Json::Value result;
std::string image = "取决于image_type参数，传入BASE64字符串或URL字符串或FACE_TOKEN字符串";
std::string image_type = "BASE64";
std::string group_id_list = "jack";
// 调用人脸搜索
result = client.search(image, image_type, group_id_list, aip::null);
// 如果有可选参数
std::map<std::string, std::string> options;
options["match_threshold"] = "70";
options["quality_control"] = "NORMAL";
options["liveness_control"] = "LOW";
options["user_id"] = "233451";
options["max_user_num"] = "3";
// 带参数调用人脸搜索
result = client.search(image, image_type, group_id_list, options);
十二、线程池
什么是线程池
基于池化思想用于管理线程的工具。
为什么需要线程池
线程过多会带来额外的开销，包括线程的创建和销毁、线程的调度，会降低计算机性能。
线程池维护多个线程，等待监督管理者分配并发执行的任务。
简单来说线程池把任务的提交和任务的执行剥离开来，当一个任务被提交到线程池之后：
- 如果此时线程数小于核心线程数，那么就会新起一个线程来执行当前的任务。
- 如果此时线程数大于核心线程数，那么就会将任务塞入阻塞队列中，等待被执行。
- 如果阻塞队列满了，并且此时线程数小于最大线程数，那么会创建新线程来执行当前任务。
- 如果阻塞队列满了，并且此时线程数大于最大线程数，那么会采取拒绝策略。
链接：https://www.zhihu.com/question/412524104/answer/1960392357
ThreadPool::ThreadPool(int numWorkers, int max_jobs = 10) : m_sum_thread(numWorkers), m_free_thread(numWorkers), m_max_jobs(max_jobs){ //numWorkers:线程数量
if (numWorkers < 1 || max_jobs < 1){
perror("workers num error");
}
//初始化jobs_cond
if (pthread_cond_init(&m_jobs_cond, NULL) != 0)
perror("init m_jobs_cond fail\n");
//初始化jobs_mutex
if (pthread_mutex_init(&m_jobs_mutex, NULL) != 0)
perror("init m_jobs_mutex fail\n");
//初始化workers
m_workers = new NWORKER[numWorkers];
if (!m_workers){
perror("create workers failed!\n");
}
//初始化每个worker
for (int i = 0; i < numWorkers; ++i){
m_workers[i].pool = this;
int ret = pthread_create(&(m_workers[i].threadid), NULL, _run, &m_workers[i]);
if (ret){
delete[] m_workers;
perror("create worker fail\n");
}
if (pthread_detach(m_workers[i].threadid)){
delete[] m_workers;
perror("detach worder fail\n");
}
m_workers[i].terminate = 0;
}
}
1.降低资源消耗：重复利用已创建的线程，减少创建和销毁的消耗
2.提高线程的可管理性：负载均衡。减少线程的不合理分布，使用线程池进行统一的分配、调优和监控。
3.提高任务响应速度：任务来时，直接执行。
1.线程池创建
代码已实现
主要分为：任务队列、工作队列和管理者线程三大部分
封装的类：任务队列类、线程池类
任务队列以组合的方式添加到线程池类
互斥和线程同步：对任务队列进行互斥操作，任务队列和线程池中工作线程是消费者和生产者模型。（条件变量加互斥锁）。
关于线程池的动态管理：删除增加线程的策略等等。。。。
2.半同步半反应堆线程池
主要由I/O单元，逻辑单元和网络存储单元组成，其中每个单元之间通过请求队列进行通信，从而协同完成任务。
其中I/O单元用于处理客户端连接，读写网络数据；逻辑单元用于处理业务逻辑的线程；网络存储单元指本地数据库和文件等。
1.五种I/O模型
阻塞I/O，非阻塞I/O，信号驱动I/O和I/O复用都是同步I/O。
同步I/O指内核向应用程序通知的是就绪事件，比如只通知有客户端连接，要求用户代码自行执行I/O操作，
异步I/O是指内核向应用程序通知的是完成事件，比如读取客户端的数据后才通知应用程序，由内核完成I/O操作。
- 阻塞IO:调用者调用了某个函数，等待这个函数返回，期间什么也不做，不停的去检查这个函数有没有返回，必须等这个函数返回才能进行下一步动作
- 非阻塞IO:非阻塞等待，每隔一段时间就去检测IO事件是否就绪。没有就绪就可以做其他事。非阻塞I/O执行系统调用总是立即返回，不管时间是否已经发生，若时间没有发生，则返回-1，此时可以根据errno区分这两种情况，对于accept，recv和send，事件未发生时，errno通常被设置成eagain
- 信号驱动IO:linux用套接口进行信号驱动IO，安装一个信号处理函数，进程继续运行并不阻塞，当IO时间就绪，进程收到SIGIO信号。然后处理IO事件。
- IO复用:linux用select/poll函数实现IO复用模型，这两个函数也会使进程阻塞，但是和阻塞IO所不同的是这两个函数可以同时阻塞多个IO操作。而且可以同时对多个读操作、写操作的IO函数进行检测。知道有数据可读或可写时，才真正调用IO操作函数
- 异步IO:linux中，可以调用aio_read函数告诉内核描述字缓冲区指针和缓冲区的大小、文件偏移及通知的方式，然后立即返回，当内核将数据拷贝到缓冲区后，再通知应用程序。
2.事件处理模式
- reactor模式中，主线程(I/O处理单元)只负责监听文件描述符上是否有事件发生，有的话立即通知工作线程(逻辑单元 )，读写数据、接受新连接及处理客户请求均在工作线程中完成。通常由同步I/O实现。
- proactor模式中，主线程和内核负责处理读写数据、接受新连接等I/O操作，工作线程仅负责业务逻辑，如处理客户请求。通常由异步I/O实现。
3.半同步/半反应堆
并发模式中的同步和异步
- 同步指的是程序完全按照代码序列的顺序执行
- 异步指的是程序的执行需要由系统事件驱动
半同步/半反应堆工作流程：
- 主线程充当异步线程，负责监听所有socket上的事件
- 若有新请求到来，主线程接收之以得到新的连接socket，然后往epoll内核事件表中注册该socket上的读写事件
- 如果连接socket上有读写事件发生，主线程从socket上接收数据，并将数据封装成请求对象插入到请求队列中
- 所有工作线程睡眠在请求队列上，当有任务到来时，通过竞争（如互斥锁）获得任务的接管权
4.线程池饥饿问题
解决方案：
- **减少阻塞：**通过减少线程的阻塞数，尤其是减少长时间的 I/O 操作，从而提高线程的 CPU 利用率和吞吐量，减少线程等待时间。
- **增加优先级：**通过增加特定线程的优先级来确保其可以及时获取到所需的资源，同时需要注意不能过度倚赖这种方法，避免破坏程序的公平性。
- **采用公平调度策略：**使用操作系统提供的公平调度策略来控制线程之间的资源争夺，保证每个线程都有机会获取相同的资源。
- **设置超时时间：**设置线程请求资源的超时时间，避免线程长时间等待资源而导致饥饿问题的出现。
- **使用不可抢占锁：**当线程占用某个锁时，不可被其它高优先级的线程强制抢夺其锁。这样可能使高优先级线程也会处于饥饿状态，但是会保证同一段代码的执行顺序不会影响系统稳定性。
十三、MQTT
MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。
MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。
MQTT 与 HTTP 一样，MQTT 运行在传输控制协议/互联网协议 (TCP/IP) 堆栈之上。
MQTT使用的发布/订阅消息模式，它提供了一对多的消息分发机制，从而实现与应用程序的解耦。
这是一种消息传递模式，消息不是直接从发送器发送到接收器（即点对点），而是由MQTT server（或称为 MQTT Broker）分发的。
服务器分发消息，因此必须是发布者，但绝不是订阅者！
客户端可以发布消息（发送方）、订阅消息（接收方）或两者兼而有之。
客户端（也称为节点）是一种智能设备，如微控制器或具有 TCP/IP 堆栈和实现 MQTT 协议的软件的计算机。
mosquitto服务器配置，在mosquitto.conf加入下面两行
allow_anonymous false
password_file /etc/mosquitto/pwfile.example
然后重启服务器
service mosquitto restart
配置密码
sudo mosquitto_passwd -c /etc/mosquitto/pwfile.example test
sudo lsof -i | grep mosquitto
1.安装mosquitto库
git clone git@github.com:eclipse/mosquitto.git
https://github.com/eclipse/mosquitto
tar -zvxf mosquitto-2.0.15.tar.gz
mv mosquitto-2.0.15.tar.gz ~
cd mosquitto-2.0.15.tar.gz
vim congig.mk
#将将 WITH_DOCS:=yes 改为 WITH_DOCS:=no
#安装依赖的第三方库
#编译找不到openssl/ssl.hsudo
apt-get install libssl-dev
#编译过程找不到ares.hsudo
apt-get install libc-ares-dev
编译过程找不到uuid/uuid.hsudo
apt-get install uuid-dev
#使用过程中找不到libmosquitto.so.1 error while loading shared libraries: libmosquitto.so.1: cannot open shared object file: No such file or directory
#解决方法：创建软链接
sudo ln -s /usr/local/lib/libmosquitto.so.1 /usr/lib/libmosquitto.so.1
#更新动态链接库
sudo ldconfig
注意：第三方库都默认安装在/usr/local/中
可以将库在/usr/local/include中的.h文件copy到/usr/include中
#以上库安装好后
make
sudo make install
2.测试mosquitto订阅与发布
1.mosquitto broker配置
查看mosquitto配置文件在mosquitto文件夹下vim mosquitto.conf
mosquitto配置文件默认即可。如有需求可按需修改。
mosquitto_sub 命令参数说明
1. -c 设定‘clean session’为无效状态，这样一直保持订阅状态，即便是已经失去连接，如果再次连接仍旧能够接收的断开期间发送的消息。
2. -d 打印debug信息
3. -h 指定要连接的域名 默认为localhost
4. -i 指定clientId
5. -I 指定clientId前缀
6. -k keepalive 每隔一段时间，发PING消息通知broker，仍处于连接状态。 默认为60秒。
7. -q 指定希望接收到QoS为什么的消息 默认QoS为0
8. -R 不显示陈旧的消息
9. -t 订阅topic
10. -v 打印消息
11. --will-payload 指定一个消息，该消息当客户端与broker意外断开连接时发出。该参数需要与--will-topic一起使用
12. --will-qos Will的QoS值。该参数需要与--will-topic一起使用
13. --will-retain 指定Will消息被当做一个retain消息（即消息被广播后，该消息被保留起来）。该参数需要与--will-topic一起使用
14. --will-topic 用户发送Will消息的topic
2.启动
mosquitto [-c config file] [ -d | --daemon ] [-p port number] [-v]
参数说明：
-c 后面跟的是启动mosquitto可以调整的参数，比如是否开启基本认证，端口是什么，SSL单向和双向的认证配置等等。
-d 表示MQTT mosquitto将在后台运行。
-p 代表当前的mosquitto服务实例启动以后，其监听端口号，这个配置的覆盖[-c config file] 指定的配置文件中的端口。
-v 代码调试模式（verbose）在终端输出更多的信息 。
3.发布
mosquitto库中的API
1.初始化mosquitto，必须在任何其他mosqtto函数前使用它。
int mosquitto_lib_init(void)
/*
功能：
初始化mosquitto，必须在任何其他mosqtto函数前使用它。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_UNKNOWN：在 Windows 上，无法初始化套接字
*/
2.调用以释放与库关联的资源。
libmosq_EXPORT int mosquitto_lib_cleanup(void)
/*
功能：
调用以释放与库关联的资源。
返回值：
MOSQ_ERR_SUCCESS 总是成功
*/
3.创建一个新的 mosquitto 客户端实例
struct mosquitto *mosquitto_new(const char *id, bool clean_session, void *obj);
/*
id：用作客户端 ID 的字符串。如果为 NULL，将生成一个随机客户端 ID。如果 id 为 NULL，则 clean_session 必须为真。
clean_session：设置为 true 指示代理在断开连接时清除所有消息和订阅。设置为 false 指示它保留它们，注意，客户端永远不会在断 开连接时丢弃自己的传出消息。调用mosquitto_connect或mosquitto_reconnect将导致消息被重新发送。使用 mosquitto_reinitialise将客户端重置为其原始状态。如果 id 参数为 NULL，则必须设置为 true。
obj：将作为参数传递给任何指定回调的用户指针。为指向struct mosquitto结构体类型的指针。
*/
4.用于释放与 mosquitto 客户端实例关联的内存。
void mosquitto_destroy(struct mosquitto *mosq)
/*
功能：
用于释放与 mosquitto 客户端实例关联的内存。
参数：
指向需要free 的 struct mosquitto指针。
*/
5.mosquitto_username_pw_set函数
libmosq_EXPORT int mosquitto_username_pw_set( struct mosquitto * mosq,
const char * username,
const char * password )
/*
功能：
为 mosquitto 实例配置用户名和密码。默认情况下，不会发送用户名或密码。对于 v3.1 和 v3.1.1 客户端，如果 username 为 NULL，则忽略密码参数。这必须在调用mosquitto_connect之前调用。
参数：
mosq：一个有效的mosquitto实例
username：要作为字符串发送的用户名，或 NULL 以禁用身份验证。
password：作为字符串发送的密码。当用户名有效时设置为 NULL，以便仅发送用户名。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
*/
6.mosquitto_connect函数
int mosquitto_connect( struct mosquitto * mosq,
const char * host,
int port,
/* int keepalive )
功能：
连接到服务端
参数：
mosq：一个有效的mosquitto实例。
host：要连接的代理的主机名或 IP 地址。
port：要连接的网络端口。通常是 1883 。
keepalive：如果在这段时间内（秒数）没有交换其他消息，代理应该向客户端发送 PING 消息。
返回值：
MOSQ_ERR_SUCCESS：连接成功。
MOSQ_ERR_INVAL：如果输入参数无效，可以是以下任何一种：
mosq == NULL
host == 空
port < 0
keepalive < 5
MOSQ_ERR_ERRNO：如果系统调用返回错误。变量 errno 包含错误代码，即使在 Windows 上也是如此。在Linux情况下使用 strerror(errno) 或在 Windows 上使用 FormatMessage()。
*/
7.mosquitto_reconnect函数
libmosq_EXPORT int mosquitto_reconnect( struct mosquitto *mosq)
/*
功能：
重新连接到代理。此功能提供了一种在连接丢失后重新连接到代理的简单方法。它使用mosquitto_connect调用中提供的值。但不能在mosquitto_connect之前调用它。
参数：
mosq：一个有效的mosquitto实例。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_ERRNO：如果系统调用返回错误。变量 errno 包含错误代码，即使在 Windows 上也是如此。在Linux下可使用 strerror(errno) 或在 Windows 上使用 FormatMessage()获取错误。
*/
8.mosquitto_disconnect函数
int mosquitto_disconnect( struct mosquitto *mosq)
/*
功能：
断开与代理的连接。该功能适用于使用所有 MQTT 协议版本的客户端。
参数：
mosq：一个有效的mosquitto实例
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理
*/
9.mosquitto_publish函数
libmosq_EXPORT int mosquitto_publish( struct mosquitto * mosq,
int * mid,
const char * topic,
int payloadlen,
const void * payload,
int qos,
bool retain )
/*
功能：
发布关于给定主题的消息。该功能适用于使用所有 MQTT 协议版本的客户端。如果需要设置 MQTT v5 PUBLISH 属性，请改用mosquitto_publish_v5。
参数：
mosq：一个有效的mosquitto实例。
mid：指向 int 的指针。如果不为 NULL，该函数会将其设置为此特定消息的消息 ID。然后可以将其与发布回调一起使用，以确定何时发送消息。请注意，尽管 MQTT 协议不对 QoS=0 的消息使用消息 ID，但 libmosquitto 会为它们分配消息 ID，以便可以使用此参数跟踪它们。
topic：要发布到的主题的以 null 结尾的字符串。
payloadlen：有效载荷的大小（字节）。有效值介于 0 和 268,435,455 之间。
payload：有效载荷，指向要发送的数据的指针。如果 payloadlen > 0 这必须是一个有效的内存位置。
qos：服务质量，整数值 0、1 或 2，指示要用于消息的服务质量。
retain：保持，设置为 true 以使消息保留。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理。
MOSQ_ERR_PROTOCOL：如果与代理通信时出现协议错误。
MOSQ_ERR_PAYLOAD_SIZE：如果 payloadlen 太大。
MOSQ_ERR_MALFORMED_UTF8：如果主题不是有效的 UTF-8
MOSQ_ERR_QOS_NOT_SUPPORTED：如果 QoS 大于代理所支持的。
MOSQ_ERR_OVERSIZE_PACKET：如果生成的数据包比代理支持的大。
*/
- mosquitto_subscribe函数
libmosq_EXPORT int mosquitto_subscribe( struct mosquitto * mosq,
int * mid,
const char * sub,
int qos )
/*
功能：
订阅一个主题。该功能适用于使用所有 MQTT 协议版本的客户端。如果需要设置 MQTT v5 SUBSCRIBE 属性，请改mosquitto_subscribe_v5。
参数：
mosq：一个有效的mosquitto实例。
mid：指向 int 的指针。如果不为 NULL，该函数会将其设置为此特定消息的消息 ID。然后可以将其与 subscribe 回调一起使用，以确定消息何时发送。
sub：订阅模式。
qos：服务质量，此订阅请求的服务质量。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理。
MOSQ_ERR_MALFORMED_UTF8：如果主题不是有效的 UTF-8
MOSQ_ERR_OVERSIZE_PACKET：如果生成的数据包比代理支持的大。
*/
11.mosquitto_unsubscribe函数
libmosq_EXPORT int mosquitto_unsubscribe( struct mosquitto * mosq,
int * mid,
/* const char * sub )
功能：
退订主题。
参数：
mosq：一个有效的mosquitto实例。
mid：指向 int 的指针。如果不为 NULL，该函数会将其设置为此特定消息的消息 ID。然后可以将其与取消订阅回调一起使用，以确定消息何时发送。
sub：退订模式。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理。
MOSQ_ERR_MALFORMED_UTF8：如果主题不是有效的 UTF-8
MOSQ_ERR_OVERSIZE_PACKET：如果生成的数据包比代理支持的大。
*/
12.mosquitto_loop_forever函数
libmosq_EXPORT int mosquitto_loop_forever( struct mosquitto * mosq,
int timeout,
int max_packets )
/*
功能：
此函数在无限阻塞循环中为您调用 loop()。这对于您只想在程序中运行 MQTT 客户端循环的情况很有用。
如果服务器连接丢失，它会处理重新连接。**如果您在回调中调用 mosquitto_disconnect()，它将返回。
参数：
mosq：一个有效的mosquitto实例。
timeout：在超时之前等待 select() 调用中的网络活动的最大毫秒数。设置为 0 以立即返回。设置负数以使用默认值 1000 毫秒。
max_packets：此参数当前未使用，应设置为 1 以便将来兼容。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理。
MOSQ_ERR_CONN_LOST：如果与代理的连接丢失。
MOSQ_ERR_PROTOCOL：如果与代理通信时出现协议错误。
MOSQ_ERR_ERRNO：如果系统调用返回错误。变量 errno 包含错误代码，即使在 Windows 上也是如此。在Linux下使用 strerror(errno) 或在 Windows 上使用 FormatMessage()获取。
*/
13.mosquitto_loop函数
libmosq_EXPORT int mosquitto_loop( struct mosquitto * mosq,
int timeout,
int max_packets )
/*
功能：
客户端的主网络循环。必须经常调用它以保持客户端和代理之间的通信正常工作。这是由mosquitto_loop_forever和mosquitto_loop_start 执行的，它们是处理网络循环的推荐方法。如果您愿意，也可以使用此功能。不能在回调中调用它。
如果存在传入数据，则将对其进行处理。传出命令，例如 mosquitto_publish，通常在调用它们的函数时立即发送，但这并不总是可能的。 mosquitto_loop还将尝试发送任何剩余的传出消息，其中还包括作为 QoS>0 消息流的一部分的命令。
这调用 select() 来监视客户端网络套接字。如果您想将 mosquitto 客户端操作与您自己的 select() 调用集成，请使用mosquitto_socket、mosquitto_loop_read、mosquitto_loop_write和mosquitto_loop_misc。
参数：
mosq：一个有效的mosquitto实例。
timeout：在超时之前等待 select() 调用中的网络活动的最大毫秒数。设置为 0 以立即返回。设置负数以使用默认值 1000 毫秒。
max_packets：此参数当前未使用，应设置为 1 以便将来兼容。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOMEM：如果发生内存不足的情况。
MOSQ_ERR_NO_CONN：如果客户端未连接到代理。
MOSQ_ERR_CONN_LOST：如果与代理的连接丢失。
MOSQ_ERR_PROTOCOL：如果与代理通信时出现协议错误。
MOSQ_ERR_ERRNO：如果系统调用返回错误。变量 errno 包含错误代码，即使在 Windows 上也是如此。在Linux下使用 strerror(errno) 或在 Windows 上使用 FormatMessage()获取。
*/
mosquitto_loop_start函数
libmosq_EXPORT int mosquitto_loop_start( struct mosquitto * mosq )
/*
功能：
这是线程客户端接口的一部分。调用一次以启动一个新线程来处理网络流量。这为重复调用mosquitto_loop提供了一种替代方法。
参数：
mosq：一个有效的mosquitto实例。
返回值：
MOSQ_ERR_SUCCESS：关于成功。
MOSQ_ERR_INVAL：如果输入参数无效。
MOSQ_ERR_NOT_SUPPORTED：如果线程支持不可用。
*/
14.mosquitto_connect_callback_set函数
libmosq_EXPORT void mosquitto_connect_callback_set(
struct mosquitto * mosq,
void (*on_connect)(struct mosquitto *, void *, int))
/*
功能：
设置连接回调。这在代理发送 CONNACK 消息以响应连接时调用。
参数：
mosq：一个有效的mosquitto实例。
on_connect：函数指针，以下形式的回调函数： void callback(struct mosquitto *mosq, void *obj, int rc)，在使用编写此回调函数时，一定要严格安装此参数和类型的要求。
回调参数
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
rc：连接响应的返回码。这些值由使用的 MQTT 协议版本定义。
*/
- mosquitto_disconnect_callback_set函数
libmosq_EXPORT void mosquitto_disconnect_callback_set(
struct mosquitto * mosq,
void (*on_disconnect)(struct mosquitto *, void *, int)
)
/*
功能：
设置断开回调。当代理收到 DISCONNECT 命令并断开客户端的连接时调用。
参数：
mosq：一个有效的mosquitto实例。
on_disconnect：以下形式的回调函数：void callback(struct mosquitto *mosq, void *obj,int rc)
回调参数：
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
rc：指示断开连接原因的整数值。值 0 表示客户端已调用mosquitto_disconnect。任何其他值表示断开是意外的。
*/
16.mosquitto_publish_callback_set函数
libmosq_EXPORT void mosquitto_publish_callback_set(
struct mosquitto * mosq,
void (*on_publish)(struct mosquitto *, void *, int)
)
/*
功能：
设置发布回调。当使用mosquitto_publish启动的消息已成功发送到代理时，将调用此方法。
参数：
mosq：一个有效的mosquitto实例。
on_publish：以下形式的回调函数： void callback(struct mosquitto *mosq, void *obj, int mid)
回调参数：
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
mid：已发送消息的消息 ID。
*/
17.mosquitto_message_callback_set函数
libmosq_EXPORT void mosquitto_message_callback_set(
struct mosquitto * mosq,
void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *)
)
/*
功能：
设置消息回调。当从代理接收到消息时调用它。
参数：
mosq：一个有效的mosquitto实例。
on_message：以下形式的回调函数：void callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message)
回调参数：
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
message：消息数据。回调完成后，该变量和关联的内存将由库释放。客户应该复制它需要的任何数据。
struct mosquitto_message{
int mid;//消息序号ID
char *topic; //主题
void *payload; //主题内容 ，MQTT 中有效载荷
int payloadlen; //消息的长度，单位是字节
int qos; //服务质量
bool retain; //是否保留消息
};
*/
18.mosquitto_subscribe_callback_set函数
libmosq_EXPORT void mosquitto_subscribe_callback_set(
struct mosquitto * mosq,
void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *)
)
/*
功能：
设置订阅回调。当代理响应订阅请求时调用。
参数：
mosq：一个有效的mosquitto实例。
on_subscribe：以下形式的回调函数： void callback(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
回调参数：
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
mid：订阅消息的消息 ID。
qos_count：授予订阅的数量（granted_qos 的大小）。
grant_qos：一个整数数组，指示每个订阅的授予 QoS。
*/
19.mosquitto_unsubscribe_callback_set函数
libmosq_EXPORT void mosquitto_unsubscribe_callback_set(
struct mosquitto * mosq,
void (*on_unsubscribe)(struct mosquitto *, void *, int)
)
/*
功能：
设置取消订阅回调。当代理响应取消订阅请求时调用它。
参数：
mosq：一个有效的mosquitto实例。
on_unsubscribe：以下形式的回调函数： void callback(struct mosquitto *mosq, void *obj, int mid)
回调参数：
mosq：进行回调的 mosquitto 实例。
obj：mosquitto_new中提供的用户数据
mid：取消订阅消息的消息 ID。
*/
十四、openssl
制作自签证书
openssl genrsa -des3 -out ca.key 1024
openssl rsa -in ca.key -out ca.key
openssl req -new -x509 -key ca.key -out ca.crt -days 365
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt -days 365
十五、QT上位机开发
QT上位机软件开发流程
1.需求分析：明确上位机软件的功能需求和 用户需求
2.与用户对接开会，制定需求规格说明书
3.概要设计：分析进行上位机软件的概要设计，确定软件的模块划分，功能结构和交互交互方式。（设计思路讨论）
4.在概要设计的基础上进行上位机软件的详细设计，定义每个模块的功能和接口
5.编码和实现，选择合适的编程语言和开发工具，按照设计规范编程代码，并进行单元测试
6.集成和测试，将各个模块进行集成，进行系统测试和继承测试，确保各个模块之间协正常，并进行功能测试，性能测试和兼容性测试。
7.软件发布，软件打包，文档编制安装部署
8.维护和优化软件，用户反馈和问题报告，修复错误和漏洞
十六、Qt
1.元对象系统
答：是Qt提供的内部对象通讯的信号与槽机制，运行时类的类型信息，以及动态属性系统（dynamic property system）。 整个元对象系统基于三个东西建立：
QObject类为所有对象提供了一个基类，只要继承此类，那创建出的对象便可以使用元对象系统。
在声明类时，将Q_OBJECT宏放置于类的私有区域就可以在类中使能元对象特性，诸如动态属性，信号，以及槽。一般实际使用中，我们总是把Q_OBJECT宏放置在类声明时的开头位置，除此之外我们的类还需要继承QObject类。
元对象编译器（Meta-Object Compiler，缩写moc），为每个QObject的子类提供必要的代码去实现元对象特性。我们可以认为Qt对C++进行了一些拓展，moc则是负责将这些拓展语法翻译成原生的C++语法，之后交给C++编译器去编译。
2.信号与槽
在Qt中，使用了信号与槽机制代替了回调机制。信号将会在特定的事件出现时被发出。Qt的控件预定义了很多信号，当然我们也可以继承这些控件以定义自己的子类，然后添加自己的信号。槽是在响应特定信号时会被调用的方法。
信号：只用声明，不用实现，通过emit发送信号。
槽函数：slots区域：声明，并且需要实现，可用通过信号激活，也可以当普通函数调用。没有返回值
信号与槽可以一对一，一对多，多对一。
1.moc查找头文件中的signals，slots，标记出信号和槽。
2.将信号槽信息存储到类静态变量staticMetaObject中，并且按声明顺序进行存放，建立索引。
3.当发现有connect连接时，将信号槽的索引信息放到一个map中，彼此配对。
4.当调用emit时，调用信号函数，并且传递发送信号的对象指针，元对象指针，信号索引，参数列表到active函数
5.通过active函数找到在map中找到所有与信号对应的槽索引
6.根据槽索引找到槽函数，执行槽函数。
Qt的线程使用
1.需要创建一个线程类的子类，让其继承QT中的线程类 QThread，比如:
class MyThread:public QThread
{
......
}
2.重写父类的 run() 方法，在该函数内部编写子线程要处理的具体的业务流程
class MyThread:public QThread
{
......
protected:
void run()
{
........
}
}
3.在主线程中创建子线程对象，new 一个就可以了
MyThread * subThread = new MyThread;
4.启动子线程, 调用 start() 方法
subThread->start();
当子线程别创建出来之后，父子线程之间的通信可以通过信号槽的方式，注意事项:
在Qt中在子线程中不要操作程序中的窗口类型对象, 不允许, 如果操作了程序就挂了
只有主线程才能操作程序中的窗口对象, 默认的线程就是主线程, 自己创建的就是子线程
实例代码：
mythread.h
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>
class MyThread : public QThread
{
Q_OBJECT
public:
explicit MyThread(QObject *parent = nullptr);
protected:
void run();
signals:
// 自定义信号, 传递数据
void curNumber(int num);
public slots:
};
#endif // MYTHREAD_H
#include "mythread.h"
#include <QDebug>
MyThread::MyThread(QObject *parent) : QThread(parent)
{
}
void MyThread::run()
{
qDebug() << "当前线程对象的地址: " << QThread::currentThread();
int num = 0;
while(1)
{
emit curNumber(num++);
if(num == 10000000)
{
break;
}
QThread::usleep(1);
}
qDebug() << "run() 执行完毕, 子线程退出...";
}
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mythread.h"
#include <QDebug>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
qDebug() << "主线程对象地址: " << QThread::currentThread();
// 创建子线程
MyThread* subThread = new MyThread;
connect(subThread, &MyThread::curNumber, this, [=](int num)
{
ui->label->setNum(num);
});
connect(ui->startBtn, &QPushButton::clicked, this, [=]()
{
// 启动子线程
subThread->start();
});
}
MainWindow::~MainWindow()
{
delete ui;
}
这种在程序中添加子线程的方式是非常简单的，但是也有弊端，假设要在一个子线程中处理多个任务，所有的处理逻辑都需要写到run()函数中，这样该函数中的处理逻辑就会变得非常混乱，不太容易维护。
创建一个新的类，让这个类从QObject派生
#ifndef MYWORK_H
#define MYWORK_H
#include <QObject>
class MyWork : public QObject
{
Q_OBJECT
public:
explicit MyWork(QObject *parent = nullptr);
// 工作函数
void working();
signals:
void curNumber(int num);
public slots:
};
#endif // MYWORK_H
2.在这个类中添加一个公共的成员函数，函数体就是我们要子线程中执行的业务逻辑
class MyWork:public QObject
{
public:
.......
// 函数名自己指定, 叫什么都可以, 参数可以根据实际需求添加
void working();
}
3.在主线程中创建一个QThread对象, 这就是子线程的对象
QThread* sub = new QThread;
4.在主线程中创建工作的类对象（千万不要指定给创建的对象指定父对象）
MyWork* work = new MyWork(this); // error
MyWork* work = new MyWork; // ok
将MyWork对象移动到创建的子线程对象中, 需要调用QObject类提供的moveToThread()方法
// void QObject::moveToThread(QThread *targetThread);
// 如果给work指定了父对象, 这个函数调用就失败了
// 提示： QObject::moveToThread: Cannot move objects with a parent
work->moveToThread(sub); // 移动到子线程中工作
6.启动子线程，调用 start(), 这时候线程启动了, 但是移动到线程中的对象并没有工作
7.调用MyWork类对象的工作函数，让这个函数开始执行，这时候是在移动到的那个子线程中运行的
3.2 示例代码
假设函数处理上面在程序中数数的这个需求，具体的处理代码如下：
mywork.h
Qt线程池
线程池的组成主要分为3个部分，这三部分配合工作就可以得到一个完整的线程池：
1.任务队列，存储需要处理的任务，由工作的线程来处理这些任务
- 通过线程池提供的API函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除
- 已处理的任务会被从任务队列中删除
- 线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程
2.工作的线程（任务队列任务的消费者） ，N个
- 线程池中维护了一定数量的工作线程, 他们的作用是是不停的读任务队列, 从里边取出任务并处理
- 工作的线程相当于是任务队列的消费者角色，
- 如果任务队列为空, 工作的线程将会被阻塞 (使用条件变量/信号量阻塞)
- 如果阻塞之后有了新的任务, 由生产者将阻塞解除, 工作线程开始工作
3.管理者线程（不处理任务队列中的任务），1个
- 它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测
- 当任务过多的时候, 可以适当的创建一些新的工作线程
- 当任务过少的时候, 可以适当的销毁一些工作的线程
- QRunnable
在Qt中使用线程池需要先创建任务，添加到线程池中的每一个任务都需要是一个QRunnable类型，因此在程序中需要创建子类继承QRunnable这个类，然后重写 run() 方法，在这个函数中编写要在线程池中执行的任务，并将这个子类对象传递给线程池，这样任务就可以被线程池中的某个工作的线程处理掉了
class MyWork : public QObject, public QRunnable
{
Q_OBJECT
public:
explicit MyWork(QObject *parent = nullptr)
{
// 任务执行完毕,该对象自动销毁
setAutoDelete(true);
}
~MyWork();
void run() override{}
}
在上面的示例中MyWork类是一个多重继承，如果需要在这个任务中使用Qt的信号槽机制进行数据的传递就必须继承QObject这个类，如果不使用信号槽传递数据就可以不继承了，只继承QRunnable即可
class MyWork :public QRunnable
{
Q_OBJECT
public:
explicit MyWork()
{
// 任务执行完毕,该对象自动销毁
setAutoDelete(true);
}
~MyWork();
void run() override{}
}
- QThreadPool
Qt中的 QThreadPool 类管理了一组 QThreads, 里边还维护了一个任务队列。QThreadPool 管理和回收各个 QThread 对象，以帮助减少使用线程的程序中的线程创建成本。每个Qt应用程序都有一个全局 QThreadPool 对象，可以通过调用 globalInstance() 来访问它。也可以单独创建一个 QThreadPool 对象使用。
// 获取和设置线程中的最大线程个数
int maxThreadCount() const;
void setMaxThreadCount(int maxThreadCount);
// 给线程池添加任务, 任务是一个 QRunnable 类型的对象
// 如果线程池中没有空闲的线程了, 任务会放到任务队列中, 等待线程处理
void QThreadPool::start(QRunnable * runnable, int priority = 0);
// 如果线程池中没有空闲的线程了, 直接返回值, 任务添加失败, 任务不会添加到任务队列中
bool QThreadPool::tryStart(QRunnable * runnable);
// 线程池中被激活的线程的个数(正在工作的线程个数)
int QThreadPool::activeThreadCount() const;
// 尝试性的将某一个任务从线程池的任务队列中删除, 如果任务已经开始执行就无法删除了
bool QThreadPool::tryTake(QRunnable *runnable);
// 将线程池中的任务队列里边没有开始处理的所有任务删除, 如果已经开始处理了就无法通过该函数删除了
void QThreadPool::clear();
// 在每个Qt应用程序中都有一个全局的线程池对象, 通过这个函数直接访问这个对象
static QThreadPool * QThreadPool::globalInstance();
一般情况下，我们不需要在Qt程序中创建线程池对象，直接使用Qt为每个应用程序提供的线程池全局对象即可。得到线程池对象之后，调用start()方法就可以将一个任务添加到线程池中，这个任务就可以被线程池内部的线程池处理掉了，使用线程池比自己创建线程的这种多种多线程方式更加简单和易于维护。
class MyWork :public QRunnable
{
Q_OBJECT
public:
explicit MyWork();
~MyWork();
void run() override;
}
MyWork::MyWork() : QRunnable()
{
// 任务执行完毕,该对象自动销毁
setAutoDelete(true);
}
void MyWork::run()
{
// 业务处理代码
......
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
// 线程池初始化，设置最大线程池数
QThreadPool::globalInstance()->setMaxThreadCount(4);
// 添加任务
MyWork* task = new MyWork;
QThreadPool::globalInstance()->start(task);
}
Qt的TCP通信
QTcpServer：服务器类，用于监听客户端连接以及和客户端建立连接。
QTcpSocket：通信的套接字类，客户端、服务器端都需要使用。
QTcpServer
//构造函数
QTcpServer::QTcpServer(QObject *parent = Q_NULLPTR);
QTcpSocket *QTcpServer::nextPendingConnection();
//给监听的套接字设置监听
bool QTcpServer::listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0);
// 判断当前对象是否在监听, 是返回true，没有监听返回false
bool QTcpServer::isListening() const;
// 如果当前对象正在监听返回监听的服务器地址信息, 否则返回 QHostAddress::Null
QHostAddress QTcpServer::serverAddress() const;
// 如果服务器正在侦听连接，则返回服务器的端口; 否则返回0
quint16 QTcpServer::serverPort() const
//得到和客户端建立连接之后用于通信的QTcpSocket套接字对象，它是QTcpServer的一个子对象，当QTcpServer对象析构的时候会自动析构这个子对象，当然也可自己手动析构，建议用完之后自己手动析构这个通信的QTcpSocket对象。
//阻塞等待客户端发起的连接请求，不推荐在单线程程序中使用，建议使用非阻塞方式处理新连接，即使用信号 newConnection() 。
QTcpSocket *QTcpServer::nextPendingConnection();
1.2 信号
//每次有新连接可用时都会发出 newConnection() 信号。
[signal] void QTcpServer::newConnection();
TCP服务器创建流程
- 创建套接字服务器QTcpServer对象
- 通过QTcpServer对象设置监听，即：QTcpServer::listen()
- 基于QTcpServer::newConnection()信号检测是否有新的客户端连接
- 如果有新的客户端连接调用QTcpSocket *QTcpServer::nextPendingConnection()得到通信的套接字对象
- 使用通信的套接字对象QTcpSocket和客户端进行通信
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private slots:
void on_startServer_clicked();
void on_sendMsg_clicked();
private:
Ui::MainWindow *ui;
QTcpServer* m_server;
QTcpSocket* m_tcp;
};
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setWindowTitle("TCP - 服务器");
// 创建 QTcpServer 对象
m_server = new QTcpServer(this);
// 检测是否有新的客户端连接
connect(m_server, &QTcpServer::newConnection, this, [=]()
{
m_tcp = m_server->nextPendingConnection();
ui->record->append("成功和客户端建立了新的连接...");
m_status->setPixmap(QPixmap(":/connect.png").scaled(20, 20));
// 检测是否有客户端数据
connect(m_tcp, &QTcpSocket::readyRead, this, [=]()
{
// 接收数据
QString recvMsg = m_tcp->readAll();
ui->record->append("客户端Say: " + recvMsg);
});
// 客户端断开了连接
connect(m_tcp, &QTcpSocket::disconnected, this, [=]()
{
ui->record->append("客户端已经断开了连接...");
m_tcp->deleteLater();
m_status->setPixmap(QPixmap(":/disconnect.png").scaled(20, 20));
});
});
}
MainWindow::~MainWindow()
{
delete ui;
}
// 启动服务器端的服务按钮
void MainWindow::on_startServer_clicked()
{
unsigned short port = ui->port->text().toInt();
// 设置服务器监听
m_server->listen(QHostAddress::Any, port);
ui->startServer->setEnabled(false);
}
// 点击发送数据按钮
void MainWindow::on_sendMsg_clicked()
{
QString sendMsg = ui->msg->toPlainText();
m_tcp->write(sendMsg.toUtf8());
ui->record->append("服务器Say: " + sendMsg);
ui->msg->clear();
}
QTcpSocket
//构造函数
QTcpSocket::QTcpSocket(QObject *parent = Q_NULLPTR);
//连接服务器，需要指定服务器端绑定的IP和端口信息。
[virtual] void QAbstractSocket::connectToHost(const QString &hostName, quint16 port, OpenMode openMode = ReadWrite, NetworkLayerProtocol protocol = AnyIPProtocol);
[virtual] void QAbstractSocket::connectToHost(const QHostAddress &address, quint16 port, OpenMode openMode = ReadWrite);
//接收数据
// 指定可接收的最大字节数 maxSize 的数据到指针 data 指向的内存中
qint64 QIODevice::read(char *data, qint64 maxSize);
// 指定可接收的最大字节数 maxSize，返回接收的字符串
QByteArray QIODevice::read(qint64 maxSize);
// 将当前可用操作数据全部读出，通过返回值返回读出的字符串
QByteArray QIODevice::readAll();
//发送数据
// 发送指针 data 指向的内存中的 maxSize 个字节的数据
qint64 QIODevice::write(const char *data, qint64 maxSize);
// 发送指针 data 指向的内存中的数据，字符串以 \0 作为结束标记
qint64 QIODevice::write(const char *data);
// 发送参数指定的字符串
qint64 QIODevice::write(const QByteArray &byteArray);
2.2 信号
//在使用QTcpSocket进行套接字通信的过程中，如果该类对象发射出readyRead()信号，说明对端发送的数据达到了，之后就可以调用 read 函数接收数据了。
[signal] void QIODevice::readyRead();
//调用connectToHost()函数并成功建立连接之后发出connected()信号。
[signal] void QAbstractSocket::connected();
//在套接字断开连接时发出disconnected()信号。
[signal] void QAbstractSocket::disconnected();
客户端
- 创建通信的套接字类QTcpSocket对象
- 使用服务器端绑定的IP和端口连接服务器QAbstractSocket::connectToHost()
- 使用QTcpSocket对象和服务器进行通信
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private slots:
void on_connectServer_clicked();
void on_sendMsg_clicked();
void on_disconnect_clicked();
private:
Ui::MainWindow *ui;
QTcpSocket* m_tcp;
};
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setWindowTitle("TCP - 客户端");
// 创建通信的套接字对象
m_tcp = new QTcpSocket(this);
// 检测服务器是否回复了数据
connect(m_tcp, &QTcpSocket::readyRead, [=]()
{
// 接收服务器发送的数据
QByteArray recvMsg = m_tcp->readAll();
ui->record->append("服务器Say: " + recvMsg);
});
// 检测是否和服务器是否连接成功了
connect(m_tcp, &QTcpSocket::connected, this, [=]()
{
ui->record->append("恭喜, 连接服务器成功!!!");
m_status->setPixmap(QPixmap(":/connect.png").scaled(20, 20));
});
// 检测服务器是否和客户端断开了连接
connect(m_tcp, &QTcpSocket::disconnected, this, [=]()
{
ui->record->append("服务器已经断开了连接, ...");
ui->connectServer->setEnabled(true);
ui->disconnect->setEnabled(false);
});
}
MainWindow::~MainWindow()
{
delete ui;
}
// 连接服务器按钮按下之后的处理动作
void MainWindow::on_connectServer_clicked()
{
QString ip = ui->ip->text();
unsigned short port = ui->port->text().toInt();
// 连接服务器
m_tcp->connectToHost(QHostAddress(ip), port);
ui->connectServer->setEnabled(false);
ui->disconnect->setEnabled(true);
}
// 发送数据按钮按下之后的处理动作
void MainWindow::on_sendMsg_clicked()
{
QString sendMsg = ui->msg->toPlainText();
m_tcp->write(sendMsg.toUtf8());
ui->record->append("客户端Say: " + sendMsg);
ui->msg->clear();
}
// 断开连接按钮被按下之后的处理动作
void MainWindow::on_disconnect_clicked()
{
m_tcp->close();
ui->connectServer->setEnabled(true);
ui->disconnect->setEnabled(false);
}
十七、C++核心编程
本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。
1 内存分区模型
C++程序在执行时，将内存大方向划分为4个区域
- 代码区：存放函数体的二进制代码，由操作系统进行管理的
- 全局区：存放全局变量和静态变量以及常量
- 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
- 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
内存四区意义：
不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程
1.1 程序运行前
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
存放 CPU 执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此.
全局区还包含了常量区, 字符串常量和其他常量也存放在此.
该区域的数据在程序结束后由操作系统释放.
示例：
//全局变量
int g_a = 10;
int g_b = 10;
//全局常量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
//局部变量
int a = 10;
int b = 10;
//打印地址
cout << "局部变量a地址为： " << (int)&a << endl;
cout << "局部变量b地址为： " << (int)&b << endl;
cout << "全局变量g_a地址为： " << (int)&g_a << endl;
cout << "全局变量g_b地址为： " << (int)&g_b << endl;
//静态变量
static int s_a = 10;
static int s_b = 10;
cout << "静态变量s_a地址为： " << (int)&s_a << endl;
cout << "静态变量s_b地址为： " << (int)&s_b << endl;
cout << "字符串常量地址为： " << (int)&"hello world" << endl;
cout << "字符串常量地址为： " << (int)&"hello world1" << endl;
cout << "全局常量c_g_a地址为： " << (int)&c_g_a << endl;
cout << "全局常量c_g_b地址为： " << (int)&c_g_b << endl;
const int c_l_a = 10;
const int c_l_b = 10;
cout << "局部常量c_l_a地址为： " << (int)&c_l_a << endl;
cout << "局部常量c_l_b地址为： " << (int)&c_l_b << endl;
system("pause");
return 0;
}
打印结果：
总结：
- C++中在程序运行前分为全局区和代码区
- 代码区特点是共享和只读
- 全局区中存放全局变量、静态变量、常量
- 常量区中存放 const修饰的全局常量 和 字符串常量
1.2 程序运行后
栈区：
由编译器自动分配释放, 存放函数的参数值,局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
示例：
int * func()
{
int a = 10;
return &a;
}
int main() {
int *p = func();
cout << *p << endl;
cout << *p << endl;
system("pause");
return 0;
}
堆区：
由程序员分配释放,若程序员不释放,程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存
示例：
int* func()
{
int* a = new int(10);
return a;
}
int main() {
int *p = func();
cout << *p << endl;
cout << *p << endl;
system("pause");
return 0;
}
总结：
堆区数据由程序员管理开辟和释放
堆区数据利用new关键字进行开辟内存
1.3 new操作符
C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete
语法： new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针
示例1： 基本语法
int* func()
{
int* a = new int(10);
return a;
}
int main() {
int *p = func();
cout << *p << endl;
cout << *p << endl;
//利用delete释放堆区数据
delete p;
//cout << *p << endl; //报错，释放的空间不可访问
system("pause");
return 0;
}
示例2：开辟数组
//堆区开辟数组
int main() {
int* arr = new int[10];
for (int i = 0; i < 10; i++)
{
arr[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
//释放数组 delete 后加 []
delete[] arr;
system("pause");
return 0;
}
1.4 new/delete与malloc/free的区别
1）malloc和free是C中的标准库函数，new和delete是C++的运算符。
2）new自身会计算申请空间大小，而malloc需要手动计算
3）new返回对象类型的指针，而malloc返回的是void*
4）new申请失败会抛出异常，mallo会返回NULL
5）new在自由存储区分配空间，malloc在堆上分配空间
虚拟空间到物理空间存在页表映射，malloc是在虚拟内存空间申请
new编译器会做一些事：
1）operator new
2）申请足够的内存空间
3）调用构造函数，初始化成员变量
delete编译器会做一些事:
1）先调用析构函数
2）operator delete
3）释放空间
2 引用
2.1 引用的基本使用
**作用： **给变量起别名
语法： 数据类型 &别名 = 原名
示例：
int main() {
int a = 10;
int &b = a;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
b = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
2.2 引用注意事项
- 引用必须初始化
- 引用在初始化后，不可以改变
示例：
int main() {
int a = 10;
int b = 20;
//int &c; //错误，引用必须初始化
int &c = a; //一旦初始化后，就不可以更改
c = b; //这是赋值操作，不是更改引用
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
system("pause");
return 0;
}
2.3 引用做函数参数
**作用：**函数传参时，可以利用引用的技术让形参修饰实参
**优点：**可以简化指针修改实参
示例：
//1. 值传递
void mySwap01(int a, int b) {
int temp = a;
a = b;
b = temp;
}
//2. 地址传递
void mySwap02(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
//3. 引用传递
void mySwap03(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
int main() {
int a = 10;
int b = 20;
mySwap01(a, b);
cout << "a:" << a << " b:" << b << endl;
mySwap02(&a, &b);
cout << "a:" << a << " b:" << b << endl;
mySwap03(a, b);
cout << "a:" << a << " b:" << b << endl;
system("pause");
return 0;
}
总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单
2.4 引用做函数返回值
作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值
示例：
//返回局部变量引用
int& test01() {
int a = 10; //局部变量
return a;
}
//返回静态变量引用
int& test02() {
static int a = 20;
return a;
}
int main() {
//不能返回局部变量的引用
int& ref = test01();
cout << "ref = " << ref << endl;
cout << "ref = " << ref << endl;
//如果函数做左值，那么必须返回引用
int& ref2 = test02();
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
test02() = 1000;
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
system("pause");
return 0;
}
2.5 引用的本质
本质：引用的本质在c++内部实现是一个指针常量.
讲解示例：
//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
int a = 10;
//自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
int& ref = a;
ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
cout << "a:" << a << endl;
cout << "ref:" << ref << endl;
func(a);
return 0;
}
结论：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了
2.6 常量引用
**作用：**常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参
示例：
//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
//v += 10;
cout << v << endl;
}
int main() {
//int& ref = 10; 引用本身需要一个合法的内存空间，因此这行错误
//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
const int& ref = 10;
//ref = 100; //加入const后不可以修改变量
cout << ref << endl;
//函数中利用常量引用防止误操作修改实参
int a = 10;
showValue(a);
system("pause");
return 0;
}
3 函数提高
3.1 函数默认参数
在C++中，函数的形参列表中的形参是可以有默认值的。
语法： 返回值类型 函数名 （参数= 默认值）{}
示例：
int func(int a, int b = 10, int c = 10) {
return a + b + c;
}
//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
return a + b;
}
int main() {
cout << "ret = " << func(20, 20) << endl;
cout << "ret = " << func(100) << endl;
system("pause");
return 0;
}
3.2 函数占位参数
C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法： 返回值类型 函数名 (数据类型){}
在现阶段函数的占位参数存在意义不大，但是后面的课程中会用到该技术
示例：
//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
cout << "this is func" << endl;
}
int main() {
func(10,10); //占位参数必须填补
system("pause");
return 0;
}
3.3 函数重载
3.3.1 函数重载概述
**作用：**函数名可以相同，提高复用性
函数重载满足条件：
- 同一个作用域下
- 函数名称相同
- 函数参数类型不同 或者 个数不同 或者 顺序不同
注意: 函数的返回值不可以作为函数重载的条件
示例：
//函数重载需要函数都在同一个作用域下
void func()
{
cout << "func 的调用！" << endl;
}
void func(int a)
{
cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
cout << "func (double a ,int b)的调用！" << endl;
}
//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
// cout << "func (double a ,int b)的调用！" << endl;
//}
int main() {
func();
func(10);
func(3.14);
func(10,3.14);
func(3.14 , 10);
system("pause");
return 0;
}
3.3.2 函数重载注意事项
- 引用作为重载条件
- 函数重载碰到函数默认参数
示例：
//函数重载注意事项
//1、引用作为重载条件
void func(int &a)
{
cout << "func (int &a) 调用 " << endl;
}
void func(const int &a)
{
cout << "func (const int &a) 调用 " << endl;
}
//2、函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
cout << "func2(int a, int b = 10) 调用" << endl;
}
void func2(int a)
{
cout << "func2(int a) 调用" << endl;
}
int main() {
int a = 10;
func(a); //调用无const
func(10);//调用有const
//func2(10); //碰到默认参数产生歧义，需要避免
system("pause");
return 0;
}
4 类和对象
C++面向对象的三大特性为：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
例如：
人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…
车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类
4.1 封装
4.1.1 封装的意义
封装是C++面向对象三大特性之一
封装的意义：
- 将属性和行为作为一个整体，表现生活中的事物
- 将属性和行为加以权限控制
封装意义一：
在设计类的时候，属性和行为写在一起，表现事物
语法： class 类名{ 访问权限： 属性 / 行为 };
**示例1：**设计一个圆类，求圆的周长
示例代码：
//圆周率
const double PI = 3.14;
//1、封装的意义
//将属性和行为作为一个整体，用来表现生活中的事物
//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名
class Circle
{
public: //访问权限 公共的权限
//属性
int m_r;//半径
//行为
//获取到圆的周长
double calculateZC()
{
//2 * pi * r
//获取圆的周长
return 2 * PI * m_r;
}
};
int main() {
//通过圆类，创建圆的对象
// c1就是一个具体的圆
Circle c1;
c1.m_r = 10; //给圆对象的半径 进行赋值操作
//2 * pi * 10 = = 62.8
cout << "圆的周长为： " << c1.calculateZC() << endl;
system("pause");
return 0;
}
**示例2：**设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
示例2代码：
//学生类
class Student {
public:
void setName(string name) {
m_name = name;
}
void setID(int id) {
m_id = id;
}
void showStudent() {
cout << "name:" << m_name << " ID:" << m_id << endl;
}
public:
string m_name;
int m_id;
};
int main() {
Student stu;
stu.setName("德玛西亚");
stu.setID(250);
stu.showStudent();
system("pause");
return 0;
}
封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
- public 公共权限
- protected 保护权限
- private 私有权限
示例：
//三种权限
//公共权限 public 类内可以访问 类外可以访问
//保护权限 protected 类内可以访问 类外不可以访问
//私有权限 private 类内可以访问 类外不可以访问
class Person
{
//姓名 公共权限
public:
string m_Name;
//汽车 保护权限
protected:
string m_Car;
//银行卡密码 私有权限
private:
int m_Password;
public:
void func()
{
m_Name = "张三";
m_Car = "拖拉机";
m_Password = 123456;
}
};
int main() {
Person p;
p.m_Name = "李四";
//p.m_Car = "奔驰"; //保护权限类外访问不到
//p.m_Password = 123; //私有权限类外访问不到
system("pause");
return 0;
}
4.1.2 struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：
- struct 默认权限为公共
- class 默认权限为私有
class C1
{
int m_A; //默认是私有权限
};
struct C2
{
int m_A; //默认是公共权限
};
int main() {
C1 c1;
c1.m_A = 10; //错误，访问权限是私有
C2 c2;
c2.m_A = 10; //正确，访问权限是公共
system("pause");
return 0;
}
4.1.3 成员属性设置为私有
**优点1：**将所有成员属性设置为私有，可以自己控制读写权限
**优点2：**对于写权限，我们可以检测数据的有效性
示例：
class Person {
public:
//姓名设置可读可写
void setName(string name) {
m_Name = name;
}
string getName()
{
return m_Name;
}
//获取年龄
int getAge() {
return m_Age;
}
//设置年龄
void setAge(int age) {
if (age < 0 || age > 150) {
cout << "你个老妖精!" << endl;
return;
}
m_Age = age;
}
//情人设置为只写
void setLover(string lover) {
m_Lover = lover;
}
private:
string m_Name; //可读可写 姓名
int m_Age; //只读 年龄
string m_Lover; //只写 情人
};
int main() {
Person p;
//姓名设置
p.setName("张三");
cout << "姓名： " << p.getName() << endl;
//年龄设置
p.setAge(50);
cout << "年龄： " << p.getAge() << endl;
//情人设置
p.setLover("苍井");
//cout << "情人： " << p.m_Lover << endl; //只写属性，不可以读取
system("pause");
return 0;
}
练习案例1：设计立方体类
设计立方体类(Cube)
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。
练习案例2：点和圆的关系
设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
4.2 对象的初始化和清理
- 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
- C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。
4.2.1 构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现。
- 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
构造函数语法：类名(){}
- 构造函数，没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数，因此可以发生重载
- 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
析构函数语法： ~类名(){}
- 析构函数，没有返回值也不写void
- 函数名称与类名相同,在名称前加上符号 ~
- 析构函数不可以有参数，因此不可以发生重载
- 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
class Person
{
public:
//构造函数
Person()
{
cout << "Person的构造函数调用" << endl;
}
//析构函数
~Person()
{
cout << "Person的析构函数调用" << endl;
}
};
void test01()
{
Person p;
}
int main() {
test01();
system("pause");
return 0;
}
4.2.2 构造函数的分类及调用
两种分类方式：
按参数分为： 有参构造和无参构造
按类型分为： 普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
示例：
//1、构造函数分类
// 按照参数分类分为 有参和无参构造 无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
//2.1 括号法，常用
Person p1(10);
//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
//test02();
system("pause");
return 0;
}
4.2.3 拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
示例：
class Person {
public:
Person() {
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person(int age) {
cout << "有参构造函数!" << endl;
mAge = age;
}
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
//析构函数在释放内存之前调用
~Person() {
cout << "析构函数!" << endl;
}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person man(100); //p对象已经创建完毕
Person newman(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
//Person newman3;
//newman3 = man; //不是调用拷贝构造函数，赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
Person p; //无参构造函数
doWork(p);
}
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}
4.2.4 构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
-
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
-
如果用户定义拷贝构造函数，c++不会再提供其他构造函数
示例：
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
void test01()
{
Person p1(18);
//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为： " << p2.age << endl;
}
void test02()
{
//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造，会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供
//如果用户提供拷贝构造，编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造，会出错
Person p5(10); //此时如果用户自己没有提供有参，会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main() {
test01();
system("pause");
return 0;
}
4.2.5 深拷贝与浅拷贝
深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
示例：
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int age ,int height) {
cout << "有参构造函数!" << endl;
m_age = age;
m_height = new int(height);
}
//拷贝构造函数
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
m_age = p.m_age;
m_height = new int(*p.m_height);
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
if (m_height != NULL)
{
delete m_height;
}
}
public:
int m_age;
int* m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
4.2.6 初始化列表
作用：
C++提供了初始化列表语法，用来初始化属性
语法：构造函数()：属性1(值1),属性2（值2）... {}
示例：
class Person {
public:
传统方式初始化
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表方式初始化
Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
void PrintPerson() {
cout << "mA:" << m_A << endl;
cout << "mB:" << m_B << endl;
cout << "mC:" << m_C << endl;
}
private:
int m_A;
int m_B;
int m_C;
};
int main() {
Person p(1, 2, 3);
p.PrintPerson();
system("pause");
return 0;
}
4.2.7 类对象作为类成员
C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员
例如：
class A {}
class B
{
A a；
}
B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
示例：
class Phone
{
public:
Phone(string name)
{
m_PhoneName = name;
cout << "Phone构造" << endl;
}
~Phone()
{
cout << "Phone析构" << endl;
}
string m_PhoneName;
};
class Person
{
public:
//初始化列表可以告诉编译器调用哪一个构造函数
Person(string name, string pName) :m_Name(name), m_Phone(pName)
{
cout << "Person构造" << endl;
}
~Person()
{
cout << "Person析构" << endl;
}
void playGame()
{
cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
}
string m_Name;
Phone m_Phone;
};
void test01()
{
//当类中成员是其他类对象时，我们称该成员为 对象成员
//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
//析构顺序与构造相反
Person p("张三" , "苹果X");
p.playGame();
}
int main() {
test01();
system("pause");
return 0;
}
4.2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
**示例1 ：**静态成员变量
class Person
{
public:
static int m_A; //静态成员变量
//静态成员变量特点：
//1 在编译阶段分配内存
//2 类内声明，类外初始化
//3 所有对象共享同一份数据
private:
static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.m_A = 100;
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200;
cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
cout << "p2.m_A = " << p2.m_A << endl;
//2、通过类名
cout << "m_A = " << Person::m_A << endl;
//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}
**示例2：**静态成员函数
class Person
{
public:
//静态成员函数特点：
//1 程序共享一个函数
//2 静态成员函数只能访问静态成员变量
static void func()
{
cout << "func调用" << endl;
m_A = 100;
//m_B = 100; //错误，不可以访问非静态成员变量
}
static int m_A; //静态成员变量
int m_B; //
private:
//静态成员函数也是有访问权限的
static void func2()
{
cout << "func2调用" << endl;
}
};
int Person::m_A = 10;
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}
4.3 C++对象模型和this指针
4.3.1 成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
class Person {
public:
Person() {
mA = 0;
}
//非静态成员变量占对象空间
int mA;
//静态成员变量不占对象空间
static int mB;
//函数也不占对象空间，所有函数共享一个函数实例
void func() {
cout << "mA:" << this->mA << endl;
}
//静态成员函数也不占对象空间
static void sfunc() {
}
};
int main() {
cout << sizeof(Person) << endl;
system("pause");
return 0;
}
4.3.2 this指针概念
通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题是：这一块代码是如何区分那个对象调用自己的呢？
c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可
this指针的用途：
- 当形参和成员变量同名时，可用this指针来区分
- 在类的非静态成员函数中返回对象本身，可使用return *this
class Person
{
public:
Person(int age)
{
//1、当形参和成员变量同名时，可用this指针来区分
this->age = age;
}
Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}
int age;
};
void test01()
{
Person p1(10);
cout << "p1.age = " << p1.age << endl;
Person p2(10);
p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
cout << "p2.age = " << p2.age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
4.3.3 空指针访问成员函数
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
示例：
//空指针访问成员函数
class Person {
public:
void ShowClassName() {
cout << "我是Person类!" << endl;
}
void ShowPerson() {
if (this == NULL) {
return;
}
cout << mAge << endl;
}
public:
int mAge;
};
void test01()
{
Person * p = NULL;
p->ShowClassName(); //空指针，可以调用成员函数
p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了
}
int main() {
test01();
system("pause");
return 0;
}
4.3.4 const修饰成员函数
常函数：
- 成员函数后加const后我们称为这个函数为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
示例：
class Person {
public:
Person() {
m_A = 0;
m_B = 0;
}
//this指针的本质是一个指针常量，指针的指向不可修改
//如果想让指针指向的值也不可以修改，需要声明常函数
void ShowPerson() const {
//const Type* const pointer;
//this = NULL; //不能修改指针的指向 Person* const this;
//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
this->m_B = 100;
}
void MyFunc() const {
//mA = 10000;
}
public:
int m_A;
mutable int m_B; //可修改 可变的
};
//const修饰对象 常对象
void test01() {
const Person person; //常量对象
cout << person.m_A << endl;
//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
//常对象访问成员函数
person.MyFunc(); //常对象不能调用const的函数
}
int main() {
test01();
system("pause");
return 0;
}
4.4 友元
生活中你的家有客厅(Public)，有你的卧室(Private)
客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去
但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的关键字为 friend
友元的三种实现
- 全局函数做友元
- 类做友元
- 成员函数做友元
4.4.1 全局函数做友元
class Building
{
//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
friend void goodGay(Building * building);
public:
Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
void goodGay(Building * building)
{
cout << "好基友正在访问： " << building->m_SittingRoom << endl;
cout << "好基友正在访问： " << building->m_BedRoom << endl;
}
void test01()
{
Building b;
goodGay(&b);
}
int main(){
test01();
system("pause");
return 0;
}
4.4.2 类做友元
class Building;
class goodGay
{
public:
goodGay();
void visit();
private:
Building *building;
};
class Building
{
//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
friend class goodGay;
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
int main(){
test01();
system("pause");
return 0;
}
4.4.3 成员函数做友元
class Building;
class goodGay
{
public:
goodGay();
void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
void visit2();
private:
Building *building;
};
class Building
{
//告诉编译器 goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
friend void goodGay::visit();
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void goodGay::visit2()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
//cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
int main(){
test01();
system("pause");
return 0;
}
4.5 运算符重载
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
4.5.1 加号运算符重载
作用：实现两个自定义数据类型相加的运算
class Person {
public:
Person() {};
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现 + 号运算符重载
Person operator+(const Person& p) {
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
public:
int m_A;
int m_B;
};
//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
// Person temp(0, 0);
// temp.m_A = p1.m_A + p2.m_A;
// temp.m_B = p1.m_B + p2.m_B;
// return temp;
//}
//运算符重载 可以发生函数重载
Person operator+(const Person& p2, int val)
{
Person temp;
temp.m_A = p2.m_A + val;
temp.m_B = p2.m_B + val;
return temp;
}
void test() {
Person p1(10, 10);
Person p2(20, 20);
//成员函数方式
Person p3 = p2 + p1; //相当于 p2.operaor+(p1)
cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
Person p4 = p3 + 10; //相当于 operator+(p3,10)
cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}
int main() {
test();
system("pause");
return 0;
}
总结1：对于内置的数据类型的表达式的的运算符是不可能改变的
总结2：不要滥用运算符重载
4.5.2 左移运算符重载
作用：可以输出自定义数据类型
class Person {
friend ostream& operator<<(ostream& out, Person& p);
public:
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数 实现不了 p << cout 不是我们想要的效果
//void operator<<(Person& p){
//}
private:
int m_A;
int m_B;
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
out << "a:" << p.m_A << " b:" << p.m_B;
return out;
}
void test() {
Person p1(10, 20);
cout << p1 << "hello world" << endl; //链式编程
}
int main() {
test();
system("pause");
return 0;
}
总结：重载左移运算符配合友元可以实现输出自定义数据类型
4.5.3 递增运算符重载
作用： 通过重载递增运算符，实现自己的整型数据
class MyInteger {
friend ostream& operator<<(ostream& out, MyInteger myint);
public:
MyInteger() {
m_Num = 0;
}
//前置++
MyInteger& operator++() {
//先++
m_Num++;
//再返回
return *this;
}
//后置++
MyInteger operator++(int) {
//先返回
MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
m_Num++;
return temp;
}
private:
int m_Num;
};
ostream& operator<<(ostream& out, MyInteger myint) {
out << myint.m_Num;
return out;
}
//前置++ 先++ 再返回
void test01() {
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main() {
test01();
//test02();
system("pause");
return 0;
}
总结： 前置递增返回引用，后置递增返回值
4.5.4 赋值运算符重载
c++编译器至少给一个类添加4个函数
- 默认构造函数(无参，函数体为空)
- 默认析构函数(无参，函数体为空)
- 默认拷贝构造函数，对属性进行值拷贝
- 赋值运算符 operator=, 对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
示例：
class Person
{
public:
Person(int age)
{
//将年龄数据开辟到堆区
m_Age = new int(age);
}
//重载赋值运算符
Person& operator=(Person &p)
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//编译器提供的代码是浅拷贝
//m_Age = p.m_Age;
//提供深拷贝 解决浅拷贝的问题
m_Age = new int(*p.m_Age);
//返回自身
return *this;
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//年龄的指针
int *m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1; //赋值操作
cout << "p1的年龄为：" << *p1.m_Age << endl;
cout << "p2的年龄为：" << *p2.m_Age << endl;
cout << "p3的年龄为：" << *p3.m_Age << endl;
}
int main() {
test01();
//int a = 10;
//int b = 20;
//int c = 30;
//c = b = a;
//cout << "a = " << a << endl;
//cout << "b = " << b << endl;
//cout << "c = " << c << endl;
system("pause");
return 0;
}
4.5.5 关系运算符重载
**作用：**重载关系运算符，可以让两个自定义类型对象进行对比操作
示例：
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
};
bool operator==(Person & p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
else
{
return false;
}
}
bool operator!=(Person & p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return false;
}
else
{
return true;
}
}
string m_Name;
int m_Age;
};
void test01()
{
//int a = 0;
//int b = 0;
Person a("孙悟空", 18);
Person b("孙悟空", 18);
if (a == b)
{
cout << "a和b相等" << endl;
}
else
{
cout << "a和b不相等" << endl;
}
if (a != b)
{
cout << "a和b不相等" << endl;
}
else
{
cout << "a和b相等" << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
4.5.6 函数调用运算符重载
- 函数调用运算符 () 也可以重载
- 由于重载后使用的方式非常像函数的调用，因此称为仿函数
- 仿函数没有固定写法，非常灵活
示例：
class MyPrint
{
public:
void operator()(string text)
{
cout << text << endl;
}
};
void test01()
{
//重载的（）操作符 也称为仿函数
MyPrint myFunc;
myFunc("hello world");
}
class MyAdd
{
public:
int operator()(int v1, int v2)
{
return v1 + v2;
}
};
void test02()
{
MyAdd add;
int ret = add(10, 10);
cout << "ret = " << ret << endl;
//匿名对象调用
cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
4.6 继承
继承是面向对象三大特性之一
有些类与类之间存在特殊的关系，例如下图中：
我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码
4.6.1 继承的基本语法
例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同
接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处
普通实现：
//Java页面
class Java
{
public:
void header()
{
cout << "首页、公开课、登录、注册...（公共头部）" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
void content()
{
cout << "JAVA学科视频" << endl;
}
};
//Python页面
class Python
{
public:
void header()
{
cout << "首页、公开课、登录、注册...（公共头部）" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
void content()
{
cout << "Python学科视频" << endl;
}
};
//C++页面
class CPP
{
public:
void header()
{
cout << "首页、公开课、登录、注册...（公共头部）" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
//Java页面
cout << "Java下载视频页面如下： " << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "--------------------" << endl;
//Python页面
cout << "Python下载视频页面如下： " << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "--------------------" << endl;
//C++页面
cout << "C++下载视频页面如下： " << endl;
CPP cp;
cp.header();
cp.footer();
cp.left();
cp.content();
}
int main() {
test01();
system("pause");
return 0;
}
继承实现：
//公共页面
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...（公共头部）" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java,Python,C++...(公共分类列表)" << endl;
}
};
//Java页面
class Java : public BasePage
{
public:
void content()
{
cout << "JAVA学科视频" << endl;
}
};
//Python页面
class Python : public BasePage
{
public:
void content()
{
cout << "Python学科视频" << endl;
}
};
//C++页面
class CPP : public BasePage
{
public:
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
//Java页面
cout << "Java下载视频页面如下： " << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "--------------------" << endl;
//Python页面
cout << "Python下载视频页面如下： " << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "--------------------" << endl;
//C++页面
cout << "C++下载视频页面如下： " << endl;
CPP cp;
cp.header();
cp.footer();
cp.left();
cp.content();
}
int main() {
test01();
system("pause");
return 0;
}
总结：
继承的好处：可以减少重复的代码
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
派生类中的成员，包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。
4.6.2 继承方式
继承的语法：class 子类 : 继承方式 父类
继承方式一共有三种：
- 公共继承
- 保护继承
- 私有继承
示例：
class Base1
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
//公共继承
class Son1 :public Base1
{
public:
void func()
{
m_A; //可访问 public权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass()
{
Son1 s1;
s1.m_A; //其他类只能访问到公共权限
}
//保护继承
class Base2
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son2:protected Base2
{
public:
void func()
{
m_A; //可访问 protected权限
m_B; //可访问 protected权限
//m_C; //不可访问
}
};
void myClass2()
{
Son2 s;
//s.m_A; //不可访问
}
//私有继承
class Base3
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son3:private Base3
{
public:
void func()
{
m_A; //可访问 private权限
m_B; //可访问 private权限
//m_C; //不可访问
}
};
class GrandSon3 :public Son3
{
public:
void func()
{
//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
//m_A;
//m_B;
//m_C;
}
};
4.6.3 继承中的对象模型
**问题：**从父类继承过来的成员，哪些属于子类对象中？
示例：
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};
//公共继承
class Son :public Base
{
public:
int m_D;
};
void test01()
{
cout << "sizeof Son = " << sizeof(Son) << endl;
}
int main() {
test01();
system("pause");
return 0;
}
利用工具查看：
打开工具窗口后，定位到当前CPP文件的盘符
然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名
效果如下图：
结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到
4.6.4 继承中构造和析构顺序
子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后？
示例：
class Base
{
public:
Base()
{
cout << "Base构造函数!" << endl;
}
~Base()
{
cout << "Base析构函数!" << endl;
}
};
class Son : public Base
{
public:
Son()
{
cout << "Son构造函数!" << endl;
}
~Son()
{
cout << "Son析构函数!" << endl;
}
};
void test01()
{
//继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
Son s;
}
int main() {
test01();
system("pause");
return 0;
}
总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
4.6.5 继承同名成员处理方式
问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
示例：
class Base {
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func()调用" << endl;
}
void func(int a)
{
cout << "Base - func(int a)调用" << endl;
}
public:
int m_A;
};
class Son : public Base {
public:
Son()
{
m_A = 200;
}
//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
void func()
{
cout << "Son - func()调用" << endl;
}
public:
int m_A;
};
void test01()
{
Son s;
cout << "Son下的m_A = " << s.m_A << endl;
cout << "Base下的m_A = " << s.Base::m_A << endl;
s.func();
s.Base::func();
s.Base::func(10);
}
int main() {
test01();
system("pause");
return EXIT_SUCCESS;
}
总结：
- 子类对象可以直接访问到子类中同名成员
- 子类对象加作用域可以访问到父类同名成员
- 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
4.6.6 继承同名静态成员处理方式
问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
示例：
class Base {
public:
static void func()
{
cout << "Base - static void func()" << endl;
}
static void func(int a)
{
cout << "Base - static void func(int a)" << endl;
}
static int m_A;
};
int Base::m_A = 100;
class Son : public Base {
public:
static void func()
{
cout << "Son - static void func()" << endl;
}
static int m_A;
};
int Son::m_A = 200;
//同名成员属性
void test01()
{
//通过对象访问
cout << "通过对象访问： " << endl;
Son s;
cout << "Son 下 m_A = " << s.m_A << endl;
cout << "Base 下 m_A = " << s.Base::m_A << endl;
//通过类名访问
cout << "通过类名访问： " << endl;
cout << "Son 下 m_A = " << Son::m_A << endl;
cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
//同名成员函数
void test02()
{
//通过对象访问
cout << "通过对象访问： " << endl;
Son s;
s.func();
s.Base::func();
cout << "通过类名访问： " << endl;
Son::func();
Son::Base::func();
//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
Son::Base::func(100);
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）
4.6.7 多继承语法
C++允许一个类继承多个类
语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承
示例：
class Base1 {
public:
Base1()
{
m_A = 100;
}
public:
int m_A;
};
class Base2 {
public:
Base2()
{
m_A = 200; //开始是m_B 不会出问题，但是改为mA就会出现不明确
}
public:
int m_A;
};
//语法：class 子类：继承方式 父类1 ，继承方式 父类2
class Son : public Base2, public Base1
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
public:
int m_C;
int m_D;
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
Son s;
cout << "sizeof Son = " << sizeof(s) << endl;
cout << s.Base1::m_A << endl;
cout << s.Base2::m_A << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域
4.6.8 菱形继承
菱形继承概念：
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承
典型的菱形继承案例：
菱形继承问题：
-
羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。 -
草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
示例：
class Animal
{
public:
int m_Age;
};
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};
void test01()
{
SheepTuo st;
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
- 利用虚继承可以解决菱形继承问题
4.7 多态
4.7.0虚函数表和虚函数指针
a.虚函数表指针存在堆区，虚函数表是数组，存在代码段当中。
b.虚函数指针指向虚函数表的首地址，虚函数表中存放的是函数地址。
c.每一个类只有一个虚函数表。
d.类的不同对象，虚函数表指针不一样。
类实例化时，把类的虚函数表地址赋值给vptr。
继承时，虚函数指针的赋值过程：
1）调用基类的构造函数，把A的虚函数表地址赋值给vptr
2）调用子类的构造函数，把B的虚函数表地址赋值给vptr
class Base {
public:
virtual void a() { cout << "Base a()" << endl; }
virtual void b() { cout << "Base b()" << endl; }
virtual void c() { cout << "Base c()" << endl; }
};
class Derive : public Base {
public:
virtual void b() { cout << "Derive b()" << endl; }
};
Derive* p = new Derive;
long* tmp = (long*)p; // 先将p强制转换为long类型指针tmp
// 由于tmp是虚函数表指针，那么*tmp就是虚函数表
long* vptr = (long*)(*tmp);
for (int i = 0; i < 3; i++) {
printf("vptr[%d] : %p\n", i, vptr[i]);
}
4.7.1 多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类
- 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
- 动态多态: 派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
下面通过案例进行讲解多态
class Animal
{
public:
//Speak函数就是虚函数
//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
class Cat :public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编
void DoSpeak(Animal & animal)
{
animal.speak();
}
//
//多态满足条件：
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象
void test01()
{
Cat cat;
DoSpeak(cat);
Dog dog;
DoSpeak(dog);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
多态满足条件
- 有继承关系
- 子类重写父类中的虚函数
多态使用条件
- 父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表 完全一致称为重写
4.7.2 多态案例一-计算器类
案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
多态的优点：
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护
示例：
//普通实现
class Calculator {
public:
int getResult(string oper)
{
if (oper == "+") {
return m_Num1 + m_Num2;
}
else if (oper == "-") {
return m_Num1 - m_Num2;
}
else if (oper == "*") {
return m_Num1 * m_Num2;
}
//如果要提供新的运算，需要修改源码
}
public:
int m_Num1;
int m_Num2;
};
void test01()
{
//普通实现测试
Calculator c;
c.m_Num1 = 10;
c.m_Num2 = 10;
cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;
cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;
cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}
//多态实现
//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator
{
public :
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
//加法计算器
class AddCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 + m_Num2;
}
};
//减法计算器
class SubCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 - m_Num2;
}
};
//乘法计算器
class MulCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 * m_Num2;
}
};
void test02()
{
//创建加法计算器
AbstractCalculator *abc = new AddCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
delete abc; //用完了记得销毁
//创建减法计算器
abc = new SubCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
delete abc;
//创建乘法计算器
abc = new MulCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
delete abc;
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：C++开发提倡利用多态设计程序架构，因为多态优点很多
4.7.3 纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
示例：
class Base
{
public:
//纯虚函数
//类中只要有一个纯虚函数就称为抽象类
//抽象类无法实例化对象
//子类必须重写父类中的纯虚函数，否则也属于抽象类
virtual void func() = 0;
};
class Son :public Base
{
public:
virtual void func()
{
cout << "func调用" << endl;
};
};
void test01()
{
Base * base = NULL;
//base = new Base; // 错误，抽象类无法实例化对象
base = new Son;
base->func();
delete base;//记得销毁
}
int main() {
test01();
system("pause");
return 0;
}
4.7.4 多态案例二-制作饮品
案例描述：
制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
示例：
//抽象制作饮品
class AbstractDrinking {
public:
//烧水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加入辅料
virtual void PutSomething() = 0;
//规定流程
void MakeDrink() {
Boil();
Brew();
PourInCup();
PutSomething();
}
};
//制作咖啡
class Coffee : public AbstractDrinking {
public:
//烧水
virtual void Boil() {
cout << "煮农夫山泉!" << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡咖啡!" << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "将咖啡倒入杯中!" << endl;
}
//加入辅料
virtual void PutSomething() {
cout << "加入牛奶!" << endl;
}
};
//制作茶水
class Tea : public AbstractDrinking {
public:
//烧水
virtual void Boil() {
cout << "煮自来水!" << endl;
}
//冲泡
virtual void Brew() {
cout << "冲泡茶叶!" << endl;
}
//倒入杯中
virtual void PourInCup() {
cout << "将茶水倒入杯中!" << endl;
}
//加入辅料
virtual void PutSomething() {
cout << "加入枸杞!" << endl;
}
};
//业务函数
void DoWork(AbstractDrinking* drink) {
drink->MakeDrink();
delete drink;
}
void test01() {
DoWork(new Coffee);
cout << "--------------" << endl;
DoWork(new Tea);
}
int main() {
test01();
system("pause");
return 0;
}
4.7.5 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：
virtual ~类名(){}
纯虚析构语法：
virtual ~类名() = 0;
类名::~类名(){}
示例：
class Animal {
public:
Animal()
{
cout << "Animal 构造函数调用！" << endl;
}
virtual void Speak() = 0;
//析构函数加上virtual关键字，变成虚析构函数
//virtual ~Animal()
//{
// cout << "Animal虚析构函数调用！" << endl;
//}
virtual ~Animal() = 0;
};
Animal::~Animal()
{
cout << "Animal 纯虚析构函数调用！" << endl;
}
//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。
class Cat : public Animal {
public:
Cat(string name)
{
cout << "Cat构造函数调用！" << endl;
m_Name = new string(name);
}
virtual void Speak()
{
cout << *m_Name << "小猫在说话!" << endl;
}
~Cat()
{
cout << "Cat析构函数调用!" << endl;
if (this->m_Name != NULL) {
delete m_Name;
m_Name = NULL;
}
}
public:
string *m_Name;
};
void test01()
{
Animal *animal = new Cat("Tom");
animal->Speak();
//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
//怎么解决？给基类增加一个虚析构函数
//虚析构函数就是用来解决通过父类指针释放子类对象
delete animal;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类
4.7.6 多态案例三-电脑组装
案例描述：
电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
示例：
#include<iostream>
using namespace std;
//抽象CPU类
class CPU
{
public:
//抽象的计算函数
virtual void calculate() = 0;
};
//抽象显卡类
class VideoCard
{
public:
//抽象的显示函数
virtual void display() = 0;
};
//抽象内存条类
class Memory
{
public:
//抽象的存储函数
virtual void storage() = 0;
};
//电脑类
class Computer
{
public:
Computer(CPU * cpu, VideoCard * vc, Memory * mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
}
//提供工作的函数
void work()
{
//让零件工作起来，调用接口
m_cpu->calculate();
m_vc->display();
m_mem->storage();
}
//提供析构函数 释放3个电脑零件
~Computer()
{
//释放CPU零件
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
//释放显卡零件
if (m_vc != NULL)
{
delete m_vc;
m_vc = NULL;
}
//释放内存条零件
if (m_mem != NULL)
{
delete m_mem;
m_mem = NULL;
}
}
private:
CPU * m_cpu; //CPU的零件指针
VideoCard * m_vc; //显卡零件指针
Memory * m_mem; //内存条零件指针
};
//具体厂商
//Intel厂商
class IntelCPU :public CPU
{
public:
virtual void calculate()
{
cout << "Intel的CPU开始计算了！" << endl;
}
};
class IntelVideoCard :public VideoCard
{
public:
virtual void display()
{
cout << "Intel的显卡开始显示了！" << endl;
}
};
class IntelMemory :public Memory
{
public:
virtual void storage()
{
cout << "Intel的内存条开始存储了！" << endl;
}
};
//Lenovo厂商
class LenovoCPU :public CPU
{
public:
virtual void calculate()
{
cout << "Lenovo的CPU开始计算了！" << endl;
}
};
class LenovoVideoCard :public VideoCard
{
public:
virtual void display()
{
cout << "Lenovo的显卡开始显示了！" << endl;
}
};
class LenovoMemory :public Memory
{
public:
virtual void storage()
{
cout << "Lenovo的内存条开始存储了！" << endl;
}
};
void test01()
{
//第一台电脑零件
CPU * intelCpu = new IntelCPU;
VideoCard * intelCard = new IntelVideoCard;
Memory * intelMem = new IntelMemory;
cout << "第一台电脑开始工作：" << endl;
//创建第一台电脑
Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);
computer1->work();
delete computer1;
cout << "-----------------------" << endl;
cout << "第二台电脑开始工作：" << endl;
//第二台电脑组装
Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;
computer2->work();
delete computer2;
cout << "-----------------------" << endl;
cout << "第三台电脑开始工作：" << endl;
//第三台电脑组装
Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;
computer3->work();
delete computer3;
}
5 文件操作
程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
通过文件可以将数据持久化
C++中对文件操作需要包含头文件 < fstream >
文件类型分为两种：
- 文本文件 - 文件以文本的ASCII码形式存储在计算机中
- 二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们
操作文件的三大类:
- ofstream：写操作
- ifstream： 读操作
- fstream ： 读写操作
5.1文本文件
5.1.1写文件
写文件步骤如下：
-
包含头文件
#include <fstream>
-
创建流对象
ofstream ofs;
-
打开文件
ofs.open(“文件路径”,打开方式);
-
写数据
ofs << “写入的数据”;
-
关闭文件
ofs.close();
文件打开方式：
| 打开方式 | 解释 |
|---|---|
| ios::in | 为读文件而打开文件 |
| ios::out | 为写文件而打开文件 |
| ios::ate | 初始位置：文件尾 |
| ios::app | 追加方式写文件 |
| ios::trunc | 如果文件存在先删除，再创建 |
| ios::binary | 二进制方式 |
注意： 文件打开方式可以配合使用，利用|操作符
**例如：**用二进制方式写文件 ios::binary | ios:: out
示例：
#include <fstream>
void test01()
{
ofstream ofs;
ofs.open("test.txt", ios::out);
ofs << "姓名：张三" << endl;
ofs << "性别：男" << endl;
ofs << "年龄：18" << endl;
ofs.close();
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 文件操作必须包含头文件 fstream
- 读文件可以利用 ofstream ，或者fstream类
- 打开文件时候需要指定操作文件的路径，以及打开方式
- 利用<<可以向文件中写数据
- 操作完毕，要关闭文件
5.1.2读文件
读文件与写文件步骤相似，但是读取方式相对于比较多
读文件步骤如下：
-
包含头文件
#include <fstream>
-
创建流对象
ifstream ifs;
-
打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);
-
读数据
四种方式读取
-
关闭文件
ifs.close();
示例：
#include <fstream>
#include <string>
void test01()
{
ifstream ifs;
ifs.open("test.txt", ios::in);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
return;
}
//第一种方式
//char buf[1024] = { 0 };
//while (ifs >> buf)
//{
// cout << buf << endl;
//}
//第二种
//char buf[1024] = { 0 };
//while (ifs.getline(buf,sizeof(buf)))
//{
// cout << buf << endl;
//}
//第三种
//string buf;
//while (getline(ifs, buf))
//{
// cout << buf << endl;
//}
char c;
while ((c = ifs.get()) != EOF)
{
cout << c;
}
ifs.close();
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 读文件可以利用 ifstream ，或者fstream类
- 利用is_open函数可以判断文件是否打开成功
- close 关闭文件
5.2 二进制文件
以二进制的方式对文件进行读写操作
打开方式要指定为 ios::binary
5.2.1 写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型 ：ostream& write(const char * buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例：
#include <fstream>
#include <string>
class Person
{
public:
char m_Name[64];
int m_Age;
};
//二进制文件 写文件
void test01()
{
//1、包含头文件
//2、创建输出流对象
ofstream ofs("person.txt", ios::out | ios::binary);
//3、打开文件
//ofs.open("person.txt", ios::out | ios::binary);
Person p = {"张三" , 18};
//4、写文件
ofs.write((const char *)&p, sizeof(p));
//5、关闭文件
ofs.close();
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 文件输出流对象 可以通过write函数，以二进制方式写数据
5.2.2 读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char *buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
示例：
#include <fstream>
#include <string>
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test01()
{
ifstream ifs("person.txt", ios::in | ios::binary);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
}
Person p;
ifs.read((char *)&p, sizeof(p));
cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
- 文件输入流对象 可以通过read函数，以二进制方式读数据
十八、C++提高编程
- 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用
1 模板
1.1 模板的概念
模板就是建立通用的模具，大大提高复用性
1.2 函数模板
-
C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板
-
C++提供两种模板机制:函数模板和类模板
1.2.1 函数模板语法
函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template<typename T>
函数声明或定义
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母
示例：
//交换整型函数
void swapInt(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
//交换浮点型函数
void swapDouble(double& a, double& b) {
double temp = a;
a = b;
b = temp;
}
//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
//swapInt(a, b);
//利用模板实现交换
//1、自动类型推导
mySwap(a, b);
//2、显示指定类型
mySwap<int>(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 函数模板利用关键字 template
- 使用函数模板有两种方式：自动类型推导、显示指定类型
- 模板的目的是为了提高复用性，将类型参数化
1.2.2 函数模板注意事项
注意事项：
-
自动类型推导，必须推导出一致的数据类型T,才可以使用
-
模板必须要确定出T的数据类型，才可以使用
示例：
//利用模板提供通用的交换函数
template<class T>
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{
int a = 10;
int b = 20;
char c = 'c';
mySwap(a, b); // 正确，可以推导出一致的T
//mySwap(a, c); // 错误，推导不出一致的T类型
}
// 2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()
{
cout << "func 调用" << endl;
}
void test02()
{
//func(); //错误，模板不能独立使用，必须确定出T的类型
func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：
- 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型
1.2.3 函数模板案例
案例描述：
- 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
- 排序规则从大到小，排序算法为选择排序
- 分别利用char数组和int数组进行测试
示例：
//交换的函数模板
template<typename T>
void mySwap(T &a, T&b)
{
T temp = a;
a = b;
b = temp;
}
template<class T> // 也可以替换成typename
//利用选择排序，进行对数组从大到小的排序
void mySort(T arr[], int len)
{
for (int i = 0; i < len; i++)
{
int max = i; //最大数的下标
for (int j = i + 1; j < len; j++)
{
if (arr[max] < arr[j])
{
max = j;
}
}
if (max != i) //如果最大数的下标不是i，交换两者
{
mySwap(arr[max], arr[i]);
}
}
}
template<typename T>
void printArray(T arr[], int len) {
for (int i = 0; i < len; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
void test01()
{
//测试char数组
char charArr[] = "bdcfeagh";
int num = sizeof(charArr) / sizeof(char);
mySort(charArr, num);
printArray(charArr, num);
}
void test02()
{
//测试int数组
int intArr[] = { 7, 5, 8, 1, 3, 9, 2, 4, 6 };
int num = sizeof(intArr) / sizeof(int);
mySort(intArr, num);
printArray(intArr, num);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：模板可以提高代码复用，需要熟练掌握
1.2.4 普通函数与函数模板的区别
普通函数与函数模板区别：
- 普通函数调用时可以发生自动类型转换（隐式类型转换）
- 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
- 如果利用显示指定类型的方式，可以发生隐式类型转换
示例：
//普通函数
int myAdd01(int a, int b)
{
return a + b;
}
//函数模板
template<class T>
T myAdd02(T a, T b)
{
return a + b;
}
//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{
int a = 10;
int b = 20;
char c = 'c';
cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型 'c' 对应 ASCII码 99
//myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换
myAdd02<int>(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换
}
int main() {
test01();
system("pause");
return 0;
}
总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T
1.2.5 普通函数与函数模板的调用规则
调用规则如下：
- 如果函数模板和普通函数都可以实现，优先调用普通函数
- 可以通过空模板参数列表来强制调用函数模板
- 函数模板也可以发生重载
- 如果函数模板可以产生更好的匹配,优先调用函数模板
示例：
//普通函数与函数模板调用规则
void myPrint(int a, int b)
{
cout << "调用的普通函数" << endl;
}
template<typename T>
void myPrint(T a, T b)
{
cout << "调用的模板" << endl;
}
template<typename T>
void myPrint(T a, T b, T c)
{
cout << "调用重载的模板" << endl;
}
void test01()
{
//1、如果函数模板和普通函数都可以实现，优先调用普通函数
// 注意 如果告诉编译器 普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
int a = 10;
int b = 20;
myPrint(a, b); //调用普通函数
//2、可以通过空模板参数列表来强制调用函数模板
myPrint<>(a, b); //调用函数模板
//3、函数模板也可以发生重载
int c = 30;
myPrint(a, b, c); //调用重载的函数模板
//4、 如果函数模板可以产生更好的匹配,优先调用函数模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2); //调用函数模板
}
int main() {
test01();
system("pause");
return 0;
}
总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性
1.2.6 模板的局限性
局限性：
- 模板的通用性并不是万能的
例如：
template<class T>
void f(T a, T b)
{
a = b;
}
在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了
再例如：
template<class T>
void f(T a, T b)
{
if(a > b) { ... }
}
在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板
示例：
#include<iostream>
using namespace std;
#include <string>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
//普通函数模板
template<class T>
bool myCompare(T& a, T& b)
{
if (a == b)
{
return true;
}
else
{
return false;
}
}
//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person &p1, Person &p2)
{
if ( p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
{
return true;
}
else
{
return false;
}
}
void test01()
{
int a = 10;
int b = 20;
//内置数据类型可以直接使用通用的函数模板
bool ret = myCompare(a, b);
if (ret)
{
cout << "a == b " << endl;
}
else
{
cout << "a != b " << endl;
}
}
void test02()
{
Person p1("Tom", 10);
Person p2("Tom", 10);
//自定义数据类型，不会调用普通的函数模板
//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1 == p2 " << endl;
}
else
{
cout << "p1 != p2 " << endl;
}
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：
- 利用具体化的模板，可以解决自定义类型的通用化
- 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板
1.3 类模板
1.3.1 类模板语法
类模板作用：
- 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template<typename T>
类
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母
示例：
#include <string>
//类模板
template<class NameType, class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->mName = name;
this->mAge = age;
}
void showPerson()
{
cout << "name: " << this->mName << " age: " << this->mAge << endl;
}
public:
NameType mName;
AgeType mAge;
};
void test01()
{
// 指定NameType 为string类型，AgeType 为 int类型
Person<string, int>P1("孙悟空", 999);
P1.showPerson();
}
int main() {
test01();
system("pause");
return 0;
}
总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板
1.3.2 类模板与函数模板区别
类模板与函数模板区别主要有两点：
- 类模板没有自动类型推导的使用方式
- 类模板在模板参数列表中可以有默认参数
示例：
#include <string>
//类模板
template<class NameType, class AgeType = int>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->mName = name;
this->mAge = age;
}
void showPerson()
{
cout << "name: " << this->mName << " age: " << this->mAge << endl;
}
public:
NameType mName;
AgeType mAge;
};
//1、类模板没有自动类型推导的使用方式
void test01()
{
// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导
Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板
p.showPerson();
}
//2、类模板在模板参数列表中可以有默认参数
void test02()
{
Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
p.showPerson();
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：
- 类模板使用只能用显示指定类型方式
- 类模板中的模板参数列表可以有默认参数
1.3.3 类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的：
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才创建
示例：
class Person1
{
public:
void showPerson1()
{
cout << "Person1 show" << endl;
}
};
class Person2
{
public:
void showPerson2()
{
cout << "Person2 show" << endl;
}
};
template<class T>
class MyClass
{
public:
T obj;
//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
void fun1() { obj.showPerson1(); }
void fun2() { obj.showPerson2(); }
};
void test01()
{
MyClass<Person1> m;
m.fun1();
//m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}
int main() {
test01();
system("pause");
return 0;
}
总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建
1.3.4 类模板对象做函数参数
学习目标：
- 类模板实例化出的对象，向函数传参的方式
一共有三种传入方式：
- 指定传入的类型 — 直接显示对象的数据类型
- 参数模板化 — 将对象中的参数变为模板进行传递
- 整个类模板化 — 将这个对象类型 模板化进行传递
示例：
#include <string>
//类模板
template<class NameType, class AgeType = int>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->mName = name;
this->mAge = age;
}
void showPerson()
{
cout << "name: " << this->mName << " age: " << this->mAge << endl;
}
public:
NameType mName;
AgeType mAge;
};
//1、指定传入的类型
void printPerson1(Person<string, int> &p)
{
p.showPerson();
}
void test01()
{
Person <string, int >p("孙悟空", 100);
printPerson1(p);
}
//2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
p.showPerson();
cout << "T1的类型为： " << typeid(T1).name() << endl;
cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{
Person <string, int >p("猪八戒", 90);
printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T & p)
{
cout << "T的类型为： " << typeid(T).name() << endl;
p.showPerson();
}
void test03()
{
Person <string, int >p("唐僧", 30);
printPerson3(p);
}
int main() {
test01();
test02();
test03();
system("pause");
return 0;
}
总结：
- 通过类模板创建的对象，可以有三种方式向函数中进行传参
- 使用比较广泛是第一种：指定传入的类型
1.3.5 类模板与继承
当类模板碰到继承时，需要注意一下几点：
- 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
- 如果不指定，编译器无法给子类分配内存
- 如果想灵活指定出父类中T的类型，子类也需变为类模板
示例：
template<class T>
class Base
{
T m;
};
//class Son:public Base //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> //必须指定一个类型
{
};
void test01()
{
Son c;
}
//类模板继承类模板 ,可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
Son2()
{
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
}
};
void test02()
{
Son2<int, char> child1;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：如果父类是类模板，子类需要指定出父类中T的数据类型
1.3.6 类模板成员函数类外实现
学习目标：能够掌握类模板中的成员函数类外实现
示例：
#include <string>
//类模板中成员函数类外实现
template<class T1, class T2>
class Person {
public:
//成员函数类内声明
Person(T1 name, T2 age);
void showPerson();
public:
T1 m_Name;
T2 m_Age;
};
//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
this->m_Name = name;
this->m_Age = age;
}
//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
void test01()
{
Person<string, int> p("Tom", 20);
p.showPerson();
}
int main() {
test01();
system("pause");
return 0;
}
总结：类模板中成员函数类外实现时，需要加上模板参数列表
1.3.7 类模板分文件编写
学习目标：
- 掌握类模板成员函数分文件编写产生的问题以及解决方式
问题：
- 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
- 解决方式1：直接包含.cpp源文件
- 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
示例：
person.hpp中代码：
#pragma once
#include <iostream>
using namespace std;
#include <string>
template<class T1, class T2>
class Person {
public:
Person(T1 name, T2 age);
void showPerson();
public:
T1 m_Name;
T2 m_Age;
};
//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
this->m_Name = name;
this->m_Age = age;
}
//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
类模板分文件编写.cpp中代码
#include<iostream>
using namespace std;
//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件
//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test01()
{
Person<string, int> p("Tom", 10);
p.showPerson();
}
int main() {
test01();
system("pause");
return 0;
}
总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp
1.3.8 类模板与友元
学习目标：
- 掌握类模板配合友元函数的类内和类外实现
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
示例：
#include <string>
//2、全局函数配合友元 类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template<class T1, class T2> class Person;
//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template<class T1, class T2> void printPerson2(Person<T1, T2> & p);
template<class T1, class T2>
void printPerson2(Person<T1, T2> & p)
{
cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
//1、全局函数配合友元 类内实现
friend void printPerson(Person<T1, T2> & p)
{
cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}
//全局函数配合友元 类外实现
friend void printPerson2<>(Person<T1, T2> & p);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//1、全局函数在类内实现
void test01()
{
Person <string, int >p("Tom", 20);
printPerson(p);
}
//2、全局函数在类外实现
void test02()
{
Person <string, int >p("Jerry", 30);
printPerson2(p);
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别
1.3.9 类模板案例
案例描述: 实现一个通用的数组类，要求如下：
- 可以对内置数据类型以及自定义数据类型的数据进行存储
- 将数组中的数据存储到堆区
- 构造函数中可以传入数组的容量
- 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
- 提供尾插法和尾删法对数组中的数据进行增加和删除
- 可以通过下标的方式访问数组中的元素
- 可以获取数组中当前元素个数和数组的容量
示例：
myArray.hpp中代码
#pragma once
#include <iostream>
using namespace std;
template<class T>
class MyArray
{
public:
//构造函数
MyArray(int capacity)
{
this->m_Capacity = capacity;
this->m_Size = 0;
pAddress = new T[this->m_Capacity];
}
//拷贝构造
MyArray(const MyArray & arr)
{
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < this->m_Size; i++)
{
//如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，
// 普通类型可以直接= 但是指针类型需要深拷贝
this->pAddress[i] = arr.pAddress[i];
}
}
//重载= 操作符 防止浅拷贝问题
MyArray& operator=(const MyArray& myarray) {
if (this->pAddress != NULL) {
delete[] this->pAddress;
this->m_Capacity = 0;
this->m_Size = 0;
}
this->m_Capacity = myarray.m_Capacity;
this->m_Size = myarray.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < this->m_Size; i++) {
this->pAddress[i] = myarray[i];
}
return *this;
}
//重载[] 操作符 arr[0]
T& operator [](int index)
{
return this->pAddress[index]; //不考虑越界，用户自己去处理
}
//尾插法
void Push_back(const T & val)
{
if (this->m_Capacity == this->m_Size)
{
return;
}
this->pAddress[this->m_Size] = val;
this->m_Size++;
}
//尾删法
void Pop_back()
{
if (this->m_Size == 0)
{
return;
}
this->m_Size--;
}
//获取数组容量
int getCapacity()
{
return this->m_Capacity;
}
//获取数组大小
int getSize()
{
return this->m_Size;
}
//析构
~MyArray()
{
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;
this->m_Capacity = 0;
this->m_Size = 0;
}
}
private:
T * pAddress; //指向一个堆空间，这个空间存储真正的数据
int m_Capacity; //容量
int m_Size; // 大小
};
类模板案例—数组类封装.cpp中
#include "myArray.hpp"
#include <string>
void printIntArray(MyArray<int>& arr) {
for (int i = 0; i < arr.getSize(); i++) {
cout << arr[i] << " ";
}
cout << endl;
}
//测试内置数据类型
void test01()
{
MyArray<int> array1(10);
for (int i = 0; i < 10; i++)
{
array1.Push_back(i);
}
cout << "array1打印输出：" << endl;
printIntArray(array1);
cout << "array1的大小：" << array1.getSize() << endl;
cout << "array1的容量：" << array1.getCapacity() << endl;
cout << "--------------------------" << endl;
MyArray<int> array2(array1);
array2.Pop_back();
cout << "array2打印输出：" << endl;
printIntArray(array2);
cout << "array2的大小：" << array2.getSize() << endl;
cout << "array2的容量：" << array2.getCapacity() << endl;
}
//测试自定义数据类型
class Person {
public:
Person() {}
Person(string name, int age) {
this->m_Name = name;
this->m_Age = age;
}
public:
string m_Name;
int m_Age;
};
void printPersonArray(MyArray<Person>& personArr)
{
for (int i = 0; i < personArr.getSize(); i++) {
cout << "姓名：" << personArr[i].m_Name << " 年龄： " << personArr[i].m_Age << endl;
}
}
void test02()
{
//创建数组
MyArray<Person> pArray(10);
Person p1("孙悟空", 30);
Person p2("韩信", 20);
Person p3("妲己", 18);
Person p4("王昭君", 15);
Person p5("赵云", 24);
//插入数据
pArray.Push_back(p1);
pArray.Push_back(p2);
pArray.Push_back(p3);
pArray.Push_back(p4);
pArray.Push_back(p5);
printPersonArray(pArray);
cout << "pArray的大小：" << pArray.getSize() << endl;
cout << "pArray的容量：" << pArray.getCapacity() << endl;
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：
能够利用所学知识点实现通用的数组
2 STL初识
2.1 STL的诞生
-
长久以来，软件界一直希望建立一种可重复利用的东西
-
C++的面向对象和泛型编程思想，目的就是复用性的提升
-
大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作
-
为了建立数据结构和算法的一套标准,诞生了STL
2.2 STL基本概念
- STL(Standard Template Library,标准模板库)
- STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
- 容器和算法之间通过迭代器进行无缝连接。
- STL 几乎所有的代码都采用了模板类或者模板函数
2.3 STL六大组件
STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器
- 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
- 算法：各种常用的算法，如sort、find、copy、for_each等
- 迭代器：扮演了容器与算法之间的胶合剂。
- 仿函数：行为类似函数，可作为算法的某种策略。
- 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
- 空间配置器：负责空间的配置与管理。
2.4 STL中容器、算法、迭代器
**容器：**置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表 等
这些容器分为序列式容器和关联式容器两种:
序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
**算法：**问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)
算法分为:质变算法和非质变算法。
质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等
**迭代器：**容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
迭代器种类：
| 种类 | 功能 | 支持运算 |
|---|---|---|
| 输入迭代器 | 对数据的只读访问 | 只读，支持++、==、！= |
| 输出迭代器 | 对数据的只写访问 | 只写，支持++ |
| 前向迭代器 | 读写操作，并能向前推进迭代器 | 读写，支持++、==、！= |
| 双向迭代器 | 读写操作，并能向前和向后操作 | 读写，支持++、–， |
| 随机访问迭代器 | 读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器 | 读写，支持++、–、[n]、-n、<、<=、>、>= |
常用的容器中迭代器种类为双向迭代器，和随机访问迭代器
2.5 容器算法迭代器初识
了解STL中容器、算法、迭代器概念之后，我们利用代码感受STL的魅力
STL中最常用的容器为Vector，可以理解为数组，下面我们将学习如何向这个容器中插入数据、并遍历这个容器
2.5.1 vector存放内置数据类型
容器： vector
算法： for_each
迭代器： vector<int>::iterator
示例：
#include <vector>
#include <algorithm>
void MyPrint(int val)
{
cout << val << endl;
}
void test01() {
//创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
vector<int> v;
//向容器中放数据
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
//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 << endl;
pBegin++;
}
//第二种遍历方式：
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << endl;
}
cout << endl;
//第三种遍历方式：
//使用STL提供标准遍历算法 头文件 algorithm
for_each(v.begin(), v.end(), MyPrint);
}
int main() {
test01();
system("pause");
return 0;
}
2.5.2 Vector存放自定义数据类型
学习目标：vector中存放自定义数据类型，并打印输出
示例：
#include <vector>
#include <string>
//自定义数据类型
class Person {
public:
Person(string name, int age) {
mName = name;
mAge = age;
}
public:
string mName;
int mAge;
};
//存放对象
void test01() {
vector<Person> v;
//创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);
Person p5("eee", 50);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
cout << "Name:" << (*it).mName << " Age:" << (*it).mAge << endl;
}
}
//放对象指针
void test02() {
vector<Person*> v;
//创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);
Person p5("eee", 50);
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
Person * p = (*it);
cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;
}
}
int main() {
test01();
test02();
system("pause");
return 0;
}
2.5.3 Vector容器嵌套容器
学习目标：容器中嵌套容器，我们将所有数据进行遍历输出
示例：
#include <vector>
//容器嵌套容器
void test01() {
vector< vector<int> > v;
vector<int> v1;
vector<int> v2;
vector<int> v3;
vector<int> v4;
for (int i = 0; i < 4; i++) {
v1.push_back(i + 1);
v2.push_back(i + 2);
v3.push_back(i + 3);
v4.push_back(i + 4);
}
//将容器元素插入到vector v中
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++) {
cout << *vit << " ";
}
cout << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
3 STL- 常用容器
3.1 string容器
3.1.1 string基本概念
本质：
- string是C++风格的字符串，而string本质上是一个类
string和char * 区别：
- char * 是一个指针
- string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。
特点：
string 类内部封装了很多成员方法
例如：查找find，拷贝copy，删除delete 替换replace，插入insert
string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责
3.1.2 string构造函数
构造函数原型：
string();//创建一个空的字符串 例如: string str;
string(const char* s);//使用字符串s初始化string(const string& str);//使用一个string对象初始化另一个string对象string(int n, char c);//使用n个字符c初始化
示例：
#include <string>
//string构造
void test01()
{
string s1; //创建空字符串，调用无参构造函数
cout << "str1 = " << s1 << endl;
const char* str = "hello world";
string s2(str); //把c_string转换成了string
cout << "str2 = " << s2 << endl;
string s3(s2); //调用拷贝构造函数
cout << "str3 = " << s3 << endl;
string s4(10, 'a');
cout << "str3 = " << s3 << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：string的多种构造方式没有可比性，灵活使用即可
3.1.3 string赋值操作
功能描述：
- 给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赋给当前字符串
示例：
//赋值
void test01()
{
string str1;
str1 = "hello world";
cout << "str1 = " << str1 << endl;
string str2;
str2 = str1;
cout << "str2 = " << str2 << endl;
string str3;
str3 = 'a';
cout << "str3 = " << str3 << endl;
string str4;
str4.assign("hello c++");
cout << "str4 = " << str4 << endl;
string str5;
str5.assign("hello c++",5);
cout << "str5 = " << str5 << endl;
string str6;
str6.assign(str5);
cout << "str6 = " << str6 << endl;
string str7;
str7.assign(5, 'x');
cout << "str7 = " << str7 << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
string的赋值方式很多，operator= 这种方式是比较实用的
3.1.4 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个字符连接到字符串结尾
示例：
//字符串拼接
void test01()
{
string str1 = "我";
str1 += "爱玩游戏";
cout << "str1 = " << str1 << endl;
str1 += ':';
cout << "str1 = " << str1 << endl;
string str2 = "LOL DNF";
str1 += str2;
cout << "str1 = " << str1 << endl;
string str3 = "I";
str3.append(" love ");
str3.append("game abcde", 4);
//str3.append(str2);
str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾
cout << "str3 = " << str3 << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：字符串拼接的重载版本很多，初学阶段记住几种即可
3.1.5 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个字符为字符串strstring& replace(int pos, int n,const char* s);//替换从pos开始的n个字符为字符串s
示例：
//查找和替换
void test01()
{
//查找
string str1 = "abcdefgde";
int pos = str1.find("de");
if (pos == -1)
{
cout << "未找到" << endl;
}
else
{
cout << "pos = " << pos << endl;
}
pos = str1.rfind("de");
cout << "pos = " << pos << endl;
}
void test02()
{
//替换
string str1 = "abcdefgde";
str1.replace(1, 3, "1111");
cout << "str1 = " << str1 << endl;
}
int main() {
//test01();
//test02();
system("pause");
return 0;
}
总结：
- find查找是从左往后，rfind从右往左
- find找到字符串后返回查找的第一个字符位置，找不到返回-1
- replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串
3.1.6 string字符串比较
功能描述：
- 字符串之间的比较
比较方式：
- 字符串比较是按字符的ASCII码进行对比
= 返回 0
> 返回 1
< 返回 -1
函数原型：
int compare(const string &s) const;//与字符串s比较int compare(const char *s) const;//与字符串s比较
示例：
//字符串比较
void test01()
{
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;
}
}
int main() {
test01();
system("pause");
return 0;
}
总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大
3.1.7 string字符存取
string中单个字符存取方式有两种
char& operator[](int n);//通过[]方式取字符char& at(int n);//通过at方法获取字符
示例：
void test01()
{
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;
}
int main() {
test01();
system("pause");
return 0;
}
总结：string字符串中单个字符存取有两种方式，利用 [ ] 或 at
3.1.8 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个字符cstring& erase(int pos, int n = npos);//删除从Pos开始的n个字符
示例：
//字符串插入和删除
void test01()
{
string str = "hello";
str.insert(1, "111");
cout << str << endl;
str.erase(1, 3); //从1号位置开始3个字符
cout << str << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**插入和删除的起始下标都是从0开始
3.1.9 string子串
功能描述：
- 从字符串中获取想要的子串
函数原型：
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
示例：
//子串
void test01()
{
string str = "abcdefg";
string subStr = str.substr(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;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**灵活的运用求子串功能，可以在实际开发中获取有效的信息
3.2 vector容器
3.2.1 vector基本概念
功能：
- vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别：
- 不同之处在于数组是静态空间，而vector可以动态扩展
动态扩展：
- 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
- vector容器的迭代器是支持随机访问的迭代器
3.2.2 vector构造函数
功能描述：
- 创建vector容器
函数原型：
vector<T> v;//采用模板实现类实现，默认构造函数vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。vector(n, elem);//构造函数将n个elem拷贝给本身。vector(const vector &vec);//拷贝构造函数。
示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1; //无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector<int> v2(v1.begin(), v1.end());
printVector(v2);
vector<int> v3(10, 100);
printVector(v3);
vector<int> v4(v3);
printVector(v4);
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**vector的多种构造方式没有可比性，灵活使用即可
3.2.3 vector赋值操作
功能描述：
- 给vector容器进行赋值
函数原型：
-
vector& operator=(const vector &vec);//重载等号操作符 -
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 -
assign(n, elem);//将n个elem拷贝赋值给本身。
示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//赋值操作
void test01()
{
vector<int> v1; //无参构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector<int>v2;
v2 = v1;
printVector(v2);
vector<int>v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);
vector<int>v4;
v4.assign(10, 100);
printVector(v4);
}
int main() {
test01();
system("pause");
return 0;
}
总结： vector赋值方式比较简单，使用operator=，或者assign都可以
3.2.4 vector容量和大小
功能描述：
- 对vector容器的容量和大小操作
函数原型：
-
empty();//判断容器是否为空 -
capacity();//容器的容量 -
size();//返回容器中元素的个数 -
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
-
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除
示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
if (v1.empty())
{
cout << "v1为空" << endl;
}
else
{
cout << "v1不为空" << endl;
cout << "v1的容量 = " << v1.capacity() << endl;
cout << "v1的大小 = " << v1.size() << endl;
}
//resize 重新指定大小 ，若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
v1.resize(15,10);
printVector(v1);
//resize 重新指定大小 ，若指定的更小，超出部分元素被删除
v1.resize(5);
printVector(v1);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 判断是否为空 — empty
- 返回元素个数 — size
- 返回容器容量 — capacity
- 重新指定大小 — resize
3.2.5 vector插入和删除
功能描述：
- 对vector容器进行插入、删除操作
函数原型：
push_back(ele);//尾部插入元素elepop_back();//删除最后一个元素insert(const_iterator pos, ele);//迭代器指向位置pos插入元素eleinsert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素eleerase(const_iterator pos);//删除迭代器指向的元素erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素clear();//删除容器中所有元素
示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//插入和删除
void test01()
{
vector<int> v1;
//尾插
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
printVector(v1);
//尾删
v1.pop_back();
printVector(v1);
//插入
v1.insert(v1.begin(), 100);
printVector(v1);
v1.insert(v1.begin(), 2, 1000);
printVector(v1);
//删除
v1.erase(v1.begin());
printVector(v1);
//清空
v1.erase(v1.begin(), v1.end());
v1.clear();
printVector(v1);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 尾插 — push_back
- 尾删 — pop_back
- 插入 — insert (位置迭代器)
- 删除 — erase （位置迭代器）
- 清空 — clear
3.2.6 vector数据存取
功能描述：
- 对vector中的数据的存取操作
函数原型：
at(int idx);//返回索引idx所指的数据operator[];//返回索引idx所指的数据front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
示例：
#include <vector>
void test01()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";
}
cout << endl;
cout << "v1的第一个元素为： " << v1.front() << endl;
cout << "v1的最后一个元素为： " << v1.back() << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 除了用迭代器获取vector容器中元素，[ ]和at也可以
- front返回容器第一个元素
- back返回容器最后一个元素
3.2.7 vector互换容器
功能描述：
- 实现两个容器内元素进行互换
函数原型：
swap(vec);// 将vec与本身的元素互换
示例：
#include <vector>
void printVector(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector<int>v2;
for (int i = 10; i > 0; i--)
{
v2.push_back(i);
}
printVector(v2);
//互换容器
cout << "互换后" << endl;
v1.swap(v2);
printVector(v1);
printVector(v2);
}
void test02()
{
vector<int> v;
for (int i = 0; i < 100000; i++) {
v.push_back(i);
}
cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;
v.resize(3);
cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;
//收缩内存
vector<int>(v).swap(v); //匿名对象
cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：swap可以使两个容器互换，可以达到实用的收缩内存效果
3.2.8 vector预留空间
功能描述：
- 减少vector在动态扩展容量时的扩展次数
函数原型：
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
示例：
#include <vector>
void test01()
{
vector<int> v;
//预留空间
v.reserve(100000);
int num = 0;
int* p = NULL;
for (int i = 0; i < 100000; i++) {
v.push_back(i);
if (p != &v[0]) {
p = &v[0];
num++;
}
}
cout << "num:" << num << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：如果数据量较大，可以一开始利用reserve预留空间
3.3 deque容器
3.3.1 deque容器基本概念
功能：
- 双端数组，可以对头端进行插入删除操作
deque与vector区别：
- vector对于头部的插入删除效率低，数据量越大，效率越低
- deque相对而言，对头部的插入删除速度回比vector快
- vector访问元素时的速度会比deque快,这和两者内部实现有关
deque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间
- deque容器的迭代器也是支持随机访问的
3.3.2 deque构造函数
功能描述：
- deque容器构造
函数原型：
deque<T>deqT; //默认构造形式deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。deque(n, elem);//构造函数将n个elem拷贝给本身。deque(const deque &deq);//拷贝构造函数
示例：
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//deque构造
void test01() {
deque<int> d1; //无参构造函数
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
deque<int> d2(d1.begin(),d1.end());
printDeque(d2);
deque<int>d3(10,100);
printDeque(d3);
deque<int>d4 = d3;
printDeque(d4);
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**deque容器和vector容器的构造方式几乎一致，灵活使用即可
3.3.3 deque赋值操作
功能描述：
- 给deque容器进行赋值
函数原型：
-
deque& operator=(const deque &deq);//重载等号操作符 -
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 -
assign(n, elem);//将n个elem拷贝赋值给本身。
示例：
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//赋值操作
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
deque<int>d2;
d2 = d1;
printDeque(d2);
deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);
deque<int>d4;
d4.assign(10, 100);
printDeque(d4);
}
int main() {
test01();
system("pause");
return 0;
}
总结：deque赋值操作也与vector相同，需熟练掌握
3.3.4 deque大小操作
功能描述：
- 对deque容器的大小进行操作
函数原型：
-
deque.empty();//判断容器是否为空 -
deque.size();//返回容器中元素的个数 -
deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
-
deque.resize(num, elem);//重新指定容器的长度为num,若容器变长，则以elem值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
示例：
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//大小操作
void test01()
{
deque<int> d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//判断容器是否为空
if (d1.empty()) {
cout << "d1为空!" << endl;
}
else {
cout << "d1不为空!" << endl;
//统计大小
cout << "d1的大小为：" << d1.size() << endl;
}
//重新指定大小
d1.resize(15, 1);
printDeque(d1);
d1.resize(5);
printDeque(d1);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- deque没有容量的概念
- 判断是否为空 — empty
- 返回元素个数 — size
- 重新指定个数 — resize
3.3.5 deque 插入和删除
功能描述：
- 向deque容器中插入和删除数据
函数原型：
两端插入操作：
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位置的数据，返回下一个数据的位置。
示例：
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//两端操作
void test01()
{
deque<int> d;
//尾插
d.push_back(10);
d.push_back(20);
//头插
d.push_front(100);
d.push_front(200);
printDeque(d);
//尾删
d.pop_back();
//头删
d.pop_front();
printDeque(d);
}
//插入
void test02()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.insert(d.begin(), 1000);
printDeque(d);
d.insert(d.begin(), 2,10000);
printDeque(d);
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d.insert(d.begin(), d2.begin(), d2.end());
printDeque(d);
}
//删除
void test03()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
d.erase(d.begin());
printDeque(d);
d.erase(d.begin(), d.end());
d.clear();
printDeque(d);
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}
总结：
- 插入和删除提供的位置是迭代器！
- 尾插 — push_back
- 尾删 — pop_back
- 头插 — push_front
- 头删 — pop_front
3.3.6 deque 数据存取
功能描述：
- 对deque 中的数据的存取操作
函数原型：
at(int idx);//返回索引idx所指的数据operator[];//返回索引idx所指的数据front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
示例：
#include <deque>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//数据存取
void test01()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
for (int i = 0; i < d.size(); i++) {
cout << d[i] << " ";
}
cout << endl;
for (int i = 0; i < d.size(); i++) {
cout << d.at(i) << " ";
}
cout << endl;
cout << "front:" << d.front() << endl;
cout << "back:" << d.back() << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 除了用迭代器获取deque容器中元素，[ ]和at也可以
- front返回容器第一个元素
- back返回容器最后一个元素
3.3.7 deque 排序
功能描述：
- 利用算法实现对deque容器进行排序
算法：
sort(iterator beg, iterator end)//对beg和end区间内元素进行排序
示例：
#include <deque>
#include <algorithm>
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);
sort(d.begin(), d.end());
printDeque(d);
}
int main() {
test01();
system("pause");
return 0;
}
总结：sort算法非常实用，使用时包含头文件 algorithm即可
3.4 案例-评委打分
3.4.1 案例描述
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
3.4.2 实现步骤
- 创建五名选手，放到vector中
- 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
- sort算法对deque容器中分数排序，去除最高和最低分
- deque容器遍历一遍，累加总分
- 获取平均分
示例代码：
//选手类
class Person
{
public:
Person(string name, int score)
{
this->m_Name = name;
this->m_Score = score;
}
string m_Name; //姓名
int m_Score; //平均分
};
void createPerson(vector<Person>&v)
{
string nameSeed = "ABCDE";
for (int i = 0; i < 5; i++)
{
string name = "选手";
name += nameSeed[i];
int score = 0;
Person p(name, score);
//将创建的person对象 放入到容器中
v.push_back(p);
}
}
//打分
void setScore(vector<Person>&v)
{
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
//将评委的分数 放入到deque容器中
deque<int>d;
for (int i = 0; i < 10; i++)
{
int score = rand() % 41 + 60; // 60 ~ 100
d.push_back(score);
}
//cout << "选手： " << it->m_Name << " 打分： " << endl;
//for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
//{
// cout << *dit << " ";
//}
//cout << endl;
//排序
sort(d.begin(), d.end());
//去除最高和最低分
d.pop_back();
d.pop_front();
//取平均分
int sum = 0;
for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
{
sum += *dit; //累加每个评委的分数
}
int avg = sum / d.size();
//将平均分 赋值给选手身上
it->m_Score = avg;
}
}
void showScore(vector<Person>&v)
{
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名： " << it->m_Name << " 平均分： " << it->m_Score << endl;
}
}
int main() {
//随机数种子
srand((unsigned int)time(NULL));
//1、创建5名选手
vector<Person>v; //存放选手容器
createPerson(v);
//测试
//for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
//{
// cout << "姓名： " << (*it).m_Name << " 分数： " << (*it).m_Score << endl;
//}
//2、给5名选手打分
setScore(v);
//3、显示最后得分
showScore(v);
system("pause");
return 0;
}
总结： 选取不同的容器操作数据，可以提升代码的效率
3.5 stack容器
3.5.1 stack 基本概念
概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop
生活中的栈：
3.5.2 stack 常用接口
功能描述：栈容器常用的对外接口
构造函数：
stack<T> stk;//stack采用模板类实现， stack对象的默认构造形式stack(const stack &stk);//拷贝构造函数
赋值操作：
stack& operator=(const stack &stk);//重载等号操作符
数据存取：
push(elem);//向栈顶添加元素pop();//从栈顶移除第一个元素top();//返回栈顶元素
大小操作：
empty();//判断堆栈是否为空size();//返回栈的大小
示例：
#include <stack>
//栈容器常用接口
void test01()
{
//创建栈容器 栈容器必须符合先进后出
stack<int> s;
//向栈中添加元素，叫做 压栈 入栈
s.push(10);
s.push(20);
s.push(30);
while (!s.empty()) {
//输出栈顶元素
cout << "栈顶元素为： " << s.top() << endl;
//弹出栈顶元素
s.pop();
}
cout << "栈的大小为：" << s.size() << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 入栈 — push
- 出栈 — pop
- 返回栈顶 — top
- 判断栈是否为空 — empty
- 返回栈大小 — size
3.6 queue 容器
3.6.1 queue 基本概念
概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口
队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop
生活中的队列：
3.6.2 queue 常用接口
功能描述：栈容器常用的对外接口
构造函数：
queue<T> que;//queue采用模板类实现，queue对象的默认构造形式queue(const queue &que);//拷贝构造函数
赋值操作：
queue& operator=(const queue &que);//重载等号操作符
数据存取：
push(elem);//往队尾添加元素pop();//从队头移除第一个元素back();//返回最后一个元素front();//返回第一个元素
大小操作：
empty();//判断堆栈是否为空size();//返回栈的大小
示例：
#include <queue>
#include <string>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
void test01() {
//创建队列
queue<Person> q;
//准备数据
Person p1("唐僧", 30);
Person p2("孙悟空", 1000);
Person p3("猪八戒", 900);
Person p4("沙僧", 800);
//向队列中添加元素 入队操作
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);
//队列不提供迭代器，更不支持随机访问
while (!q.empty()) {
//输出队头元素
cout << "队头元素-- 姓名： " << q.front().m_Name
<< " 年龄： "<< q.front().m_Age << endl;
cout << "队尾元素-- 姓名： " << q.back().m_Name
<< " 年龄： " << q.back().m_Age << endl;
cout << endl;
//弹出队头元素
q.pop();
}
cout << "队列大小为：" << q.size() << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 入队 — push
- 出队 — pop
- 返回队头元素 — front
- 返回队尾元素 — back
- 判断队是否为空 — empty
- 返回队列大小 — size
3.7 list容器
3.7.1 list基本概念
**功能：**将数据进行链式存储
链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
STL中的链表是一个双向循环链表
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
list的优点：
- 采用动态存储分配，不会造成内存浪费和溢出
- 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list的缺点：
- 链表灵活，但是空间(指针域) 和 时间（遍历）额外耗费较大
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。
总结：STL中List和vector是两个最常被使用的容器，各有优缺点
3.7.2 list构造函数
功能描述：
- 创建list容器
函数原型：
list<T> lst;//list采用采用模板类实现,对象的默认构造形式：list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。list(n,elem);//构造函数将n个elem拷贝给本身。list(const list &lst);//拷贝构造函数。
示例：
#include <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(L1.begin(),L1.end());
printList(L2);
list<int>L3(L2);
printList(L3);
list<int>L4(10, 1000);
printList(L4);
}
int main() {
test01();
system("pause");
return 0;
}
总结：list构造方式同其他几个STL常用容器，熟练掌握即可
3.7.3 list 赋值和交换
功能描述：
- 给list容器进行赋值，以及交换list容器
函数原型：
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。assign(n, elem);//将n个elem拷贝赋值给本身。list& operator=(const list &lst);//重载等号操作符swap(lst);//将lst与本身的元素互换。
示例：
#include <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;
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);
cout << endl;
L1.swap(L2);
cout << "交换后： " << endl;
printList(L1);
printList(L2);
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：list赋值和交换操作能够灵活运用即可
3.7.4 list 大小操作
功能描述：
- 对list容器的大小进行操作
函数原型：
-
size();//返回容器中元素的个数 -
empty();//判断容器是否为空 -
resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
-
resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
示例：
#include <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);
if (L1.empty())
{
cout << "L1为空" << endl;
}
else
{
cout << "L1不为空" << endl;
cout << "L1的大小为： " << L1.size() << endl;
}
//重新指定大小
L1.resize(10);
printList(L1);
L1.resize(2);
printList(L1);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 判断是否为空 — empty
- 返回元素个数 — size
- 重新指定个数 — resize
3.7.5 list 插入和删除
功能描述：
- 对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值匹配的元素。
示例：
#include <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> 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);
//插入
list<int>::iterator it = L.begin();
L.insert(++it, 1000);
printList(L);
//删除
it = L.begin();
L.erase(++it);
printList(L);
//移除
L.push_back(10000);
L.push_back(10000);
L.push_back(10000);
printList(L);
L.remove(10000);
printList(L);
//清空
L.clear();
printList(L);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 尾插 — push_back
- 尾删 — pop_back
- 头插 — push_front
- 头删 — pop_front
- 插入 — insert
- 删除 — erase
- 移除 — remove
- 清空 — clear
3.7.6 list 数据存取
功能描述：
- 对list容器中数据进行存取
函数原型：
front();//返回第一个元素。back();//返回最后一个元素。
示例：
#include <list>
//数据存取
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//cout << L1.at(0) << endl;//错误 不支持at访问数据
//cout << L1[0] << endl; //错误 不支持[]方式访问数据
cout << "第一个元素为： " << L1.front() << endl;
cout << "最后一个元素为： " << L1.back() << endl;
//list容器的迭代器是双向迭代器，不支持随机访问
list<int>::iterator it = L1.begin();
//it = it + 1;//错误，不可以跳跃访问，即使是+1
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- list容器中不可以通过[]或者at方式访问数据
- 返回第一个元素 — front
- 返回最后一个元素 — back
3.7.7 list 反转和排序
功能描述：
- 将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
reverse();//反转链表sort();//链表排序
示例：
void printList(const list<int>& L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
bool myCompare(int val1 , int val2)
{
return val1 > val2;
}
//反转和排序
void test01()
{
list<int> L;
L.push_back(90);
L.push_back(30);
L.push_back(20);
L.push_back(70);
printList(L);
//反转容器的元素
L.reverse();
printList(L);
//排序
L.sort(); //默认的排序规则 从小到大
printList(L);
L.sort(myCompare); //指定规则，从大到小
printList(L);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 反转 — reverse
- 排序 — sort （成员函数）
3.7.8 排序案例
案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序
示例：
#include <list>
#include <string>
class Person {
public:
Person(string name, int age , int height) {
m_Name = name;
m_Age = age;
m_Height = height;
}
public:
string m_Name; //姓名
int m_Age; //年龄
int m_Height; //身高
};
bool ComparePerson(Person& p1, Person& p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height > p2.m_Height;
}
else
{
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 << " 年龄： " << it->m_Age
<< " 身高： " << it->m_Height << endl;
}
cout << "---------------------------------" << endl;
L.sort(ComparePerson); //排序
for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age
<< " 身高： " << it->m_Height << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
总结：
-
对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
-
高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂
3.8 set/ multiset 容器
3.8.1 set基本概念
简介：
- 所有元素都会在插入时自动被排序
本质：
- set/multiset属于关联式容器，底层结构是用二叉树实现。
set和multiset区别：
- set不允许容器中有重复的元素
- multiset允许容器中有重复的元素
3.8.2 set构造和赋值
功能描述：创建set容器以及赋值
构造：
set<T> st;//默认构造函数：set(const set &st);//拷贝构造函数
赋值：
set& operator=(const set &st);//重载等号操作符
示例：
#include <set>
void printSet(set<int> & s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//构造和赋值
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);
//拷贝构造
set<int>s2(s1);
printSet(s2);
//赋值
set<int>s3;
s3 = s2;
printSet(s3);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- set容器插入数据时用insert
- set容器插入数据的数据会自动排序
3.8.3 set大小和交换
功能描述：
- 统计set容器大小以及交换set容器
函数原型：
size();//返回容器中元素的数目empty();//判断容器是否为空swap(st);//交换两个集合容器
示例：
#include <set>
void printSet(set<int> & s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//大小
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
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(30);
s1.insert(20);
s1.insert(40);
set<int> s2;
s2.insert(100);
s2.insert(300);
s2.insert(200);
s2.insert(400);
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;
}
总结：
- 统计大小 — size
- 判断是否为空 — empty
- 交换容器 — swap
3.8.4 set插入和删除
功能描述：
- set容器进行插入数据和删除数据
函数原型：
insert(elem);//在容器中插入元素。clear();//清除所有元素erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。erase(elem);//删除容器中值为elem的元素。
示例：
#include <set>
void printSet(set<int> & s)
{
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//插入和删除
void test01()
{
set<int> s1;
//插入
s1.insert(10);
s1.insert(30);
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;
}
总结：
- 插入 — insert
- 删除 — erase
- 清空 — clear
3.8.5 set查找和统计
功能描述：
- 对set容器进行查找数据以及统计数据
函数原型：
find(key);//查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();count(key);//统计key的元素个数
示例：
#include <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;
}
//统计
int num = s1.count(30);
cout << "num = " << num << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 查找 — find （返回的是迭代器）
- 统计 — count （对于set，结果为0或者1）
3.8.6 set和multiset区别
学习目标：
- 掌握set和multiset的区别
区别：
- set不可以插入重复数据，而multiset可以
- set插入数据的同时会返回插入结果，表示插入是否成功
- multiset不会检测数据，因此可以插入重复数据
示例：
#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
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;
}
总结：
- 如果不允许插入重复数据可以利用set
- 如果需要插入重复数据利用multiset
3.8.7 pair对组创建
功能描述：
- 成对出现的数据，利用对组可以返回两个数据
两种创建方式：
pair<type, type> p ( value1, value2 );pair<type, type> p = make_pair( value1, value2 );
示例：
#include <string>
//对组创建
void test01()
{
pair<string, int> p(string("Tom"), 20);
cout << "姓名： " << p.first << " 年龄： " << p.second << endl;
pair<string, int> p2 = make_pair("Jerry", 10);
cout << "姓名： " << p2.first << " 年龄： " << p2.second << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
两种方式都可以创建对组，记住一种即可
3.8.8 set容器排序
学习目标：
- set容器默认排序规则为从小到大，掌握如何改变排序规则
主要技术点：
- 利用仿函数，可以改变排序规则
示例一 set存放内置数据类型
#include <set>
class MyCompare
{
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
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(20);
s2.insert(30);
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;
}
总结：利用仿函数可以指定set容器的排序规则
示例二 set存放自定义数据类型
#include <set>
#include <string>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
class comparePerson
{
public:
bool operator()(const Person& p1, const Person &p2)
{
//按照年龄进行排序 降序
return p1.m_Age > p2.m_Age;
}
};
void test01()
{
set<Person, comparePerson> s;
Person p1("刘备", 23);
Person p2("关羽", 27);
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;
}
总结：
对于自定义数据类型，set必须指定排序规则才可以插入数据
3.9 map/ multimap容器
3.9.1 map基本概念
简介：
- map中所有元素都是pair
- pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
- 所有元素都会根据元素的键值自动排序
本质：
- map/multimap属于关联式容器，底层结构是用二叉树实现。
优点：
- 可以根据key值快速找到value值
map和multimap区别：
- map不允许容器中有重复key值元素
- multimap允许容器中有重复key值元素
3.9.2 map构造和赋值
功能描述：
- 对map容器进行构造和赋值操作
函数原型：
构造：
map<T1, T2> mp;//map默认构造函数:map(const map &mp);//拷贝构造函数
赋值：
map& operator=(const map &mp);//重载等号操作符
示例：
#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;
}
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));
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中所有元素都是成对出现，插入数据时候要使用对组
3.9.3 map大小和交换
功能描述：
- 统计map容器大小以及交换map容器
函数原型：
size();//返回容器中元素的数目empty();//判断容器是否为空swap(st);//交换两个集合容器
示例：
#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;
}
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);
cout << "交换后" << endl;
m.swap(m2);
printMap(m);
printMap(m2);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：
- 统计大小 — size
- 判断是否为空 — empty
- 交换容器 — swap
3.9.4 map插入和删除
功能描述：
- map容器进行插入数据和删除数据
函数原型：
insert(elem);//在容器中插入元素。clear();//清除所有元素erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。erase(key);//删除容器中值为key的元素。
示例：
#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;
}
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;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
//清空
m.erase(m.begin(),m.end());
m.clear();
printMap(m);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- map插入方式很多，记住其一即可
- 插入 — insert
- 删除 — erase
- 清空 — clear
3.9.5 map查找和统计
功能描述：
- 对map容器进行查找数据以及统计数据
函数原型：
find(key);//查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();count(key);//统计key的元素个数
示例：
#include <map>
//查找和统计
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));
//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = m.count(3);
cout << "num = " << num << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 查找 — find （返回的是迭代器）
- 统计 — count （对于map，结果为0或者1）
3.9.6 map容器排序
学习目标：
- map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则
主要技术点:
- 利用仿函数，可以改变排序规则
示例：
#include <map>
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
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, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {
cout << "key:" << it->first << " value:" << it->second << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 利用仿函数可以指定map容器的排序规则
- 对于自定义数据类型，map必须要指定排序规则,同set容器
3.10 案例-员工分组
3.10.1 案例描述
- 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
- 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入 key(部门编号) value(员工)
- 分部门显示员工信息
3.10.2 实现步骤
- 创建10名员工，放到vector中
- 遍历vector容器，取出每个员工，进行随机分组
- 分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中
- 分部门显示员工信息
案例代码：
#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <map>
#include <ctime>
/*
- 公司今天招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在那个部门工作
- 员工信息有: 姓名 工资组成；部门分为：策划、美术、研发
- 随机给10名员工分配部门和工资
- 通过multimap进行信息的插入 key(部门编号) value(员工)
- 分部门显示员工信息
*/
#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
//将员工插入到分组中
//key部门编号，value具体员工
m.insert(make_pair(deptId, *it));
}
}
void showWorkerByGourp(multimap<int,Worker>&m)
{
// 0 A B C 1 D E 2 F G ...
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、分组显示员工
showWorkerByGourp(mWorker);
测试
//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++)
//{
// cout << "姓名： " << it->m_Name << " 工资： " << it->m_Salary << endl;
//}
system("pause");
return 0;
}
总结：
- 当数据以键值对形式存在，可以考虑用map 或 multimap
4 STL- 函数对象
4.1 函数对象
4.1.1 函数对象概念
概念：
- 重载函数调用操作符的类，其对象常称为函数对象
- 函数对象使用重载的()时，行为类似函数调用，也叫仿函数
本质：
函数对象(仿函数)是一个类，不是一个函数
4.1.2 函数对象使用
特点：
- 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
- 函数对象超出普通函数的概念，函数对象可以有自己的状态
- 函数对象可以作为参数传递
示例:
#include <string>
//1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class MyAdd
{
public :
int operator()(int v1,int v2)
{
return v1 + v2;
}
};
void test01()
{
MyAdd myAdd;
cout << myAdd(10, 10) << endl;
}
//2、函数对象可以有自己的状态
class MyPrint
{
public:
MyPrint()
{
count = 0;
}
void operator()(string test)
{
cout << test << endl;
count++; //统计使用次数
}
int count; //内部自己的状态
};
void test02()
{
MyPrint myPrint;
myPrint("hello world");
myPrint("hello world");
myPrint("hello world");
cout << "myPrint调用次数为： " << myPrint.count << endl;
}
//3、函数对象可以作为参数传递
void doPrint(MyPrint &mp , string test)
{
mp(test);
}
void test03()
{
MyPrint myPrint;
doPrint(myPrint, "Hello C++");
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}
总结：
- 仿函数写法非常灵活，可以作为参数进行传递。
4.2 谓词
4.2.1 谓词概念
概念：
- 返回bool类型的仿函数称为谓词
- 如果operator()接受一个参数，那么叫做一元谓词
- 如果operator()接受两个参数，那么叫做二元谓词
4.2.2 一元谓词
示例：
#include <vector>
#include <algorithm>
//1.一元谓词
struct GreaterFive{
bool operator()(int val) {
return val > 5;
}
};
void test01() {
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end()) {
cout << "没找到!" << endl;
}
else {
cout << "找到:" << *it << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
总结：参数只有一个的谓词，称为一元谓词
4.2.3 二元谓词
示例：
#include <vector>
#include <algorithm>
//二元谓词
class MyCompare
{
public:
bool operator()(int num1, int num2)
{
return num1 > num2;
}
};
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(40);
v.push_back(20);
v.push_back(30);
v.push_back(50);
//默认从小到大
sort(v.begin(), v.end());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
cout << "----------------------------" << endl;
//使用函数对象改变算法策略，排序从大到小
sort(v.begin(), v.end(), MyCompare());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：参数只有两个的谓词，称为二元谓词
4.3 内建函数对象
4.3.1 内建函数对象意义
概念：
- STL内建了一些函数对象
分类:
-
算术仿函数
-
关系仿函数
-
逻辑仿函数
用法：
- 这些仿函数所产生的对象，用法和一般函数完全相同
- 使用内建函数对象，需要引入头文件
#include<functional>
4.3.2 算术仿函数
功能描述：
- 实现四则运算
- 其中negate是一元运算，其他都是二元运算
仿函数原型：
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>//取反仿函数
示例：
#include <functional>
//negate
void test01()
{
negate<int> n;
cout << n(50) << endl;
}
//plus
void test02()
{
plus<int> p;
cout << p(10, 20) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：使用内建函数对象时，需要引入头文件 #include <functional>
4.3.3 关系仿函数
功能描述：
- 实现关系对比
仿函数原型：
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>//小于等于
示例：
#include <functional>
#include <vector>
#include <algorithm>
class MyCompare
{
public:
bool operator()(int v1,int v2)
{
return v1 > v2;
}
};
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(30);
v.push_back(50);
v.push_back(40);
v.push_back(20);
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
//自己实现仿函数
//sort(v.begin(), v.end(), MyCompare());
//STL内建仿函数 大于仿函数
sort(v.begin(), v.end(), greater<int>());
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：关系仿函数中最常用的就是greater<>大于
4.3.4 逻辑仿函数
功能描述：
- 实现逻辑运算
函数原型：
template<class T> bool logical_and<T>//逻辑与template<class T> bool logical_or<T>//逻辑或template<class T> bool logical_not<T>//逻辑非
示例：
#include <vector>
#include <functional>
#include <algorithm>
void test01()
{
vector<bool> v;
v.push_back(true);
v.push_back(false);
v.push_back(true);
v.push_back(false);
for (vector<bool>::iterator it = v.begin();it!= v.end();it++)
{
cout << *it << " ";
}
cout << endl;
//逻辑非 将v容器搬运到v2中，并执行逻辑非运算
vector<bool> v2;
v2.resize(v.size());
transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：逻辑仿函数实际应用较少，了解即可
5 STL- 常用算法
概述:
-
算法主要是由头文件
<algorithm><functional><numeric>组成。 -
<algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等 -
<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数 -
<functional>定义了一些模板类,用以声明函数对象。
5.1 常用遍历算法
学习目标：
- 掌握常用的遍历算法
算法简介：
for_each//遍历容器transform//搬运容器到另一个容器中
5.1.1 for_each
功能描述：
- 实现遍历容器
函数原型：
-
for_each(iterator beg, iterator end, _func);// 遍历算法 遍历容器元素
// beg 开始迭代器
// end 结束迭代器
// _func 函数或者函数对象
示例：
#include <algorithm>
#include <vector>
//普通函数
void print01(int val)
{
cout << val << " ";
}
//函数对象
class print02
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
//for_each算法基本用法
void test01() {
vector<int> v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//遍历算法
for_each(v.begin(), v.end(), print01);
cout << endl;
for_each(v.begin(), v.end(), print02());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**for_each在实际开发中是最常用遍历算法，需要熟练掌握
5.1.2 transform
功能描述：
- 搬运容器到另一个容器中
函数原型：
transform(iterator beg1, iterator end1, iterator beg2, _func);
//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象
示例：
#include<vector>
#include<algorithm>
//常用遍历算法 搬运 transform
class TransForm
{
public:
int operator()(int val)
{
return val;
}
};
class MyPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
vector<int>vTarget; //目标容器
vTarget.resize(v.size()); // 目标容器需要提前开辟空间
transform(v.begin(), v.end(), vTarget.begin(), TransForm());
for_each(vTarget.begin(), vTarget.end(), MyPrint());
}
int main() {
test01();
system("pause");
return 0;
}
总结： 搬运的目标容器必须要提前开辟空间，否则无法正常搬运
5.2 常用查找算法
学习目标：
- 掌握常用的查找算法
算法简介：
find//查找元素find_if//按条件查找元素adjacent_find//查找相邻重复元素binary_search//二分查找法count//统计元素个数count_if//按条件统计元素个数
5.2.1 find
功能描述：
- 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
函数原型：
-
find(iterator beg, iterator end, value);// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
示例：
#include <algorithm>
#include <vector>
#include <string>
void test01() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i + 1);
}
//查找容器中是否有 5 这个元素
vector<int>::iterator it = find(v.begin(), v.end(), 5);
if (it == v.end())
{
cout << "没有找到!" << endl;
}
else
{
cout << "找到:" << *it << endl;
}
}
class Person {
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
//重载==
bool operator==(const Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
return false;
}
public:
string m_Name;
int m_Age;
};
void test02() {
vector<Person> v;
//创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
vector<Person>::iterator it = find(v.begin(), v.end(), p2);
if (it == v.end())
{
cout << "没有找到!" << endl;
}
else
{
cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
}
}
总结： 利用find可以在容器中找指定的元素，返回值是迭代器
5.2.2 find_if
功能描述：
- 按条件查找元素
函数原型：
-
find_if(iterator beg, iterator end, _Pred);// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 函数或者谓词（返回bool类型的仿函数）
示例：
#include <algorithm>
#include <vector>
#include <string>
//内置数据类型
class GreaterFive
{
public:
bool operator()(int val)
{
return val > 5;
}
};
void test01() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i + 1);
}
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end()) {
cout << "没有找到!" << endl;
}
else {
cout << "找到大于5的数字:" << *it << endl;
}
}
//自定义数据类型
class Person {
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
public:
string m_Name;
int m_Age;
};
class Greater20
{
public:
bool operator()(Person &p)
{
return p.m_Age > 20;
}
};
void test02() {
vector<Person> v;
//创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
if (it == v.end())
{
cout << "没有找到!" << endl;
}
else
{
cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
}
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略
5.2.3 adjacent_find
功能描述：
- 查找相邻重复元素
函数原型：
-
adjacent_find(iterator beg, iterator end);// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
// beg 开始迭代器
// end 结束迭代器
示例：
#include <algorithm>
#include <vector>
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(5);
v.push_back(2);
v.push_back(4);
v.push_back(4);
v.push_back(3);
//查找相邻重复元素
vector<int>::iterator it = adjacent_find(v.begin(), v.end());
if (it == v.end()) {
cout << "找不到!" << endl;
}
else {
cout << "找到相邻重复元素为:" << *it << endl;
}
}
总结：面试题中如果出现查找相邻重复元素，记得用STL中的adjacent_find算法
5.2.4 binary_search
功能描述：
- 查找指定元素是否存在
函数原型：
-
bool binary_search(iterator beg, iterator end, value);// 查找指定的元素，查到 返回true 否则false
// 注意: 在无序序列中不可用
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
示例：
#include <algorithm>
#include <vector>
void test01()
{
vector<int>v;
for (int i = 0; i < 10; i++)
{
v.push_back(i);
}
//二分查找
bool ret = binary_search(v.begin(), v.end(),2);
if (ret)
{
cout << "找到了" << endl;
}
else
{
cout << "未找到" << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列
5.2.5 count
功能描述：
- 统计元素个数
函数原型：
-
count(iterator beg, iterator end, value);// 统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// value 统计的元素
示例：
#include <algorithm>
#include <vector>
//内置数据类型
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(4);
v.push_back(5);
v.push_back(3);
v.push_back(4);
v.push_back(4);
int num = count(v.begin(), v.end(), 4);
cout << "4的个数为： " << num << endl;
}
//自定义数据类型
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
bool operator==(const Person & p)
{
if (this->m_Age == p.m_Age)
{
return true;
}
else
{
return false;
}
}
string m_Name;
int m_Age;
};
void test02()
{
vector<Person> v;
Person p1("刘备", 35);
Person p2("关羽", 35);
Person p3("张飞", 35);
Person p4("赵云", 30);
Person p5("曹操", 25);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
Person p("诸葛亮",35);
int num = count(v.begin(), v.end(), p);
cout << "num = " << num << endl;
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
总结： 统计自定义数据类型时候，需要配合重载 operator==
5.2.6 count_if
功能描述：
- 按条件统计元素个数
函数原型：
-
count_if(iterator beg, iterator end, _Pred);// 按条件统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
示例：
#include <algorithm>
#include <vector>
class Greater4
{
public:
bool operator()(int val)
{
return val >= 4;
}
};
//内置数据类型
void test01()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(4);
v.push_back(5);
v.push_back(3);
v.push_back(4);
v.push_back(4);
int num = count_if(v.begin(), v.end(), Greater4());
cout << "大于4的个数为： " << num << endl;
}
//自定义数据类型
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
class AgeLess35
{
public:
bool operator()(const Person &p)
{
return p.m_Age < 35;
}
};
void test02()
{
vector<Person> v;
Person p1("刘备", 35);
Person p2("关羽", 35);
Person p3("张飞", 35);
Person p4("赵云", 30);
Person p5("曹操", 25);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
int num = count_if(v.begin(), v.end(), AgeLess35());
cout << "小于35岁的个数：" << num << endl;
}
int main() {
//test01();
test02();
system("pause");
return 0;
}
**总结：**按值统计用count，按条件统计用count_if
5.3 常用排序算法
学习目标：
- 掌握常用的排序算法
算法简介：
sort//对容器内元素进行排序random_shuffle//洗牌 指定范围内的元素随机调整次序merge// 容器元素合并，并存储到另一容器中reverse// 反转指定范围的元素
5.3.1 sort
功能描述：
- 对容器内元素进行排序
函数原型：
-
sort(iterator beg, iterator end, _Pred);// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
示例：
#include <algorithm>
#include <vector>
void myPrint(int val)
{
cout << val << " ";
}
void test01() {
vector<int> v;
v.push_back(10);
v.push_back(30);
v.push_back(50);
v.push_back(20);
v.push_back(40);
//sort默认从小到大排序
sort(v.begin(), v.end());
for_each(v.begin(), v.end(), myPrint);
cout << endl;
//从大到小排序
sort(v.begin(), v.end(), greater<int>());
for_each(v.begin(), v.end(), myPrint);
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**sort属于开发中最常用的算法之一，需熟练掌握
5.3.2 random_shuffle
功能描述：
- 洗牌 指定范围内的元素随机调整次序
函数原型：
-
random_shuffle(iterator beg, iterator end);// 指定范围内的元素随机调整次序
// beg 开始迭代器
// end 结束迭代器
示例：
#include <algorithm>
#include <vector>
#include <ctime>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
srand((unsigned int)time(NULL));
vector<int> v;
for(int i = 0 ; i < 10;i++)
{
v.push_back(i);
}
for_each(v.begin(), v.end(), myPrint());
cout << endl;
//打乱顺序
random_shuffle(v.begin(), v.end());
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**random_shuffle洗牌算法比较实用，使用时记得加随机数种子
5.3.3 merge
功能描述：
- 两个容器元素合并，并存储到另一容器中
函数原型：
-
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);// 容器元素合并，并存储到另一容器中
// 注意: 两个容器必须是有序的
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10 ; i++)
{
v1.push_back(i);
v2.push_back(i + 1);
}
vector<int> vtarget;
//目标容器需要提前开辟空间
vtarget.resize(v1.size() + v2.size());
//合并 需要两个有序序列
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
for_each(vtarget.begin(), vtarget.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**merge合并的两个容器必须的有序序列
5.3.4 reverse
功能描述：
- 将容器内元素进行反转
函数原型：
-
reverse(iterator beg, iterator end);// 反转指定范围的元素
// beg 开始迭代器
// end 结束迭代器
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(30);
v.push_back(50);
v.push_back(20);
v.push_back(40);
cout << "反转前： " << endl;
for_each(v.begin(), v.end(), myPrint());
cout << endl;
cout << "反转后： " << endl;
reverse(v.begin(), v.end());
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**reverse反转区间内元素，面试题可能涉及到
5.4 常用拷贝和替换算法
学习目标：
- 掌握常用的拷贝和替换算法
算法简介：
copy// 容器内指定范围的元素拷贝到另一容器中replace// 将容器内指定范围的旧元素修改为新元素replace_if// 容器内指定范围满足条件的元素替换为新元素swap// 互换两个容器的元素
5.4.1 copy
功能描述：
- 容器内指定范围的元素拷贝到另一容器中
函数原型：
-
copy(iterator beg, iterator end, iterator dest);// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// dest 目标起始迭代器
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i + 1);
}
vector<int> v2;
v2.resize(v1.size());
copy(v1.begin(), v1.end(), v2.begin());
for_each(v2.begin(), v2.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**利用copy算法在拷贝时，目标容器记得提前开辟空间
5.4.2 replace
功能描述：
- 将容器内指定范围的旧元素修改为新元素
函数原型：
-
replace(iterator beg, iterator end, oldvalue, newvalue);// 将区间内旧元素 替换成 新元素
// beg 开始迭代器
// end 结束迭代器
// oldvalue 旧元素
// newvalue 新元素
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v;
v.push_back(20);
v.push_back(30);
v.push_back(20);
v.push_back(40);
v.push_back(50);
v.push_back(10);
v.push_back(20);
cout << "替换前：" << endl;
for_each(v.begin(), v.end(), myPrint());
cout << endl;
//将容器中的20 替换成 2000
cout << "替换后：" << endl;
replace(v.begin(), v.end(), 20,2000);
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**replace会替换区间内满足条件的元素
5.4.3 replace_if
功能描述:
- 将区间内满足条件的元素，替换成指定元素
函数原型：
-
replace_if(iterator beg, iterator end, _pred, newvalue);// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器
// end 结束迭代器
// _pred 谓词
// newvalue 替换的新元素
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
class ReplaceGreater30
{
public:
bool operator()(int val)
{
return val >= 30;
}
};
void test01()
{
vector<int> v;
v.push_back(20);
v.push_back(30);
v.push_back(20);
v.push_back(40);
v.push_back(50);
v.push_back(10);
v.push_back(20);
cout << "替换前：" << endl;
for_each(v.begin(), v.end(), myPrint());
cout << endl;
//将容器中大于等于的30 替换成 3000
cout << "替换后：" << endl;
replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**replace_if按条件查找，可以利用仿函数灵活筛选满足的条件
5.4.4 swap
功能描述：
- 互换两个容器的元素
函数原型：
-
swap(container c1, container c2);// 互换两个容器的元素
// c1容器1
// c2容器2
示例：
#include <algorithm>
#include <vector>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i+100);
}
cout << "交换前： " << endl;
for_each(v1.begin(), v1.end(), myPrint());
cout << endl;
for_each(v2.begin(), v2.end(), myPrint());
cout << endl;
cout << "交换后： " << endl;
swap(v1, v2);
for_each(v1.begin(), v1.end(), myPrint());
cout << endl;
for_each(v2.begin(), v2.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**swap交换容器时，注意交换的容器要同种类型
5.5 常用算术生成算法
学习目标：
- 掌握常用的算术生成算法
注意：
- 算术生成算法属于小型算法，使用时包含的头文件为
#include <numeric>
算法简介：
-
accumulate// 计算容器元素累计总和 -
fill// 向容器中添加元素
5.5.1 accumulate
功能描述：
- 计算区间内 容器元素累计总和
函数原型：
-
accumulate(iterator beg, iterator end, value);// 计算容器元素累计总和
// beg 开始迭代器
// end 结束迭代器
// value 起始值
示例：
#include <numeric>
#include <vector>
void test01()
{
vector<int> v;
for (int i = 0; i <= 100; i++) {
v.push_back(i);
}
int total = accumulate(v.begin(), v.end(), 0);
cout << "total = " << total << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**accumulate使用时头文件注意是 numeric，这个算法很实用
5.5.2 fill
功能描述：
- 向容器中填充指定的元素
函数原型：
-
fill(iterator beg, iterator end, value);// 向容器中填充元素
// beg 开始迭代器
// end 结束迭代器
// value 填充的值
示例：
#include <numeric>
#include <vector>
#include <algorithm>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v;
v.resize(10);
//填充
fill(v.begin(), v.end(), 100);
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
**总结：**利用fill可以将容器区间内元素填充为 指定的值
5.6 常用集合算法
学习目标：
- 掌握常用的集合算法
算法简介：
-
set_intersection// 求两个容器的交集 -
set_union// 求两个容器的并集 -
set_difference// 求两个容器的差集
5.6.1 set_intersection
功能描述：
- 求两个容器的交集
函数原型：
-
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);// 求两个集合的交集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
示例：
#include <vector>
#include <algorithm>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
v2.push_back(i+5);
}
vector<int> vTarget;
//取两个里面较小的值给目标容器开辟空间
vTarget.resize(min(v1.size(), v2.size()));
//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd =
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 求交集的两个集合必须的有序序列
- 目标容器开辟空间需要从两个容器中取小值
- set_intersection返回值既是交集中最后一个元素的位置
5.6.2 set_union
功能描述：
- 求两个集合的并集
函数原型：
-
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);// 求两个集合的并集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
示例：
#include <vector>
#include <algorithm>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i+5);
}
vector<int> vTarget;
//取两个容器的和给目标容器开辟空间
vTarget.resize(v1.size() + v2.size());
//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd =
set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 求并集的两个集合必须的有序序列
- 目标容器开辟空间需要两个容器相加
- set_union返回值既是并集中最后一个元素的位置
5.6.3 set_difference
功能描述：
- 求两个集合的差集
函数原型：
-
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);// 求两个集合的差集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
示例：
#include <vector>
#include <algorithm>
class myPrint
{
public:
void operator()(int val)
{
cout << val << " ";
}
};
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i+5);
}
vector<int> vTarget;
//取两个里面较大的值给目标容器开辟空间
vTarget.resize( max(v1.size() , v2.size()));
//返回目标容器的最后一个元素的迭代器地址
cout << "v1与v2的差集为： " << endl;
vector<int>::iterator itEnd =
set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
cout << "v2与v1的差集为： " << endl;
itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 求差集的两个集合必须的有序序列
- 目标容器开辟空间需要从两个容器取较大值
- set_difference返回值既是差集中最后一个元素的位置
十九、内存管理/函数设计
bool类型用if(!flag)和if(flag)不要与fasle和true和0比较
int型用if(a == 0)
float型用if(x >= -CMPNUM && X =< CMPNUM)，其中CMPNUM = 0.000001
char *p型用if(p == NULL)
头文件的作用：
头文件一般是声明函数或者结构体、类，以及宏定义。
通过头文件来调用库功能：在很多场合，源代码不便（或准）向户公布。只要通过向用户提供头文件和二进制的库即可。
创建结构体、函数的实现 后需空一行。
逻辑紧密的不空行，if else 属于一个语句，块之间不空行
尽量在定义变量的时候初始化
以后尽量这么写int *p，少写int* p
命名时：
类和函数：用大驼峰命名 void GetName()
变量：小驼峰命名fristNmae
//循环里面有条件判断，会打断for循环的流水线作业，使得编译器不能对for循环进行优化处理
for(int i = 0; i < N; ++i)
{
if(condition)
{
DoSomething();
}
else()
{
DoOtherthing();
}
}
全局变量：int g_name
静态变量：int s_name
类成员变量：int m_name
goto语句
优点：灵活跳转，可用于goto error
goto state;
String s1;
int num = 0;
...
state:
...
缺点：破坏程序结构，会跳过对象的构造、变量的初始化等，导致引发错误。
预处理命令
#idndef//防止头文件被重复包含，相关内容被重复定义，重复包含虽不会出错，但是会增加代码量，影响运行效率
//如果头文件内容已经被定义了，会直接跳到ednif结束
//如果没有被定义，进入#define，开始预编译处理，进行展开。
常量
const
1.修饰变量时，不允许变量被赋值，
2.在函数参数列表中，对形参加以修饰，可以防止传入的参数被赋值修改
3.const修饰函数，防止函数对传入的变量进行修改
等等
1.直接写数字和字符串，可读性差，无法理解；容易书写错误；统一修改困难
2.const与#define
const有数据类型，编译会进行安全检查；#define是字符替换，没有类型检查，会导致错误
类中的const数据成员只在某个对象的声明周期是常量，它的初始化只能在类构造函数的初始化列表进行
class A
{
enum {SIZE1 = 100, SIZE2= 200};//枚举常量,不会占用对象的存储空间，编译时被全部求值。
int array1[SIZE1];
}
1.函数设计
函数设计的一些规范
1.参数值传递的话使用const&引用，省去临时对象的拷贝构造和析构，提高效率。
2.参数是指针，仅仅作为输入用，应该在类型前加const,防止这指针被修改。
3.有时函数原本不需要返回值，但还是附加了返回值，例如strcpy
char*strcpy(char *strDest, char *strSrc)
{
if(strDest == NULL || strSrc == NULL)
{
return NULL;
}
char *ret = strDest;//将目标数组首地址储存，在之后的++中方便找到
while(*strSrc != '\0')
{
*strDest++ = *strSrc++;
}
*strDest = *strSrc;
return ret; //将数组dest首地址返回，可以方便外面灵活操作，例如链式表达求strlen
}
char* strcat(char *strDest, char *strSrc)
{
assert(strDest != NULL || strSrc != NULL);
char *ret = strDest;
while(*strDest != '\0')
{
*strDest++;
}
while(*strSrc != '\0')
{
*strDest++ = *strSrc++;
}
*strDest = *strSrc;
return ret;
}
int strcmp(char *dt, char *st)
{
assert(dt != NULL || st != NULL);//使用断言，断言是仅在Debug版本起作用的宏，用于检查不应该发生的事情，只能函数调用出现问题。
if(dt == st)
{
return -1;
}
int tmp = 0;
while(*st != '\0')
{
tmp = *dt++ - *st++;
if(tmp != 0)
{
return tmp;
}
}
if(*dt == *st)
{
return 0;
}
}
4.如果函数返回的是一个对象：
1）引用传递比值传递（移动拷贝构造加析构）更加高效，此场景用于返回值有赋值操作。
2）有些场合只能用值传递，而不能用引用传递，因为返回的可能是临时对象。（局部对象会被销毁，此时引用无效了）
string的构造函数、拷贝构造、=赋值重载、析构函数
class String
{
public:
String(const char *str = NULL);
String(const String &str);
String& operate=(const String &other);
~String();
private:
char *m_data;
}
String::String(const char *str)
{
if(str == NULL)
{
m_data = new char[1];
if(m_data == NULL)
{
cout << "Fail to new" << endl;
exit(1);
}
m_data[0] = '\0';
}
else
{
int len = strlen(str);
m_data = new char[len + 1];
if(m_data == NULL)
{
cout << "Fail to new" << endl;
exit(1);
}
strcpy(m_data, str);
}
}
String::String(const String &str)
{
int len = strlen(str.m_data);
m_data = new char[len + 1];
if(m_data == NULL)
{
cout << "Fail to new" << endl;
exit(1);
}
strcpy(m_data, str);
}
String& String::operate=(const String &other)
{
if(this == &other)//检查自赋值
{
return *this;
}
delete [] m_data;//释放原来的内存资源
int len = strlen(other.m_data);
m_data = new char[len + 1];//每次在堆区申请空间，1.一定要判断是否申请成功 2.记得delete,防止内存泄漏
if(m_data == NULL)
{
cout << "Fail to new" << endl;
exit(1);
}
strcpy(m_data, other.m_data);
return *this;
}
String::~String()
{
delete [] m_data;
}
5.关于函数返回return
1）一定要清楚函数返回的是指针、引用还是值。
2）return不要返回指向“栈内存”的指针或者引用，因为该内存在函数结束时被自动销毁。
3）如果return返回的是对象，要考虑效率问题。
...
//这时临时对象的语法，表示“创建一个临时对象并返回它”，其过程直接把临时对象创建并初始化在外部存储单元，省去了拷贝和析构的开销
return String(s1+s2);
//先创建temp对象，完成初始化，然后拷贝构造把temp拷贝到保存返回值的外部存储单元中，最后，temp在函数结束时被销毁（调用析构函数）
Sring temp(s1 + s2);
return temp;
6.关于指针和引用的区别
1）引用是给变量取名字，引用被创建必须被初始化（指针可以在任何时候被初始化）
2）不能有NULL引用，引用必须与合法是存储单元关联（指针则可以是NULL）
3）一旦引用被初始化，就不能改变引用的关系（指针可以随时改变所指的对象）
2.内存管理
7.内存分配
1）从静态存储区：**存储全局变量和静态变量（和常量）的区域，由编译器分配和释放。**内存在程序编译时就已经分配好了，生命周期：整个运行期间。
2）从栈区：存储函数内部的局部变量，函数执行结束时，存储单元被自动释放。
3）从堆区：**也叫动态内存分配。**程序运行时可以用malloc/alloc、new申请任意多少的空间，程序员自己释放内存，其生存周期由我们决定。
8.使用内存注意：
1）申请内存时没有申请成功，需养成在使用指针前检查指针是否为NULL
2）内存分配成功，但是未初始化，所以定义指针申请堆区空间和定义数组的时候一定要养成初始化的习惯
3）内存分配成功且初始化，但是操作越界。
4）忘记释放内存，造成内存泄漏，后果就是内存耗尽。malloc与free、new与delete成对出现，养成习惯。(不然调用一次函数，内存泄露一次)
5）释放了内存，却继续使用。不要返回指向“栈空间”的指针或引用，free或delete释放了内存后，没有将指针置为NULL。
数组名对应着一块内存，不是指向一块内存，地址与容量无法更改，只有内容可以更改。
数组的二次赋值不能直接数组名赋值（a = b），可以用strcpy。
数组作为函数参数进行传递时，自动退化为同类型的指针。
值传递，无法影响主函数的本体的。
地址（指针）传递和引用传递可以影响本体。
9.动态内存的释放
void Func(void)
{
char *p = (char *)malloc(100);//函数结束，指针p被释放，但是堆区申请的空间还在
free(p);//在函数未结束前，堆区内存虽被释放了，但是指针并没有消亡，也没置NULL
}
10.野指针
1）指针变量未被初始化。
2）指针被free或delete后，没有置NULL
3）指针操作超越了变量的作用范围，返回了指向“栈空间”的指针
11.malloc和free 、new和delete
malloc和free是C中的标准库函数，new和delete是C++的运算符。（此运算符在C++中是被重载的）。他们都可以动态申请内存。
在C++中，动态对象的创建的同时也自动执行构造函数，对象在消亡之前会自动执行析构函数。
由于malloc\free是库函数不是运算符，不在编译器控制权限内，执行构造函数和析构函数的任务无法交给malloc和free。
malloc：
void *malloc(size_t size);
返回值为void*,所以要显示的进行类型转换。
不识别申请的内存是是什么类型，只关心内存的总字节数。
new:
int *p = new int[length];
new内置了sizeof、类型转换和类型安全检查
Class Obj
{
public:
Obj();
Obj(int x);
private:
int x;
};
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1);
...
delete a;
delete b;
}
如果用new创建对象数组，只能使用对象的无参构造函数
Obj *objects = new Obj[100];//创建100个动态对象
二十、网络编程
内核接受网络数据的全过程
进程在recv阻塞期间，计算机收到了对端传送的数据（步骤①）。数据经由网卡传送到内存（步骤②），然后网卡通过中断信号通知cpu有数据到达，cpu执行中断程序（步骤③）。此处的中断程序主要有两项功能，先将网络数据写入到对应socket的接收缓冲区里面（步骤④），再唤醒进程A（步骤⑤），重新将进程A放入工作队列中。
局域网 ：
小范围内的私有网络，一个家庭内的网络、一个公司内的网络、一个校园内的网络都属于局域网。
广域网：
把不同地域的局域网互相连接起来的网络。运营商搭建广域网实现跨区域的网络互连。
互联网：
互联全世界的网络。互联网是一个开放、互联的网络，不属于任何个人和任何机构，接入互联网后可以和互联网的任何一台主机进行通信。
1.网络协议
概念
网络协议：就是为了通信各方能够互相交流而定义的标准或规则，手机、无线路由器等设备通过多种网络协议便能实现通信。例如：手机电脑通过WLAN协议接入WIFI，通过DHCP协议自动获取网络配置，这样手机接入了局域网。
OIS七层协议模型
OSI 参考模型将网络协议提供的服务分成 7 层，并定义每一层的服务内容，实现每一层服务的是协议，协议的具体内容是规则。上下层之间通过接口进行交互，同一层之间通过协议进行交互。
| 分层 | 分层名称 |
|---|---|
| 7 | 应用层 |
| 6 | 表示层 |
| 5 | 会话层 |
| 4 | 传输层 |
| 3 | 网络层 |
| 2 | 数据链路层 |
| 1 | 物理层 |
最高层：应用层
应用层是计算机用户，以及各种应用程序和网络之间的接口，其功能是直接向用户提供服务，完成用户希望在网络上完成的各种工作。
第6层：表示层
表示层负责数据格式的转换，将应用处理的信息转换为适合网络传输的格式，或者将来自下一层的数据转换为上层能处理的格式。
第5层：会话层
虽然已经可以实现给正确的计算机发送正确的封装过后的信息了。但我们总不可能每次都要调用传输层协议去打包，然后再调用IP协议去找路由，所以我们要建立一个自动收发包，自动寻址的功能。于是会话层出现了。
作用就是建立和管理应用程序之间的通信。
第4层：传输层
当发送大量数据时，很可能会出现丢包的情况，另一台电脑要告诉是否完整接收到全部的包。如果缺了，就告诉丢了哪些包，然后再发一次，直至全部接收为止。
作用是监控数据传输服务的质量，保证报文的正确传输。
第3层：网络层
计算机网络中如果有多台计算机，怎么找到要发的那台？如果中间有多个节点，怎么选择路径？这就是路由要做的事。
作用是通过路由选择算法，为报文（该层的数据单位，由上一层数据打包而来）通过通信子网选择最适当的路径。这一层定义的是IP地址，通过IP地址寻址，所以产生了IP协议。
第2层：数据链路层
在计算机网络中由于各种干扰的存在，物理链路是不可靠的。该层的主要功能就是：通过各种控制协议，将有差错的物理信道变为无差错的、能可靠传输数据帧的数据链路。
作用是是接收来自物理层的位流形式的数据，并封装成帧，传送到上一层；同样，也将来自上层的数据帧，拆装为位流形式的数据转发到物理层。
最低层：物理层
解决两个硬件之间怎么通信的问题，常见的物理媒介有光纤、电缆、中继器等。它主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。
TCP/IP四层协议簇（网际网协议簇）
TCP/IP四层协议簇是在当时已有协议上归纳总结出的模型，更泛用更标准。TCP/IP 与 OSI 分层之间的对应关系，以及 TCP/IP 每层的主要协议。
应用层：http(超文本传输协议)、ftp（文件传输协议）、nfs（网络挂载协议）、ssh（远程登录协议）、telnet
针对特定应用的协议。应用程序和网络之间的接口，直接向用户提供服务。应用层设备不转发数据，它们是数据的源或目的。
传输层：TCP(传输控制协议)、UDP（用户数据协议）、SCTP（流控制传输协议）
主要功能就是让应用程序之间互相通信，并确保数据包顺利且完整无误送达。通过端口号识别应用程序，使用的协议有面向连接的 TCP 协议和面向无连接的 UDP 协议。（老板兼安全员）
网络层：IP（网间协议）、ICMP（网际控制消息协议）、IGMP（网际组管理协议）
IP 协议基于 IP 地址转发分包数据，作用是将数据包从源地址发送到目的地址。（导航领路员兼菜鸟驿站，通过IP地址转发）
物理与网络接口层：以太网协议、ARP（地址解析协议）、RARP（反向地址转换协议）
设备之间通过物理的传输介质互连， 而互连的设备之间使用 MAC 地址实现数据传输。（底层搬运工，交换机、路由器传送数据都需要，通过MAC地址转发）
网络通信原理（流程）
数据的封装与解封
数据发送前，按照参考模型从上到下，在数据经过每一层时，添加协议报文头部信息，这个过程叫封装。
数据接收后，按照参考模型从下到上，在数据经过每一层时，去掉协议头部信息，这个过程叫解封装。
数据传输流程
发送数据包：
1.访问浏览器页面，应用程序中会进行 HTML 格式编码处理，然后发送请求，让下一层TCP进行数据传送。（应用层、表示层、会话层）
2.到传输层后，TCP 需要给数据封装 TCP 头部信息，随后封装了 TCP 头部信息的段再发送给 IP 。（传输层）
3.IP 将 TCP 传过来的数据段当做自己的数据，并封装 IP 头部信息。（网络层）
4.网络接口对传过来的 IP 包封装上以太网头部信息并进行发送处理。
5.经过三（四）次封装，最后报文形成以太网数据帧的格式，然后通过物理层（传输介质）传输给接收端。
接收数据包：
1.网络接口查看以太网帧头部信息，看目标mac地址是否是自己，是的话将以太网帧解封装成 IP 包，传给 IP 模块进行处理。
2.网络层收到IP包后，头部信息的目的 IP 地址判断是否是发送给自己包，如果是发送给自己的包，则查看上一层的协议类型。
3.传输层收到TCP包后，先检查校验，数据是否丢包损坏，然后检查序列号判断数据是否正确，然后检查端口号，确定具体应用程序。**数据接收完毕后，发送一个 “ 确认回执 ” 给发送端。**最后会把 TCP 段解封装发送给由端口号识别的应用程序。
4.应用程序收到数据后，通过解析数据内容获知发送端请求的网页内容，然后按照 HTTP 协议进行后续数据交互。
网络设备
1.通信介质与数据链路
设备之间通过线缆进行连接。有线线缆有双绞线、光纤、串口线等。根据数据链路不同选择对应的线缆。传输介质还可以被分为电波、微波等不同类型的电磁波。
传输速率：单位为 bps ，是指单位时间内传输的数据量有多少。又称作带宽，带宽越大网络传输能力就越强。
吞吐量：单位为 bps ，主机之间实际的传输速率。吞吐量这个词不仅衡量带宽， 同时也衡量主机的 CPU 处理能力、 网络的拥堵程度、 报文中数据字段的占有份额等信息。
2.网卡
有唯一的mac地址（设备编号），每一台计算机设备都得有它，它能与交换机直接交互。可以让计算机上网。
3.交换机
二层交换机位于 OSI 模型的第 2 层（数据链路层）。它能够识别数据链路层中的数据帧，并将帧转发给相连的另一个数据链路。
例如：A电脑通过网卡发送数据包，交换机解析查看数据帧，查看目标mac地址，然后查看端口映射表，然后通过目标端口转发数据到B电脑网卡。
4.路由器
路由器（三层交换机）是在 OSI 模型的第 3 层（网络层）。它的功能：连接两个及以上的网络，并且可以实现路由和转送。通过识别数据的 IP 地址进行转发。
先查看最外层封装的以太网头部信息，当目的 MAC 地址是自己时，就会将以太网头部解封装，查看数据的 IP 地址。根据 IP 路由表做出转发决定时，路由器会把下一跳设备的 MAC 地址作为以太网头部的目的 MAC 地址，重新封装以太网头部并将数据转发出去。
2.网络常用命令
一、nc
简介：nc是netcat的简写，是一个功能强大的网络工具。nc命令在linux系统中实际命令是ncat，nc是软连接到ncat。
功能：
实现任意TCP/UDP端口的侦听，nc可以作为server以TCP或UDP方式侦听指定端口实现任意TCP/UDP端口的侦听，nc可以作为server以TCP或UDP方式侦听指定端口
端口的扫描，nc可以作为client发起TCP或UDP连接
机器之间传输文件
机器之间网络测速
常用参数：
1) -l
用于指定nc将处于侦听模式。指定该参数，则意味着nc被当作server，侦听并接受连接，而非向其它地址发起连接。
2) -p <port>
暂未用到（老版本的nc可能需要在端口号前加-p参数，下面测试环境是centos6.6，nc版本是nc-1.84，未用到-p参数）
3) -s
指定发送数据的源IP地址，适用于多网卡机
4) -u
指定nc使用UDP协议，默认为TCP
5) -v
输出交互或出错信息，新手调试时尤为有用
6）-w
超时秒数，后面跟数字
7）-z
表示zero，表示扫描时不发送任何数据
示例（以下示例加上-u将变为UDP通信）：
1）nc -zvw 2 192.168.11.55 8888
判断是否能成功连接到192.168.11.55的8888端口，不发送任何数据，超时时间为2秒
2）nc -l 9999
开启TCP服务，端口为9999，能打印出接收到的数据，不会回发数据
3）nc 192.168.11.55 8888
向ip为192.168.11.55的8888端口发起TCP连接请求，成功后可收发数据
二、telnet
telnet命令主要用于远程登录主机，一般也可用来测试远端端口是否可用
参数较为复杂，更多用于远程登录
示例：
1）telnet 192.168.11.55 8888
向ip为192.168.11.55的8888端口发起TCP连接请求，成功后可收发数据
三、netstat
简介：netstat 命令用于显示网络状态。利用 netstat 指令可让你得知整个 Linux 系统的网络情况。
常用参数：
1）-a 或 --all
显示所有连线中的Socket。
2）-c 或 --continuous
持续列出网络状态。
3）-h 或 --help
在线帮助。
4）-l 或 --listening
显示监控中的服务器的Socket。
5）-n 或 --numeric
直接使用IP地址，而不通过域名服务器。
6）-p 或 --programs
显示正在使用Socket的程序识别码和程序名称。
7）-t 或 --tcp
显示TCP传输协议的连线状况。
8）-u 或 --udp
显示UDP传输协议的连线状况。
示例：
1）netstat -lntp
查看当前开启tcp服务的ip地址以及程序
2）netstat -anp
查看当前所有的socket使用状态和对应的程序
3.网络编程框架
1.迭代服务器
socket();
bind();
listen();
while (1) {
accept();
while (1) {
read()/write();
if ([退出条件]) {
break;
}
}
close(connfd);
}
close(sockfd);
2.多进程并发服务器
void sig_handle(int sig)
{
waitpid(-1, NULL, WNOHANG);
}
socket();
bind();
listen();
signal(SIGCHLD, sig_handle);
while (1) {
accept();
pid = fork();
if (pid > 0) {
close(connfd);
}
else if (pid == 0) {
close(sockfd);
while (1) {
read()/write();
if ([退出条件]) {
break;
}
}
close(connfd);
exit(0);
}
//wait(NULL); //阻塞
//waitpid(-1, NULL, WNOHANG); //非阻塞
}
close(sockfd);
3.多线程并发服务器
void *client_handle(void *arg)
{
int connfd = *(int *)arg;
while (1) {
read()/write();
if ([退出条件]) {
break;
}
}
close(connfd);
}
socket();
bind();
listen();
while (1) {
accept();
pthread_create(&tid, NULL, client_handle, (void *)&connfd);
//pthread_join(); //阻塞
pthread_detach();
}
close(sockfd);
4.UDP文件传输服务器框架
socket();
bind();
recvfrom(); //接收文件名
open(); //只读方式打开文件，如果失败直接退出
while (1) {
int len = read(); //从文件中读取数据，读到buf里
if (len <= 0) {
sendto(sockfd, buf, 0, 0, ...); //发送0个字节，表示数据发送完成
break;
}
sendto(); //把buf内容发送给客户端
}
close(fd);
close(sockfd);
5.UDP文件传输客户端框架
socket();
sendto(); //发送文件名给服务器
open(); //写方式打开文件，如果失败直接退出
while (1) {
int len = recvfrom(); //从服务器获取文件数据
if (len <= 0) {
break;
}
write(); //把buf内容写入文件
}
close(fd);
close(sockfd);
6.select并发TCP服务器
socket();
bind();
listen();
//创建初始化位图
FD_SET(sockfd, &fds);
while (1) {
tmp = fds;
select(); //阻塞
for (int i = 0; i < nfds; ++i) {
if (!FD_ISSET(i, &tmp)) {
continue;
}
if (i == sockfd) { //判断监听套接字
accept();
FD_SET();
if (connfd + 1 > nfds) {
nfds = connfd + 1;
}
}
else {
read();
if ([退出条件]) {
FD_CRL();
if (nfds == i + 1) {
--nfds;
}
close(i);
}
write();
}
}
}
close(sockfd);
4.TCP通信
C/S模型
客户端和数据端模型： 提供服务的程序叫服务端， 接受服务的程序叫客户端。客户端可以随时发送请求给服务端。
注意：TCP/IP 应用的架构绝大多数属于客户端/服务端模型。
SOCKET（套接字）编程
socket
服务器是插座，（服务器上可以有很多插孔）
客户端是插头，可以插在插座。
在通信过程中，socket是成对存在。一个文件描述符指向一个socket（该套接字内部由内核借助两个缓存区实现）
网络字节序
顾名思义，在网络传输中字节的顺序。字节序分为大端字节序和小端字节序，大端是低地址存高位，小端是低地址存地位。
一般计算机系统是小端字节序，而网络通信是打大端字节序。数据打包是按照小端字节序封装，三层交换机解封装时按照大端字节数读取，会造成无法正确识别而传输失效。
故需要进行主机字节数和网络字节序的相互转换。
htons(unit16_t hostshort);//主机字节序转网络字节序
htonl(unit32_t netlong);//主机字节序转网络字节序
ntohs(unit16_t hostshort);//网络字节序转主机字节序
ntohl(unit16_t netlong);//网络字节序转主机字节序
h代表host;n代表network;s代表16位短整型;l代表长整型
IP地址转换函数
192.168.6.66是，需要将其通过atoi( )函数转成整数，然后通过htonl化为网络字节序的整型数。这样比较麻烦
#include<arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);//主机字节序（ip地址）转换为网络字节序
功能：
This function converts the character string src into a network address structure in the af address family.
返回值：
成功：返回1
异常：返回0，说明src指向的不是一个有效ip地址
失败：返回-1，并置errno
参数：
参数1：The following address families are currently supported（IP地址家族）:
AF_INET IPv4 network address //The address is converted to a struct in_addr and copied to dst, which must be sizeof(struct in_addr) (4) bytes (32 bits) long.
AF_INET6 IPv6 network address
参数2：
src:输入参数："192.168.6.61"(点分十进制数格式的ip地址)
参数3：
dst:输出参数：转换后的网络字节序ip地址
int inet_ntop(int af, const char *src, void *dst);//网络字节序（ip地址）转换为主机字节序
sockaddr数据结构
struct sockaddr{}；结构体与struct sockaddr_in {}；结构体所占空间大小是一样，本来struct sockaddr_in {}；就是struct sockaddr{}；的升级款。
但是struct sockaddr{}；年代久远，之前调用它构建的函数不可能全部重构。所以现代虽是实际使用struct sockaddr_in {}；但调用时它必须强转为struct sockaddr{}；结构体类型。例如bind（）函数。
struct sockaddr
{
sa_family_t sa_family;
char sa_data[14];
};
//最早期定义的数据结构.
//但是随着进步，出现了配对ipv4的更好的struct sockaddr_in{};
struct sockaddr_in
{
sa_family_t sin_family; /* address family: AF_INET */
in_port_t sin_port; /* port in network byte order */
struct in_addr sin_addr; /* internet address（必须是network byte order:网络字节序） */
};
/* Internet address. */
struct in_addr
{
uint32_t s_addr; /* address in network byte oder */
};//历史遗留问题，被一点点删掉了
/*==============================================================================================*/
struct sockaddr_in addr;//定义一个结构体addr
/*
初始化结构体成员
*/
addr.sin_family = AF_INET;
addr.sin_port = htons(8888);
addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY宏：取出系统中任意的有效IP地址，它是个二进制整形。
SOCKET编程
socket模型创建流程
服务器端模型建立：
1.创建套接字，socket( )在客户端创建一个套接字，socket( )在服务器端创建一个套接字，形成通信的插头与插座。用文件描述符指向套接字，文件描述符理解为句柄。
2.使用bind( )绑定 IP和端口。
3.使用listen( )设置监听上限个数（客户端同时与服务器通信）
4.使用accept( )建立通信，accept（）函数会调用第一步中套接字的sockfd,并返回一个套接字(用connfd指向该套接字）用于与客户端进行通信。此时connfd用于与客户端通信，而sockfd用于监听。
注意：accept( )为阻塞函数，会阻塞等待客户端连接connect。
5.服务器端利用write( )请求数据，服务器端利用read( )接受数据，然后处理请求，再利用write( )向客户端回应数据，客户端利用read( )接受数据。
6.完成一次通信。
客户端模型建立：
1.创建套接字，socket( )在客户端创建一个套接字，socket( )在服务器端创建一个套接字，形成通信的插头与插座。用文件描述符指向套接字，文件描述符理解为句柄。
2.使用connet( )函数建立与服务器端的链接。
3.服务器端利用write( )请求数据，服务器端利用read( )接受数据，然后处理请求，再利用write( )向客户端回应数据，客户端利用read( )接受数据。
4.完成一次通信。
socket( )函数
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int domain域, int type, int protocol协议)
功能：创建一个套接字
返回值：
成功：返回套接字对应的文件描述符sockfd//a file descriptor for the new socket is returned
失败：返回-1，并置errno
参数：
参数1：domain:IP协议
Name Purpose Man page
AF_UNIX, AF_LOCAL Local communication unix(7)
AF_INET IPv4 Internet protocols ip(7)
AF_INET6 IPv6 Internet protocols ipv6(7)
参数2：type:指定传输格式协议：有流格式子协议、数据包格式协议。
SOCK_STREAM Provides sequenced, reliable, two-way, connection-based byte streams.
提供排序、可靠、双向、基于连接的字节流。
SOCK_DGRAM Supports datagrams (connectionless, unreliable messages of a fixed maximum length). 数据报
参数3：protocol: 一般为0
#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
功能：为套接字分配名称。绑定ip和端口号。//将 addr 指定的地址分配给文件描述符 sockfd 引用的套接字。 Addrlen 指定 addr 指向的地址结构的大小（以字节为单位）。
返回值：
成功：返回0
失败：返回-1，并置errno
参数：
参数1：sockfd:已创建套接字的文件描述符
参数2：&addr为传入参数:指定的结构地址分配给文件描述符 sockfd 引用的套接字。
参数3：Addrlen:指定 addr 指向的地址结构的大小（以字节为单位）//sizeof( struct sockaddr_in)
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MY_SOCK_PATH "/somepath"
#define LISTEN_BACKLOG 50
#define handle_error(msg) do { perror(msg); exit(EXIT_FAILURE); } while (0)
int main(int argc, char *argv[])
{
int sfd, cfd;
struct sockaddr_un my_addr, peer_addr;
socklen_t peer_addr_size;
sfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sfd == -1)
handle_error("socket");
memset(&my_addr, 0, sizeof(struct sockaddr_un));
/* Clear structure */
my_addr.sun_family = AF_UNIX;
strncpy(my_addr.sun_path, MY_SOCK_PATH,
sizeof(my_addr.sun_path) - 1);
if (bind(sfd, (struct sockaddr *) &my_addr,
sizeof(struct sockaddr_un)) == -1)
handle_error("bind");
if (listen(sfd, LISTEN_BACKLOG) == -1)
handle_error("listen");
/* Now we can accept incoming connections one
at a time using accept(2) */
peer_addr_size = sizeof(struct sockaddr_un);
cfd = accept(sfd, (struct sockaddr *) &peer_addr,
&peer_addr_size);
if (cfd == -1)
handle_error("accept");
/* Code to deal with incoming connection(s)... */
/* When no longer required, the socket pathname, MY_SOCK_PATH
should be deleted using unlink(2) or remove(3) */
}
listen( )函数
#include <sys/types.h>
#include <sys/socket.h>
int listen(int sockfd, int backlog);
功能：将 sockfd 引用的套接字标记为被动套接字，即作为使用 accept（2） 传入连接请求的套接字。//被动套接字理解为成为接受方，等待电话铃声想起。
返回值：
成功：返回0
失败：返回-1，并置errno
参数：
参数1：sockfd:已创建套接字的文件描述符
参数2：backlog:定义 sockfd 的挂起连接队列可能增长到的最大长度。//能同时连接客户端的个数(同时进行3次握手的客户端个数)
#include <sys/types.h>
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);//阻塞等待与客户端建立连接
功能：
它提取监听套接字sockfd的挂起连接队列上的第一个连接请求，创建一个新的连接套接字，并返回指向该套接字的新文件描述符来指向它。 新创建的套接字未处于监听状态。原始套接字 sockfd 不受此调用的影响。//意思是基于被动套接字收到的连接请求，再创一个套接字用来连接通信
返回值：
成功：返回0
失败：返回-1，并置errno
参数：
参数1：sockfd:新创建的连接套接字的文件描述符I(真正与客户端通信的套接字)
参数2：&addr为传出参数:成功与服务器连接的那个客户端的地址结构
参数3：&addrlen为传入传出参数：入：addr的大小；出：客户端addr的实际大小
入： socklen_t client_addr_len = sizeof(client_addr);
出：strlen(client_addr);//实际大小
5.TCP重点
TCP协议头
三次握手
四次挥手
TCP为何能实现可靠通信
TCP是可靠的（无差错，不丢失，不重复），按序传递的，基于字节流传输的面向连接的传输层的传输控制协议。
TCP：
1)传输数据在传输过程中不会丢失，无差错，不重复
2）按序传递
3）没有消息边界
4）面向连接，一对一通信。
停止等待
超时重传
理想传输条件：1）传输信道无差错； 2）发送方发送速度多快，接收方都能来得及处理
TCP停止等待协议
每发送完一个数据单元的分组，会停止发送，等待对方确定后，再发下一组。
超时重传：超过一段时间没收到确认，发送方就会认为数据包丢失，既而重传。
滑动窗口机制
滑动窗口协议（Sliding Window Protocol），属于TCP协议的一种应用，用于网络数据传输时的流量控制，以避免拥塞的发生。该协议允许发送方在停止并等待确认前发送多个数据分组。由于发送方不必每发一个分组就停下来等待确认，因此该协议可以加速数据的传输，提高网络吞吐量。
TCP通过滑动窗口的概念来进行流量控制。设想在发送端发送数据的速度很快而接收端接收速度却很慢的情况下，为了保证数据不丢失，显然需要进行流量控制， 协调好通信双方的工作节奏。
滑动窗口本质上是描述接受方的TCP数据报缓冲区大小的数据，发送方根据这个数据来计算自己最多能发送多长的数据。如果发送方收到接受方的窗口大小为0的TCP数据报，那么发送方将停止发送数据，等到接受方发送窗口大小不为0的数据报的到来。
“窗口”对应的是一段可以被发送者发送的字节序列，其连续的范围称之为“窗口”；
“滑动”则是指这段“允许发送的范围”是可以随着发送的过程而变化的，方式就是按顺序“滑动”。
TCP协议的两端分别为发送者A和接收者B，由于是全双工协议，因此A和B应该分别维护着一个独立的发送缓冲区和接收缓冲区，由于对等性（A发B收和B发A收），我们以A发送B接收的情况作为例子；
发送窗口是发送缓存中的一部分，是可以被TCP协议发送的那部分，其实应用层需要发送的所有数据都被放进了发送者的发送缓冲区；
发送窗口中相关的有四个概念：已发送并收到确认的数据（不再发送窗口和发送缓冲区之内）、已发送但未收到确认的数据（位于发送窗口之中）、允许发送但尚未发送的数据以及发送窗口外发送缓冲区内暂时不允许发送的数据
每次成功发送数据之后，发送窗口就会在发送缓冲区中按顺序移动，将 新的数据包含到窗口中准备发送；
流量控制
受接受方的处理能力影响，接收方没从接受缓冲区读取数据，从而限制发送发发送数据库，防止接受缓冲区数据丢弃。
先收缩窗口，再收缩缓冲区
拥塞控制机制
网络中的链路容量和交换结点中的缓存和处理机都有着工作的极限，当网络的需求超过它们的工作极限时，就出现了拥塞。
拥塞控制：**拥塞控制就是防止过多的数据注入到网络中，这样可以使网络中的路由器或链路不致过载。**常用的方法就是：
- 慢开始、拥塞控制
- 快重传、快恢复
慢开始、拥塞控制：
慢开始、拥塞控制是在拥塞发生时循序减少主机发送到网络中的分组数，使得发生拥塞的路由器有足够的时间把队列中积压的分组处理完毕。
1.发送方维持一个叫做“拥塞窗口”的变量，该变量和接收端口共同决定了发送者的发送窗口；
2.当主机开始发送数据时，避免一下子将大量字节注入到网络，造成或者增加拥塞，选择发送一个1字节的试探报文；
存中…(img-AZ23ceb5-1695278505158)]
[外链图片转存中…(img-eM9Eg3C5-1695278505158)]
局域网 ：
小范
1469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
