1. C++面向过程

一、C++简介

1.1 C++的产生及其特点

从C语言发展演变而来，解决了C语言中存在的一些问题，并增加了对面向对象程序设计方法的支持
- 与其他高级语言相比，C语言可以直接访问物理地址；与汇编相比它具有良好的可读性和可移植性
C++于1980年由贝尔实验室的Bjarne Stroustrup创建
特点：
- 尽量兼容C语言
- 支持面向对象的方法
  - 对象是程序的基本单元
  - 对象的属性需要用某种类型的数据来表示
  - 对象的功能和行为由成员函数来实现，函数的实现归根到底是算法的设计

1.2 Hello World

/*** #include头文件，既用于声明头文件以供多个文件使用，同时也用来声明函数原型，以便于在整个程序中使用 ***/
#include <iostream>// 主函数，程序入口
int main(){std::cout << "Hello World !" << std::endl;std::cout << "Welcome to C++ ! " << std::endl;return 0;
}

二、C++语法基础

2.1 标识符命名规则

以字母或者下划线开始
可以由大写字母、小写字母、下划线或数字0~9组成
区分大小写
不能是C++关键字或操作符

2.2 注释

单行注释：//注释描述
多行注释：/* 注释描述 */

2.3 变量

作用：给一段指定的内存空间命名，方便操作这段内存
语法：数据类型变量名 = 初始值;

#include<iostream>
using namespace std;int main() {//变量的定义//语法：数据类型  变量名 = 初始值int a = 10;cout << "a = " << a << endl;system("pause");return 0;
}

2.4 常量

作用：记录程序中不可更改的数据
定义方式：
- #define 宏常量：#define 常量名常量值
  - 没有数据类型，只是简单的字符串替换，不能进行安全检查
- const常量：const 数据类型常量名 = 常量值
  - 常类型，创建时必须初始化
  - 编译期概念，即编译时用到的地方都会替换成相应的值，可节省空间，避免不必要的内存分配

//1、宏常量
#define day 7int main() {cout << "一周里总共有 " << day << " 天" << endl;//day = 8;  //报错，宏常量不可以修改//2、const修饰变量const int month = 12;cout << "一年里总共有 " << month << " 个月份" << endl;//month = 24; //报错，常量是不可以修改的system("pause");return 0;
}

const对象默认为文件局部变量
- 默认情况下，const对象被设定为仅在文件内有效，如果要在不同的程序文件中使用同一个const对象，则必须要显示声明extern，并初始化
- 多个文件之间共享const对象，那么不管是声明还是定义都可添加上extern关键字，这样就只需要定义一次即可

// file_1.cpp
// 定义并初始化了一个常量，该常量可以被其他文件访问
extern const int bufSize = fcn();// file_2.h
// 与file_1.cpp中定义的bufSize是同一个
extern const int bufSize;// file_1.cpp定义并初始化了bufSize，因此显然是一个定义，加上了extern则可以被其他文件访问
// file_2.h头文件中的声明也由extern做了限定，其作用是指明bufSize并非本文独有，它的定义将在别处出现

2.5 数据类型

作用：
- 存储所需要的尺寸
- 取值空间
- 对齐信息
- 可执行的操作
不同变量类型之间的唯一区别就是内存空间大小
- 1 byte = 8 bit
- 1 bit 可为0或1
- 有符号数signed，需要有一位表示符号+/- ；无符号数unsigned

2.5.1 整型 int

sizeof关键字
1. 作用：统计数据类型所占内存大小
2. 语法：sizeof( 数据类型 / 变量)
3. 例如：sizeof(float)
4. 整型内存大小的一个结论：short < int <= long <= long long

2.5.2 浮点型（实型）

作用：表示小数
分成两种：float、double

默认情况下，输出一个小数，会显示出6位有效数字

2.5.3 字符型 char

作用：用于显示单个字符
语法：char ch = 'a';
注意：
1. 用单引号将字符括起
2. 单引号内只能有一个字符
C/C++中字符型变量只占用一个字节

不是把字符本身放到内存中存储，而是将对应的ASCII编码放入存储单元

int main() {char ch = 'a';cout << ch << endl;cout << sizeof(char) << endl;//ch = "abcde"; //错误，不可以用双引号//ch = 'abcde'; //错误，单引号内只能引用一个字符cout << (int)ch << endl;  //查看字符a对应的ASCII码ch = 97; //可以直接用ASCII给字符型变量赋值cout << ch << endl;system("pause");return 0;
}

转义字符：用于表示一些不能显示出来的ASCII字符

字符串型

C风格：char 变量名[]="字符串值"

要加中括号

int main() {char str1[] = "hello world";cout << str1 << endl;system("pause");return 0;
}

C++风格：string 变量名="字符串值"

要包含头文件：#include <string>

int main() {string str = "hello world";cout << str << endl;system("pause");return 0;
}

2.5.4 布尔型 bool

只有两个值
- true：本质是1，非0都是1
- false：本质是0
只占1个字节

int main() {bool flag = true;cout << flag << endl; // 1flag = false;cout << flag << endl; // 0cout << "size of bool = " << sizeof(bool) << endl; //1system("pause");return 0;
}

2.6 标准库类型string

标准库 string 表示可变长的字符序列

使用string类型时必须要首先包含string头文件

#include <string>

定义和初始化

string s1;		// 默认初始化，s1是一个空字符串string s2(s1);	// 直接初始化string s2 = s1;	// 拷贝初始化

如果使用等号=初始化一个变量，实际上就是执行的拷贝初始化
不使用等号=，则执行的直接初始化

string s3(n, 'c');	// 把s3初始化为由连续n个字符c组成的串// 例如：
string s3(5, 'c');	// s3的初始化内容是5个c组成的串：ccccc

string对象的操作
- 执行读取操作时，string对象会自动忽略开头的空白，从第一个真正的字符开始读起
- 输入：“ HelloWorld ”，输出：“HelloWorld”
```
#include <string>int main() {string s;std::cin >> s;std::cout << s << std::endl;return 0;
}
```
- 多个输入或多个输出可以连写在一起
```
string s1, s2;
cin >> s1 >> s2;			// 第一个输入读到s1中, 第二个输入读到s2中
cout << s1 << s2 << endl;
```
getline
- 读取一整行
- 可保留字符串中的空白符
- getline函数的参数是一个输入流和一个string对象，函数从给定的输入流中读入内容，将读入内存的存放到string对象中
- getline遇到换行符就结束读取操作并返回结果
```
int main() {string line;// 每次循环都是读入一整行，while (getline(cin, line)) {cout << line << endl;}return 0;
}
```
empty
- string的成员函数
- 根据string对象是否为空返回一个对应的布尔值
```
while ( getline(cin, line) ) {if ( !line.empty() ) {count << line << endl;}
}
```
size
- string的成员函数
- 返回string对象的长度，即string对象中字符的个数
```
string line;while (getline(cin, line)) {if (line.size() > 80)cout << line << endl;
}
```
- size函数返回的是一个string::size_type类型的值

2.7 标准库类型vector

vector表示对象的集合，其中所有对象的类型都相同，集合中的每个对象都有一个与之对应的索引，该索引可用于访问对象

vector容纳着其他对象，因此也常称为容器（container）

使用vector必须包含vector头文件

#include <vector>using std::vector;

vector是一个类模板
- 模板本身不是类或函数，可将其看作编译器生成类或函数编写的一份说明
- 当使用模板时，需要指出编译器应该把类或函数实例化成何种类型
- 实例化：编译器根据模板创建类或函数的过程

定义和初始化

vector<T> v1;					// T是对象类型，v1是一个空的vector对象，执行默认初始化vector<T> v2(v1);				// v2中包含v1所有元素的副本
vector<T> v2 = v1;				// 同上vector<T> v3(n, val);			// v3包含n个重复的元素, 每个元素值都是val// 值初始化
vector<T> v4(n)				   // 只提供容纳的元素数量，初值由元素类型决定，如int型则初值为0// 列表初始化
vector<T> v4{a, b, c, ...};  	// v4包含了初始值个数的元素，每个元素被赋予相应的初始值
vector<T> v5 = {a, b, c, ...};	// 同上

push_back
- vector的成员函数，用于添加元素
- 将一个值作为vector对象的尾元素push到vector对象的尾端
```
// 将0 ~ 99的整数存储到v2中vector<int> v2;for (int i = 0; i != 100; ++i) {v2.push_back(i);
}
```
```
// 从标准输入中读取单词，将其作为vector对象的元素存储string word;
vector<string> text;while ( cin >> word ) {text.push_back(word);
}
```
- 如果循环体内包含有向vector对象添加元素的语句，则不能使用范围for循环
  - 范围for循环语句体内不应改变其所遍历序列的大小

注意：

不能用下标形式给vector对象添加元素
可用于访问已存在的元素，下标从0开始

2.6 数据输入

从键盘获取输入数据

int main(){//整型输入int a = 0;cout << "请输入整型变量：" << endl;cin >> a;cout << a << endl;//浮点型输入double d = 0;cout << "请输入浮点型变量：" << endl;cin >> d;cout << d << endl;//字符型输入char ch = 0;cout << "请输入字符型变量：" << endl;cin >> ch;cout << ch << endl;//字符串型输入string str;cout << "请输入字符串型变量：" << endl;cin >> str;cout << str << endl;//布尔类型输入bool flag = true;cout << "请输入布尔型变量：" << endl;cin >> flag;cout << flag << endl;system("pause");return EXIT_SUCCESS;
}

2.7 类型别名

两种方式：

typedef

typedef double d;	// d是类型double的同义词

别名声明：using

using d = double;	// 把等号左侧的名字规定成右侧的类型的别名

2.7.1 auto

让编译器通过初始值来推算变量的类型
auto定义的变量必须要有初始值

auto a = val1 + val2;// a初始化为val1和val2相加的结果

auto可以在一条语句中声明多个变量，但必须注意一条声明语句只能有一个基本数据类型

auto i = 1, *p = &i;	// i是整型变量，p是整型指针auto a = 0, b = 3.14;	// 错误！！！

2.7.2 decltype

选择并返回操作数的数据类型

decltype( fcn() ) sum = x;	// sum的类型是函数fcn返回类型

编译器会分析表达式并得到它的类型，不会实际计算表达式的值

三、运算符

用于执行代码运算

3.1 算术运算符

处理四则运算

加减乘除

int main() {int a1 = 10;int b1 = 3;cout << a1 + b1 << endl;cout << a1 - b1 << endl;cout << a1 * b1 << endl;cout << a1 / b1 << endl;  //两个整数相除结果依然是整数int a2 = 10;int b2 = 20;cout << a2 / b2 << endl; int a3 = 10;int b3 = 0;//cout << a3 / b3 << endl; //报错，除数不可以为0//两个小数可以相除double d1 = 0.5;double d2 = 0.25;cout << d1 / d2 << endl;return 0;
}

取模

int main() {int a1 = 10;int b1 = 3;cout << 10 % 3 << endl;int a2 = 10;int b2 = 20;cout << a2 % b2 << endl;int a3 = 10;int b3 = 0;//cout << a3 % b3 << endl; //取模运算时，除数也不能为0//两个小数不可以取模double d1 = 3.14;double d2 = 1.1;//cout << d1 % d2 << endl;return 0;
}

递增递减

int main() {//后置递增int a = 10;a++; //等价于a = a + 1cout << a << endl; // 11//前置递增int b = 10;++b;cout << b << endl; // 11//区别//前置递增先对变量进行++，再计算表达式int a2 = 10;int b2 = ++a2 * 10;cout << b2 << endl;//后置递增先计算表达式，后对变量进行++int a3 = 10;int b3 = a3++ * 10;cout << b3 << endl;return 0;
}

3.2 赋值运算符

3.3 比较运算符

用于表达式的比较，并返回一个真值或假值

3.4 逻辑运算符

用于根据表达式的值返回真值或假值

四、基本控制结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

顺序结构：程序按顺序执行，不发生跳转
选择结构：依据条件是否满足，有选择的执行相应功能
循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

单行格式 if 语句

int main() {//选择结构-单行if语句//输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印int score = 0;cout << "请输入一个分数：" << endl;cin >> score;cout << "您输入的分数为： " << score << endl;//if语句//注意事项，在if判断语句后面，不要加分号if (score > 600) {cout << "我考上了一本大学！！！" << endl;}return 0;
}

多行格式 if 语句

int main() {int score = 0;cout << "请输入考试分数：" << endl;cin >> score;if (score > 600) {cout << "我考上了一本大学" << endl;}else {cout << "我未考上一本大学" << endl;}return 0;
}

多条件的 if 语句

int main() {int score = 0;cout << "请输入考试分数：" << endl;cin >> score;if (score > 600) {cout << "我考上了一本大学" << endl;}else if (score > 500) {cout << "我考上了二本大学" << endl;}else if (score > 400) {cout << "我考上了三本大学" << endl;}else {cout << "我未考上本科" << endl;}return 0;
}/**********************等价于*************************/
else {if (score > 500) {cout << "我考上了二本大学" << endl;}
}

嵌套if语句

// 案例需求：
// 提示用户输入一个高考考试分数，根据分数做如下判断
// 分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科
// 在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大
int main() {int score = 0;cout << "请输入考试分数：" << endl;cin >> score;if (score > 600) {cout << "我考上了一本大学" << endl;if (score > 700) {cout << "我考上了北大" << endl;}else if (score > 650) {cout << "我考上了清华" << endl;}else {cout << "我考上了人大" << endl;}}else if (score > 500) {cout << "我考上了二本大学" << endl;}else if (score > 400) {cout << "我考上了三本大学" << endl;}else {cout << "我未考上本科" << endl;}return 0;
}

4.1.2 三目运算符

语法：表达式1 ? 表达式2 ：表达式3
- 如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
- 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

int main() {int a = 10, b = 20, c = 0;c = a > b ? a : b;cout << "c = " << c << endl;//C++中三目运算符返回的是变量,可以继续赋值(a > b ? a : b) = 100;cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;return 0;
}

4.1.3 switch语句

执行多条件分支语句
switch语句中表达式类型只能是整型或者字符型
case里如果没有break，那么程序会一直向下执行

switch(表达式) {case 结果1：执行语句; break;case 结果2：执行语句; break;...default:执行语句;break;
}

//请给电影评分 
//10 ~ 9   经典   
// 8 ~ 7   非常好
// 6 ~ 5   一般
// 5分以下 烂片
int main() {int score = 0;cout << "请给电影打分" << endl;cin >> score;switch (score) {case 10:					// 没有break就会继续往下执行case 9:cout << "经典" << endl;break;case 8:cout << "非常好" << endl;break;case 7:case 6:cout << "一般" << endl;break;default:cout << "烂片" << endl;break;}return 0;
}

4.2 循环语句

4.2.1 while循环

满足循环条件，执行循环语句

int main() {int num = 0;while (num < 10) {cout << "num = " << num << endl;num++;}return 0;
}

4.2.2 do…while循环

与while的区别在于do…while会先执行一次循环语句，再判断循环条件

int main() {int num = 0;do {cout << num << endl;num++;} while (num < 10);return 0;
}

4.2.3 for循环

语法：for(起始表达式; 条件表达式; 末尾循环体) { 循环语句; }

int main() {for (int i = 0; i < 10; i++) {cout << i << endl;}return 0;
}/*****************等价于***********************/
int i = 0;
bool condition = true;
for(;condition;) {i++;if(!(i < 10))condition = false;
}

4.3 break语句

用于跳出选择结构或者循环结构
break使用的时机：
- 出现在switch条件语句中，作用是终止case并跳出switch
- 出现在循环语句中，作用是跳出当前的循环语句
- 出现在嵌套循环中，跳出最近的内层循环语句

int main() {//2、在循环语句中用breakfor (int i = 0; i < 10; i++) {if (i == 5)	{break; //跳出循环语句}cout << i << endl;}return 0;
}

4.4 continue语句

在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

int main() {for (int i = 0; i < 100; i++) {if (i % 2 == 0) {continue;}cout << i << endl;}return 0;
}

五、指针

5.1 指针的基本概念

指针是一个整数，存储一个内存地址
- 电脑中的内存就像是一条大街，街边都是房子，每栋房子都有一个门牌号和地址，将每栋带地址的房子想象成一个字节的数据（1 byte）
  - 现在有人网购，需要送货上门；有人需要寄快递，把东西送出去。那么需要一个方法来获取正确的门牌号地址，也要能够从房子里搬东西出去，即能够从内存中，对那些byte进行read和write
  - 指针就是那个地址，告诉我们房子在什么地方 —— 指定的字节的在电脑内存的哪个位置
语法：数据类型* 变量名;
- 数据类型types对指针本身而言完全没有意义，因为所有指针都是一个整数，存放一个内存地址
  - 数据类型代表的是存放在这个内存中的数据的类型

int main() {//指针的定义：数据类型* 变量名 ;int a = 10; 	//定义整型变量aint* p = &a;	//定义并初始化指针, 指向变量a的地址cout << &a << endl; //打印数据a的地址cout << p << endl;  //打印指针变量p
}

5.2 指针的使用

在指针前面加一个星号*，即可访问指针指向内存中存储的数据，并对其进行操作
- 星号*也称为解引用符
这也称为Dereferencing（逆向引用，解引用）

//通过*操作指针变量指向的内存
cout << "*p = " << *p << endl;

六、引用

本质上只是指针的一个拓展
- 没有reference能做而pointer不能做的事
与指针的区别：
- reference必须引用一个已存在的变量，引用本身并不是一个新的变量，不真正占用内存
定义引用：数据类型& 引用名

int main() {int a = 10;int &b = a; // b是a的别名cout << "a = " << a << endl;cout << "b = " << b << endl;// b是a的别名，修改b的值就是在修改a的值b = 100;cout << "a = " << a << endl;cout << "b = " << b << endl;return 0;
}

注意事项：
- 引用必须初始化
- 引用在初始化之后，不可以改变

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;return 0;
}

七、函数

7.1 函数的定义与声明

函数的组成：

返回类型 函数名字(参数列表) {函数体
}

函数的声明（也称为函数接口）：
- 与定义的区别：函数声明不需要函数体
- 函数接口三要素：
  - 返回类型
  - 函数名
  - 形参类型
一般在头文件中进行声明，在源文件中定义
- 含有函数声明的头文件应该被包含到定义函数的源文件中

7.2 参数传递

每次调用函数都会重建它的形参，并用传入的实参对形参进行初始化

7.2.1 值传递

实参的值被拷贝给形参，形参和实参是两个相互独立的对象
- 实参被值传递，函数被传值调用
- 函数对形参做的所有操作都不会影响实参

7.2.2 引用传递

形参是引用类型，那么它将直接绑定到对应的实参上
- 实参被引用传递，函数被传引用调用

7.3 函数分文件编写

作用：让代码结构更加清晰
步骤：
- 创建后缀名为 .h 的头文件
  - 在头文件中写函数的声明
- 创建后缀名为 .cpp 的源文件
  - 引用上一步的.h头文件
  - 在源文件中写函数的定义
- 在主函数中调用函数，引用该函数的头文件

示例：

swap.h 头文件

# include <iostream>//实现两个数字交换的函数声明
void swap(int a, int b);

swap.cpp 源文件

// 双引号""代表自定义的头文件
# include "swap.h"void swap(int a, int b){int temp = a;a = b;b = temp;
}

main.cpp 主程序文件

# include <iostream>
# include "swap.h"int main(){int a = 10;int b = 20;swap(a, b);return 0;
}

7.4 例子：冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个；
对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值；
重复以上步骤，每次比较次数-1，直到不需要比较。

排序总轮数 = 元素个数 - 1
每轮对比次数 = 元素个数 - 排序轮数 - 1

// 利用冒泡排序实现升序序列
#include <iostream>// 冒泡排序函数 参数1 数组的首地址 参数2 数组长度
void bubbleSort(int* arr, int len) {for (int i = 0; i < len - 1; i++) {for (int j = 0; j < len - i - 1; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}// 打印数组
void printArray(int* arr, int len) {for (int i = 0; i < len; i++) {std::cout << arr[i] << std::endl;}
}int main() {// 1、创建数组int arr[10] = { 4, 3, 6, 9, 1, 2, 10, 8, 7, 5 };int len = sizeof(arr) / sizeof(arr[0]);// 2、创建函数，实现冒泡排序bubbleSort(arr, len);// 3、打印排序后的数组printArray(arr, len);system("pause");return 0;
}