C++

第一部分 基础编程

1.1. 初识C++

1.1.1. 编程语言是什么

我们编写程序，就是希望与计算机进行交流，让计算机帮助我们实现我们期望的效果。从这点出发，其实和人与人之间的沟通交流是一样的。两个人如果需要正常的沟通交流，必须要满足的条件是，你说的话对方听得懂，对方说的话你也能听得懂。如果条件不满足，你说中文对方不动，对方说英文你不懂。那么此时就没有办法交流。

写程序也是这样，我们需要和计算机沟通交流。但是很遗憾，机器听不懂我们人类的语言，也学不会人类的语言。那么我们去学习机器的语言呢？更加麻烦，计算机只认识0和1，不会太复杂的语言。此时我们怎么办？

我们可以借助一个“翻译”，把我们的需求翻译成机器语言，说给机器听。但是，这个翻译其实也是一个程序，依然没有办法学习人类的语言。幸运的是，这个“翻译员”有自己的独特的语言体系，而这种语言体系比起机器语言来说，要更加容易理解。这就是我们俗称的“编程语言”。

编程语言有很多很多，有些语言更加贴合机器的世界，这些语言对我们人类来说，学习的成本就比较高。也有一些语言，更加贴合人类的世界，这类的编程语言，更加符合我们人类的生活习惯和思维逻辑，学习起来难度要小很多，更加容易一些。这样的语言，我们称为“高级语言”，而Java就是一种高级语言。

1.1.2. 进制

1.1.2.1. 进制的介绍

在我们正式开始学习C++之前，需要对计算机的一些理论的基础有一定的认知。而进制就是这样的基础，因此我们需要先学习进制。

我们知道在计算机的世界中，只有0和1两个数字，那么其他的数据该如何去表示呢？

1.1.2.2. 什么是进制

进制也就是进位计数制，是人为定义的带进位的计数方法（有不带进位的计数方法，比如原始的结绳计数法，唱票时常用的“正”字计数法，以及类似的tally mark计数）。 对于任何一种进制—X进制，就表示每一位置上的数运算时都是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

1.1.2.3. 进制的分类

二进制

用数字0和1表示每一个自然数，逢2进1。这样的进位制度称为“二进制”

例如: 0, 1, 10, 11, 100, 101, 110, 111, 1000

在计算机的世界中，所有的数据最终在存储和运算的时候，都是以二进制的形式进行的。

十进制

日常生活中，我们使用到的进位制度。使用数字0-9表示每一个自然数，逢10进1。这样的进位制度称为“十进制”

例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, …

八进制

使用数字0-7表示每一个自然数，逢8进1。这样的进位制度称为“八进制”

例如: 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, …

十六进制

使用数字0-9，a-f表示每一个自然数，逢16进1。这样的进位制度称为“十六进制”

例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 10, 11, 12, 13, …

TIPS: 为什么会有八进制和十六进制

计算机只认识0和1，因此数据的存储和运算都是以二进制的形式完成的。但是，二进制与我们日常生活中使用的十进制相差较远。二进制数字对我们人类来说，可读性会有很大的影响。因此，人们在二进制和十进制的基础上，衍生出来了八进制和十六进制。一方面满足了与二进制之间转换的便捷性，另一方面也带来了可读性的提升。

1.1.2.4. 不同进制的表示方式

进制有着不同的分类，我们常见的有二进制、八进制、十进制、十六进制。因此当我们写一个数字的时候，需要区分到底是什么进制。

• 二进制: 通常以****0b作为开头，例如: 0b1001, 0b1100等
• 八进制: 通常以****0作为开头，例如: 012, 076, 0234等
• 十六进制: 通常以****0x作为开头，例如: 0x12, 0xa2df, 0x23fa等
• 十进制: 前面什么都不写，默认的就是十进制的表示形式

**TIPS: **

在进行二进制的计算的时候，有一个小的技巧: 在二进制中，每向左移动一位，相当于在现有的值的基础上乘2。

例如:

0b1 = 1

0b10 = 2

0b100 = 4

0b1000 = 8

基于这一点考虑，我们在进行进制的计算的时候，可以使用拆数字的形式来完成。把一个数字拆解成2的整数次幂，方便累加。

例如:

13 = 8 + 4 + 1 = 1101

23 = 16 + 4 + 2 + 1 = 10111

1.1.2.5. 进制的转换

1. 十进制转其他进制
   使用辗转相除法，用数字除进制，再用商除进制，一直累除。直到商为0结束。最后将每一步得到的余数倒着连接起来即可。
   

2. 其他进制转十进制
   用每一位的数字，乘进制的位数-1次方，把所有的结果累加到一起，即可得到十进制表示形式。
   

3. 八进制、十六进制与二进制互相转换

   • 一个八进制位可以等价替换成3个二进制位
   • 一个十六进制位可以等价替换成4个二进制位

   

   1 2 3 4 5 6

   0175 => 0x?? 0b 0111 1101 = 7D 0x793 => 0? 0b 011 110 010 011 = 03623

1.1.2.6. 负数的表示方式

在上述的进制的表示和进制的转换中，我们完成的都是正数的表示形式。那么负数呢？

我们需要先知道一个前提: 在二进制中，每一个二进制位，我们称为一个比特位，简称bit

8bit = 1Byte (字节)

再往后的单位转换，大家就清楚了:

1024Byte = 1KB

1024KB = 1MB

1024MB = 1GB

1024GB = 1TB

1024TB = 1PB

1024PB = 1EB

…

通常情况下，我们在用二进制表示一个数字的时候，会写满一个字节。如果一个字节表示不了，就用两个字节。如果两个字节表示不了，就用四个字节。如果四个字节表示不了，就用八个字节。以此类推。

因此，数字8的表示形式，就应该是****0000 1000

在这种表示形式中，最左侧的一位，叫做“最高位”。而这一位不是用来表示大小的，是用来表示正负数的。如果最高位是0表示正数，如果最高位是1表示负数。

1
2
3
4
5
6

小练习:

105 = 0110 1001
-76 = 1100 1100
198 = 0000 0000 1100 0110
-82 = 1101 0010

1.1.2.7. 原反补

我们已经知道了负数的表示形式了，那么我们进行一些简单的数字的加法试试看:

18 + 12 = ?

18: 0001 0010

12: 0000 1100

和: 0001 1110 = 30

看上去挺好的，结果也都是正常的。那么，我们来做一个减法计算吧:

18 - 12 = ？

18: 0001 0010

12: 0000 1100

差: 0000 0110 = 6

看上去也挺好的，结果也都是正常的。但是，这里是有问题的。计算机其实并不会做减法计算，只会做加法计算。因此，18-12的计算过程，实际上是18+(-12)，我们再来看:

18 + (-12) = ?

18: 0001 0010

-12: 1000 1100

结果: 1001 1110 = -30 ???

结果不对了！

为什么呢？其实原因也很简单，因为符号位是不能直接参与计算的。在刚才的计算中，我们直接用符号位进行计算了，因此得到了错误的结果。

为了避免符号位直接参与计算，导致计算的结果出问题，前人们继续引入了补码的概念。

实际上，在计算机中，所有的数据的存储和计算，都是以补码的形式进行的。

原码: 直接计算出来的二进制的表示形式。

反码: 正数的反码与原码相同。负数的反码为原码符号位不变，其他位按位取反。

补码: 正数的补码与原码相同。负数的补码为反码+1。

1
2
3
4
5

练习:

-18[补] = 1110 1110
-12[补] = 1111 0100
-76[补] = 1011 0100

那么，我们继续使用补码来进行减法的计算。

18 + (-12)

18[补]: 0001 0010

-12[补]: 1111 0100

计算结果: 1 0000 0110

多出来一位怎么办？简单，直接舍去就行了！得到最终的结果: 0000 0110 = 6

这样，计算的结果就正常了！我们继续做12-18

12 + (-18)

12[补]: 0000 1100

-18[补]: 1110 1110

计算结果: 1111 1010

不对！结果好像是一个很大的数字 ？因为数据的存储和计算都是以补码的形式进行的，那么计算的结果也是一个补码。

将补码转成原码其实很简单，再对这个数字求一次补即可。

1111 1010[补] = 1000 0110 = -6

结果正常了！

1.1.3. 第一个C++程序

1
2
3
4
5

#include <iostream>

int main() {
    std::cout << "Hello World!\n" << std::endl;
}

1
2
3
4
5
6
7

#include <iostream>					引用指定的库

int main() {}						主函数，程序从这里开始执行

std::cout							输出语句，将后面的内容输出到控制台

std::endl							结束输出，并冲刷缓冲区

1.1.4. 注释

在开发的过程中，我们除了要写我们的程序代码之外，还有一个非常重要的组成部分是==注释==。很多的公司对注释都是有要求的，甚至于有的公司会要求注释量不少于代码量。那么，什么是注释呢？？

注释其实就是程序员对某一段代码的解释、备注，这些内容是给程序员看的，这部分的内容不会被编译、运行，只是给一段代码做标注。

在C++中，注释分为两种: *单行注释，*多行注释

1.1.4.1. 单行注释

单行注释以两个斜线 ==//== 开始，斜线之后的内容都是注释的内容，不会被编译。

1
2
3
4
5
6
7

#include <iostream>

int main() {
    // 这里就是单行注释
    // 下面这段话，可以在控制台上输出 Hello World!
    std::cout << "Hello World!\n" << std::endl;
}

1.1.4.2. 多行注释

多行注释以 ==/== 开始，以 ==/== 结束，中间所有的内容都是注释的内容，不会被编译。

1
2
3
4
5
6
7
8
9

#include <iostream>

int main() {
    /*
    	这里的内容就是多行注释的内容
    	可以同时注释多行的内容
    */
    std::cout << "Hello World!\n" << std::endl;
}

1.2. C++数据类型

1.2.1. 标识符

1.2.1.1. 标识符的概念

其实，我们写程序，就是操作各种各样的数据进行计算处理。那么，在程序中的每一个数据，我们需要有一个唯一的标识。这就类似于我们在中学时候学过的代数。

1
2
3

x = 10
y = 20
x + y = 30

我们在计算x+y的时候，知道实际计算的是10和20，也就是说用x代表10，用y代表20。其实，这就是标识符。

标识符，是由字母、数字、下划线组成的一个字符序列，用来表示程序中的数据

1.2.1.2. 标识符的命名规则

• 由字母、数字、下划线组成，不能有其他的组成部分
• 不能以数字开头，需要以字母或者下划线开头
• 不能与系统关键字重复
• 区分大小写

关键字是什么？

其实关键字也是遵循上述前两点规则的字符序列，只不过这样的字符序列已经被系统征用并赋予特殊含义了，我们在定义标识符的时候就不能够再使用了。例如: int、float、const等。

1.2.1.3. 标识符的命名规范

标识符出了在遵循上述的规则之外，还有有一定的规范，并不是可以随便写的。标识符最基础的规范就是望文知义，命名要有一定的意义，方便我们自己去区分标识符所表达的含义。

1.2.2. 数据类型

在程序设计的过程中，我们会操作若干的数据进行各种各样的运算，这些数据由一个个的标识符来表示。但是，每一个数据都是有自己的数据类型的。我们在定义一个变量的时候需要指定数据类型，否则没有办法为这个数据的存储进行空间的开辟。

1.2.2.1. 整型

整型，就是整数的类型，描述的是整数数字。在C++中，整型有如下的一些分类，不同的整型所对应的空间大小不同，能够表示的数据范围也不相同，在适当的场景下，应该选择合适的数据类型来使用。

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>

int main() {
    // sizeof 获取一个数据类型或者一个变量的空间占用大小
    std::cout << "short: " << sizeof(short) << std::endl;
    std::cout << "int: " << sizeof(int) << std::endl;
    std::cout << "long: " << sizeof(long) << std::endl;
    std::cout << "long long: " << sizeof(long long) << std::endl;

    return 0;
}

1.2.2.2. 浮点型

浮点型，就是小数的类型，描述的是小数数字。浮点型有两种分类，区别在于占用的空间大小和小数点后面可以精确到的位数。

1
2
3
4
5
6
7
8
9

#include <iostream>

int main() {
    // sizeof 获取一个数据类型或者一个变量的空间占用大小
    std::cout << "float: " << sizeof(float) << std::endl;
    std::cout << "double: " << sizeof(double) << std::endl;

    return 0;
}

1.2.2.3. 布尔型

**布尔型是用来描述非真即假、非假即真的数据类型，使用关键字 **bool 来表示，只占用一个字节。布尔型只有两个值true和false。

1.2.2.4. 字符型

字符是用来描述一个文本内容中的最小组成单位的，在程序中使用关键字****char来表示，只占用一个字节。

1.2.2.5. 字符串型

字符串是由若干个字符组成的一个有序的字符序列，在C++中使用关键字****string来表示。

1.2.3. 变量、常量

我们设计程序，其实就是需要在内存中开辟出若干空间，存储若干数据，并对这若干的数据进行运算。我们会使用一个标识符来表示这些数据。这些数据中，有些值是可以改变的，例如一个人的年龄、成绩等，这些都是变量。有些值是不可以改变的，比如生日等，这些就是常量。

总结：

可以修改值的是****变量，不可以修改值的是常量。

1.2.3.1. 变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>

int main() {
    // 定义变量的语法：数据类型 标识符
    int num1;
    // 也可以在定义变量的同时，设置变量的初始值
    int num2 = 100;
    // 变量在定义完成之后，可以修改值
    num2 = 200;

    // 定义多个相同数据类型的变量
    int n1 = 100, n2 = 200;

    return 0;
}

1.2.3.2. 常量

1
2
3
4
5
6
7
8

#include <iostream>

int main() {
    // 定义常量的时候，需要添加一个关键字 const
    const int NUMBER = 10;
    std::cout << NUMBER << std::endl;
    return 0;
}

1.2.3.3. 各种数据类型的变量定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>

int main() {

    // 整型
    short num1 = 10;
    int num2 = 20;
    long num3 = 30;
    long long num4 = 40;

    // 浮点型
    float num5 = 3.14f;		// float类型最好在字面量的后面添加f
    double num6 = 3.14;

    // 布尔型
    bool num7 = true;

    // 字符型
    char num8 = 'a';		// 字符需要包含在一对单引号里面

    // 字符串类型
    string num9 = "hello";	// 字符串需要包含在一对双引号里面

    return 0;
}

1.2.3.4. 转义字符

我们使用char表示字符类型，将一个字符写到一个单引号中。使用string表示字符串类型的数据，将若干字符写到一个双引号中。

那么，是不是所有的字符都可以写在单引号或者双引号中呢？

并不是！有些字符是具有特殊的含义的。例如，在字符中，单引号成对出现，表示匹配一为字符。在字符串中，双引号成对出现，表示匹配一个字符串。

1
2
3
4
5
6
7
8
9
10
11

// 这种写法是错误的：
// 第一个单引号表示一个字符的开始
// 第二个单引号匹配一个字符的结束，此时两个单引号成对，但是中间并没有字符出现，已经是错误的了
// 第三个单引号就更是错误的情况了
char c1 = ''';

// 这种写法是错误的：
// 第一个双引号表示一个字符串的开始
// 第二个双引号表示一个字符串的结束，此时两个双引号成对，一个字符串结束
// 第三个双引号的出现，就成了错误的情况了
string str = """;

那么，我就是想在一个字符中写单引号，或者在一个字符串中写双引号怎么办？此时，就需要使用转义字符了。

转义字符，就是\，作用有两个:

• 可以将一个特殊的字符，变成一个普通的字符。

  1 2 3 4 5 6 7 8 9

  #include <iostream> int main() { // 在字符中表示单引号 char c = '\''; // 在字符串中表示双引号 string str = "\""; return 0; }

• 可以配合某些普通的字符，表达特殊的含义。

  1 2 3 4 5 6 7 8 9 10 11 12

  #include <iostream> int main() { // n本身是一个普通的字符，添加上\之后，就变成了换行符 string str1 = "hello \n world"; // 常见的转义字符配合普通字符的使用: // \n : 换行符 // \t : 制表符 // \r : 回车符 return 0; }

1.2.3.5. 数据类型转换

数据类型转换，其实是一个比较奇怪的问题。因为一个变量一旦实例化完成，类型是不能发生改变的。

例如: int a = 10; 此时的a从头到销毁，都是int类型，不会改变。

那么，数据类型转换到底是怎么一回事呢？

其实，数据类型转换，指的是定义一个新的指定类型的变量，然后将原来变量的值给这个新的变量进行赋值。这样我们就得到了一个指定数据类型的变量，并且具有了原来变量的值。

**数据类型的转换可以分为两种: **自动类型转换 和 强制类型转换。

• 自动类型转换
  由取值范围小的数据类型，向取值范围大的数据类型转换。转换的过程不需要进行额外的操作，直接赋值就可以了。且转型完成后，不存在值的精度丢失的情况

  1 2 3 4 5 6 7 8 9 10

  #include <iostream> int main() { // 1. 定义一个short类型的变量 short num1 = 10; // 2. 转型为int类型的变量 // 直接赋值即可完成转型 int num2 = num1; return 0; }

  此外，byte、short、char类型的数据参与运算的时候，结果会自动的提升为int类型

• 强制类型转换
  由取值范围大的数据类型，向取值范围小的数据类型转换。转换的过程中需要进行强制的类型转换操作，且转型完成后，可能会出现精度丢失的情况。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream> int main() { // 1. 定义一个int类型的变量 int num1 = 200; // 2. 转型为char类型的变量 // 需要进行强制类型转换，在需要转型的变量之前添加小括号，里面写上需要转型的类型即可 char num2 = (char)num1; // 转型完成后，数据的值可能会发生变化，例如转型为char类型，肯定表示不了200。这种情况叫做精度丢失。 // 那么，转型之后的结果到底是多少呢？ // 前面我们说过数据的存储和运算都是以补码的形式进行的，因此我们来计算一下200的补码是多少 // 0000 0000 1100 1000 // 转型到char类型的时候，由于只有一个字节，只有八个比特位，因此肯定要舍去一部分的数据。舍去的是高位的数据，保留最后的8位 // 也就是说，强制类型转换之后的结果是 1100 1000 // 从最高位是1，可以得到是一个负数，那么再计算一下补码，得到1011 1000，也就是-56 // 即: 上述转型完成后，得到的num2的值是-56 return 0; }

1.2.3.6. 控制台输入

我们可以使用****cout将内存中的数据输出到控制台上，也可以从控制台读取数据到内存中，而读取控制台输入的数据，给内存中的某一个变量赋值，需要使用到的是==cin==

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>

int main(){
	// 整型变量输入
	int n = 0;
	std::cout << "请输入一个整型数值: " << std::endl;
	std::cin >> n;
	std::cout << n << std::endl;

	// 浮点型变量输入
	double f = 0;
	std::cout << "请输入一个浮点型数值: " << std::endl;
	std::cin >> f;
	std::cout << f << std::endl;

	// 字符型变量输入
	char c = 0;
	std::cout << "请输入一个字符型数值: " << std::endl;
	std::cin >> c;
	std::cout << c << std::endl;

	// 字符串型输入
	string str;
	std::cout << "请输入一个字符串型数值: " << std::endl;
	std::cin >> str;
	std::cout << str << std::endl;

	// 布尔类型输入
	bool b = true;
	std::cout << "请输入布尔型变量：" << std::endl;
	std::cin >> b;
	std::cout << b << std::endl;

	return 0;
}

1.2.3.7. 宏定义

宏定义在C++中是一个比较特殊的命令，它可以在一定程度上方便开发人员的程序设计过程。但是很多的初学者因为不能很好的去理解宏定义，不明白本质是什么，因此在使用宏定义的时候经常会出现问题。

宏定义，就是在文件的头部，使用==#define==来定义一个标识符，用来描述一个字符串。这个标识符就被称为是宏定义。在程序中用到这个宏定义的时候，会直接替换成宏定义描述的字符串。

1
2
3
4
5
6
7

#include <iostream>

#define SUCCESS_CODE 0

int main() {
    return SUCCESS_CODE;		// 这里SUCCESS_CODE会被替换成0，也就成了 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>

#define EXPR 2 + 2

int main() {
    // 这里的EXPR会被替换成2 + 2，也就成了 std::cout << 2 + 2 << std::endl;
    std::cout << EXPR << std::endl;

    // 这里的EXPR会被替换成2 + 2，也就成了 std::cout << 2 + 2 * 2 + 2 << std::endl;
    std::cout << EXPR * EXPR << std::endl;

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>

#define EXPR (2 + 2)

int main() {
    // 这里的EXPR会被替换成(2 + 2)，也就成了 std::cout << (2 + 2) << std::endl;
    std::cout << EXPR << std::endl;

    // 这里的EXPR会被替换成(2 + 2)，也就成了 std::cout << (2 + 2) * (2 + 2) << std::endl;
    std::cout << EXPR * EXPR << std::endl;

    return 0;
}

1.2.4. 命名空间

在c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

1.2.4.1. 命名空间使用语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>

// 定义一个命名空间
namespace A {
    int num = 10;
    // 命名空间可以嵌套
    namespace AA {
        int num = 30;
    }
}
namespace B {
    int num = 20;
}

// 命名空间是开放的，可以随时把新成员添加到现有的命名空间中
namespace A {
    int score = 100;
}

// 在命名空间中，函数的声明和实现可以分离
namespace A {
    void test();
}

void A::test() {
    std::cout << "test" << std::endl;
}

int main() {
    // 输出A命名空间中的num
    std::cout << A::num << std::endl;
    // 输出B命名空间中的num
    std::cout << B::num << std::endl;
    // 输出A::AA命名空间中的num
    std::cout << A::AA::num << std::endl;
    return 0;
}

1.2.4.2. using

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>

// 定义命名空间
namespace constant {
    const double PI = 3.141592653;
    int num1 = 100;
    int num2 = 200;
}

int main() {

    // 输出PI
    std::cout << constant::PI << std::endl;

    // using命名空间中的指定成员
    using constant::num1;
    std::cout << num1 << std::endl;
    std::cout << constant::num2 << std::endl;

    // using命名空间
    using namespace constant;
    std::cout << num2 << std::endl;

    return 0;
}

1.2.4.3. 注意事项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>

using namespace std;

// 定义命名空间
namespace constant {
    const double PI = 3.141592653;
    int num1 = 100;
    int num2 = 200;
}

namespace A {
    int num2 = 200;
}

int main() {
    int num1 = 300;
    using namespace constant;

    cout << num1 << endl;               // 输出当前命名空间中的num1
    cout << constant::num1 << endl;     // 输出constant命名空间中的num1

    using namespace A;

    // 此时，using的constant和A命名空间中都有num2的定义，且当前的命名空间中没有num2的定义，此时会产生二义性。
    // cout << num2 << endl;   
}

1.3. 运算符

1.3.1. 算术运算符

算术运算符，可以对两个数据进行算术运算。

注意事项:

整型与整型的计算结果，还是一个整型。所以，如果10/3的时候，得到的结果是3.3333333，此时系统会将这个数字强制类型转换成整型的结果，舍去小数点后面所有的数字，只保留整数部分，也就是3。

在进行计算的时候，结果会进行类型的提升，将结果提升为取值范围大的数据类型。

• int与int的计算结果是int
• int与long的计算结果是long
• float与long的计算结果是float
• float与double的计算结果是double
• …

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

int main(){
    // 定义两个变量，用来做计算
    std::cout << 10 + 3 << std::endl;		// 13
    std::cout << 10 - 3 << std::endl;		// 7
    std::cout << 10 * 3 << std::endl;		// 30
    std::cout << 10 / 3 << std::endl;		// 3
    std::cout << 10 % 3 << std::endl;		// 1

    return 0;
}

重点来了！自增自减运算符！

++、–是自增自减运算符，表示在现有的值的基础上，对数据进行+1和-1的操作。

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>

int main(){
    // 定义一个整型的变量
    int number = 10;
    // 在现有的值的基础上+1
    number++;
    // number现在的结果就是11
    std::cout << number << std::endl;
    return 0;
}

但是！！自增自减运算符，还可以写在变量前面！

• 自增自减运算符，在变量之前，表示先对变量进行计算，再取变量的值使用。
• 自增自减运算符，在变量之后，表示先取变量的值使用，再对变量进行计算。

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>

int main(){
    // 定义一个变量
    int number = 10;

    std::cout << number++ << std::endl;		// 输出10，结束后number的值自增为11
    std::cout << ++number << std::endl;		// 输出12，在上一步结束之后，number的值自增为了11，在这里先进行计算，再取变量的值使用。运算结束后，number的值为12
    std::cout << --number << std::endl;		// 输出11，在12的基础上，先减一，再输出结果。运算结束后，number的值为11
    std::cout << number-- << std::endl;		// 输出11，在11的基础上，先取值，再减一。运算结束后，number的值为10
    std::cout << number << std::endl;		// 输出10
    return 0;
}

练习题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 有一个三位的数字，计算每一位上的数字的和
#include <iostream>

int main(){
    // 定义一个三位的数字
    int number = 123;
    // 分别获取每一位的数字
    int g = number % 10;
    int s = number / 10 % 10;
    int b = number / 100;
    // 计算每一位的数字的和
    int result = g + s + b;
    std::cout << result << std::endl;
    return 0;
}

1.3.2. 赋值运算符

在C++中的赋值运算符是=，可以将等号右边的值，给等号左边的变量进行赋值。

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

int main(){
    // 定义一个变量
    int variable;
    // 给这个变量进行赋值
    variable = 10;

    // 这里的等号，就是一个赋值运算符，将等号右边的值给左边的变量进行赋值。
    // 赋值完成后，变量variable的值，就是10
    return 0;
}

请注意: 在C++中，等号是赋值的意思，并不是比较相等的意思。

赋值运算符的意义其实很简单，就是等号右边的值给左边的变量进行赋值。但与此同时，赋值运算符与上述的算术运算符类似，也是有运算的结果的。赋值运算的结果就是赋值完成以后的变量的值！

1
2
3
4
5
6
7
8
9

#include <iostream>

int main(){
    // 定义一个变量
    int number;
    // 给变量赋值，并输出赋值结果
    std::cout << (number = 100) << std::endl;		// 这里的输出结果是100，因为赋值完成之后的变量number的值就是100
    return 0;
}

此外，程序员都可会偷懒了，在赋值运算符的基础上，又结合了常用的计算，衍生出来了其他的组合的运算符。

常见的组合运算符: += -= *= /= %=

**以 ****+=** 为例，表示将一个变量，在现有的值的基础上进行加法的计算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>

int main(){
    // 定义一个变量
    int number = 10;
    // 让变量在现有的值的基础上+10
    number += 10;

    std::cout << number << std::endl;		// number的结果就是20
    return 0;
}
// 在上述代码中，我们可以将number += 10，理解为 number = (int)(number + 10);
// 对数字number进行加10的计算，并将计算的结果再强制类型转换成变量原来的类型。
// 例如: 
// char c = 'a';
// c += 1;
// 最后c的结果是b，其实在这里已经完成了结果的强制类型转换。因为字符型的变量在参与运算的时候，结果会自动的转型为int类型
// 因为组合运算符内置了强制类型转换的操作，才会使得将计算的结果再转型为char类型

1.3.3. 关系运算符

关系运算，就是对两个数字进行大小、相等的比较的运算。常用的关系运算符如下:

关系运算符比较的是数值类型和字符类型的数据，得到的比较结果一定是bool类型。

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

int main(){
    std::cout << (10 > 5) << std::endl;			// true
    std::cout << (10 < 5) << std::endl;			// false
    std::cout << (10 >= 5) << std::endl;		// true
    std::cout << (10 <= 5) << std::endl;		// false
    std::cout << (10 == 5) << std::endl;		// false
    std::cout << (10 != 5) << std::endl;		// true

    return 0;
}

1.3.4. 逻辑运算符

逻辑运算，是对两个布尔类型的变量进行的逻辑操作。常见的逻辑运算符如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>

int main(){
    std::cout << (true & false) << std::endl;		// false
    std::cout << (true | false) << std::endl;		// true
    std::cout << (!true) << std::endl;				// false
    std::cout << (true ^ true) << std::endl;		// false

    int num1 = 10;
    int num2 = 20;
    bool res = num1++ > 10 && num2++ < 100;
    std::cout << "res = " << res << ", num1 = " << num1 << ", num2 = " << num2 << std::endl;

    return 0;
}

1.3.5. 位运算符

位运算，是作用于两个整型数字的运算。将参与运算的每一个数字计算出补码，对补码中的每一位进行类似于逻辑运算的操作，1相当于True，0相当于False。

~: 对数字补码的每一位进行取反，包括符号位。

<<: 对数字补码的每一位向左移动指定的位数，右侧补0。

>>: 对数字补码的每一位向右移动指定的位数，左侧补符号位。

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

int main() {
    std::cout << (10 & 20) << std::endl;        // 位与运算
    std::cout << (10 | 20) << std::endl;        // 位或运算
    std::cout << (10 ^ 20) << std::endl;        // 位异或运算
    std::cout << (~10) << std::endl;            // 按位取反运算
    std::cout << (10 << 2) << std::endl;        // 位左移运算
    std::cout << (10 >> 2) << std::endl;        // 位右移运算

    return 0;
}

1.3.6. 三目运算符

**三目运算符是一个带有简单逻辑的运算符，用?:来表示，语法如下: **condition ? value1 : value2

语义: condition是一个bool类型的变量或者bool结果的表达式，如果为true，运算的结果为value1；如果为false，运算的结果为value2。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>

using namespace std;

int main() {
    // 从控制台输入两个数字，计算两个数字的最大值
    int num1, num2;
    cout << "请输入一个数字: ";
    cin >> num1;
    cout << "请再次输入一个数字: ";
    cin >> num2;

    int res = num1 > num2 ? num1 : num2;
    cout << "最大值是: " << res << endl;

    return 0;
}

1.4. 流程控制

1.4.1. 流程控制概述

1.4.1.1. 程序的执行结构

我们之前在写代码，执行代码的时候，发现写的代码都是一行一行的执行的。这种执行的结构称为“顺序结构”，除了这种结构之外，还有其他的执行结构。

程序执行结构	结构的描述	描述图
顺序结构	代码从上往下，依次执行。
分支结构	程序在某一个节点遇到了多种向下执行的可能性，根据条件，选择一个分支继续执行。
循环结构	某一段代码需要被重复执行多次。

1.4.1.2. 流程控制的概念

流程控制，就是通过指定的语句，修改程序的执行结构。 按照修改的不同的执行结构，流程控制语句可以分为：

• 分支流程控制语句：
  • 顾名思义，就是将程序的执行结构修改为分支结构。
  • 常见的分支流程控制语句有: if-else、switch-case
• 循环流程控制语句:
  • 顾名思义，就是将程序的执行结构修改为循环结构。
  • 常见的循环流程控制语句有: for、while、do-while

1.4.2. 分支结构

1.4.2.1. if的结构图

1.4.2.2. if的基础语法

1
2
3
4
5
6
7

if (/* 条件判断 true or false */) {
    // 条件结果为true执行大括号以内的语句
}
/*
	执行流程：
	代码运行到if分支结构，首先判断if之后的条件是否为true，如果为true，执行大括号里面的语句，如果为false直接执行大括号之外的语句，
*/

1
2
3
4
5
6
7
8

// 示例1: 成绩如果大于60，奖励一颗糖

// 简单的if语句：
// 成绩如果大于60   给奖励
int score = 10;
if (score>60) {
	cout << "给颗糖" << endl;
}

1
2
3
4
5

// 示例2: C++成绩大于98分，而且MySQL成绩大于80分，老师奖励他；或者C++成绩等于100分，MySQL成绩大于70分，老师也可以奖励他。

if ((cppScore >98 && mysqlScore > 80 ) || ( cppScore == 100 && mysqlScore > 70 )) {
    //奖励
}

1.4.2.3. if-else的使用

1
2
3
4
5
6
7

if (condition) {
    // 代码段1
}
else {
    // 代码段2
}
// 逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行

1
2
3
4
5
6
7
8
9

int score;
cout << "请输入一个成绩:";
cin >> score;
if (score >= 60) {
    cout << "成绩及格了！" << endl；
}
else {
    cout << "成绩不及格！" << endl；
}

• 示例1: 如果是男生就永远18岁，否则永远16岁。

  1 2 3 4 5 6 7 8

  string gender; cout << "请输入你的性别: "; cin >> gender; if (gender == "男") { cout << "永远18岁！" << endl; } else { cout << "永远16岁！" << endl; }

• 示例2: 买彩票，如果体彩中了500万，我买车、买房、非洲旅游，如果没中，继续买。

  1 2 3 4 5 6 7 8

  bool isWin; cout << "你中彩票了吗？"; cin >> isWin; if (isWin) { cout << "买车！买房！非洲旅游！" << endl; } else { cout << "继续搬砖" << endl; }

1.4.2.4. else if的使用

1
2
3
4
5
6
7
8
9
10

if (condition1) {
    // 代码段1
}
else if (condition2) {
    // 代码段2
}
else {
    // 代码段3
}
// 逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3

• 示例1: 在控制台输入成绩，输出成绩的等级

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  #include <iostream> using namespace std; int main() { int score; cout << "请输入你的成绩:"; cin >> score; if (score < 60) { cout << "不及格" << endl; } else if (score < 80) { cout << "良好" << endl; } else { cout << "优秀!" << endl; } return 0; }

• 如果成绩大于90并且是男生就送个女朋友，成绩大于90并且是女生送个男朋友，否则…

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  #include <iostream> using namespace std; int main() { int score; cout << "请输入你的成绩:"; cin >> score; string gender; cout << "请输入你的性别:"; cin >> gender; if (score > 90 && gender == "男") { cout << "送你一个女朋友" << endl; } else if (score > 90 && gender == "女") { cout << "送你一个男朋友" << endl; } else { cout << "洗洗睡吧" << endl; } return 0; }

• 在控制台上输入一个字母，如果是小写字母，将其转成大写输出；如果是大写字母，将其转成小写输出；如果不是字母，原义输出。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream> using namespace std; int main() { char c ; cout << "请输入一个字符"; cin >> c; if (c >= 'a' && c <= 'z') { cout << (char)(c - 32) << endl; } else if (c >= 'A' && c <= 'Z') { cout << (char)(c + 32) << endl; } else { cout << c << endl; } return 0; }

1.4.2.5. switch结构图

1.4.2.6. switch基础语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

switch(variable) { 
    case const1:
        statement1;
        break;
    case const2:
        statement2;
        break;   
        … …
    case constN:
        statementN;
        break;
    default:
        statement_dafault;
        break;
} 

程序逻辑：

• 检测某一个变量的值， 从上往下依次与每一个case进行校验、匹配
• 如果变量的值和某一个case后面的值相同，则执行这个case后的语句
• 如果变量的值和每一个case都不相同，则执行default后的语句

1.4.2.7. switch的语法规则

1. 表达式expr的值必须是整型
2. case子句中的值const, 必须是常量值, case中的值不能是一个范围
3. 所有case子句中的值应是不同的,否则会编译出错
4. default子句是可选的（不是必须的）
5. break语句用来在执行完一个case分支后使程序跳出switch语句块；否则会继续执行下去

1.4.2.8. switch基础案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 简单实现switch-case语句
int i = 1;
switch(i){
    case 1:
       cout << "Hello World!" << endl;
        break;
    case 2:
        cout << "Hello World!2" << endl;
    case 3:
        cout << "Hello World3" << endl;
        break;
    default:
        cout << "Haaaa" << endl;
        break;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 判断春夏秋冬
int season = 1;
switch(season){
    case 1:
        cout << "春暖花开" << endl;
        break;
    case 2:
        cout << "闷热" << endl;
        break;
    case 3:
        cout << "秋高气爽" << endl;
        break;
    case 4:
        cout << "滴水成冰" << endl;
        break;
    default:
        cout << "火星的" << endl;
        break;
}

1.4.2.9. switch的穿透性

我们来看一段代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 判断春夏秋冬
int season = 1;
switch(season){
    case 1:
        cout << "春暖花开" << endl;
    case 2:
        cout << "闷热" << endl;
    case 3:
        cout << "秋高气爽" << endl;
    case 4:
        cout << "滴水成冰" << endl;
    default:
        cout << "火星的" << endl;
}

上述代码中， switch结构捕获变量season的值。 变量的值和第一个case是匹配的， 应该输出的结果是 “春暖花开”。 但实际上的输出结果却是从”春暖花开”开始的每一个输出。

因为在switch结构中有“穿透性”。

穿透性:

指的是， 当switch的变量和某一个case值匹配上之后， 将会跳过后续的case或者default的匹配，直接向后穿透。

为了杜绝穿透， 可以使用关键字 break:

1.4.2.10. 合理的使用穿透性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>

using namespace std;

int main() {
    // 输入一个年月日，判断这一天是这一年的第几天
    int year, month, day;
    cout << "请输入一个年:";
    cin >> year;
    cout << "请输入一个月:";
    cin >> month;
    cout << "请输入一个日:";
    cin >> day;

    // 定义变量，记录总天数
    int days = day;

    switch (month) {
        case 12: days += 30;
        case 11: days += 31;
        case 10: days += 30;
        case 9: days += 31;
        case 8: days += 31;
        case 7: days += 30;
        case 6: days += 31;
        case 5: days += 30;
        case 4: days += 31;
        case 3: days += year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ? 29 : 28;
        case 2: days += 31;
    }

    cout << days << endl;

    return 0;
}

1.4.2. 循环结构

1.4.2.1. while循环的基础语法

1
2
3
4
5

// while语句由关键字 while 小括号 大括号 以及相关语句组成
// 基本格式如下：
while (条件表达式) {
	循环体
}

**条件表达式: **循环终止的判断条件语句，要求为布尔表达式，也就是结果为真或假值 比如 i < 10;

**循环体: **n行循环要执行的语句

1.4.2.2. while的结构

流程说明：

1. 执行条件表达式，也就是执行循环终止的判断条件语句，看其结果是true还是false，如果是 false，循环结束，如果是true继续执行
2. 执行循环体语句，也就是执行大括号中的实际代码
3. 回到第一步再次执行，第一到第三步，直到某次第一步表达式结果为false

1.4.2.3. while循环的注意事项

1. while循环本身没有循环变量声明和初始化的组成部份，所以如果有这个需要，应在while循环前声明循环变量并赋值
2. while循环本身也没有控制循环终止的判断条件语句部分，所以需要在循环体中增加相应的控制语句，否则容易死循环

1.4.2.4. while循环案例

1. 打印输出5次，我爱编程，我爱千锋

   1 2 3 4 5 6 7 8 9

   // 初始化部分 int count = 0; // 循环条件 while(count < 5){ // 循环体 cout << "我爱编程，我爱千锋" << endl; // 更新循环变量 count++; }

2. 求 10 的阶乘

   1 2 3 4 5 6 7

   int sum = 1; int i = 1; while(i <= 10){ sum = sum * i; i++; } cout << "10的阶乘: " << sum << endl;

3. 求1-100的和

   1 2 3 4 5 6 7 8

   int i = 1; // 初始化变量 int sum = 0; //保存和 // 循环条件 while(i <= 100){ sum = sum + i; i++; } cout << "1-100的和是: " << sum << endl;

4. 求100以内的偶数的和

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   int z = 2; int sum = 0; while(z <= 100){ sum = sum + z; z += 2; } cout << "1-100的偶数的和是: " << sum << endl; // 或 int z = 1; int sum = 0; while(z <= 100){ if(z % 2 == 0){ sum = sum + z; } z++; } cout << "1-100的偶数的和是: " << sum << endl;

1.4.2.5. do-while循环的基本语法

1
2
3
4
5

// do-while语句由  do关键字 大括号 while关键字 小括号号和相关语句组成
// 基本格式如下:
do {
    循环体
} while (条件表达式);

1.4.2.6. do-while循环的执行结构

1. 执行循环体语句，也就是执行大括号中的实际代码
2. 执行条件表达式，也就是执行循环终止的判断条件语句，看其结果是true还是false，如果是 false，循环结束，如果是true 继续执行
3. 回到第一步再次执行第一到第三步，直到某次第一步表达式结果为false

1.4.2.7. do-while循环的特点和注意事项

1.do-while循环为先执行后判断，也就是先执行一次循环体中的代码，然后再检查条件表达式，所以do-while循环至少会执行一次

2.其它特点和while循环一样

1.4.2.8. do-while循环练习

1. 打印三次helloworld

   1 2 3 4 5 6 7 8

   // 1 初始化部分 int i = 0; do{ // 2 循环体 cout << "Hello World!" << endl; // 4 循环变量变化部分 i++; }while(i < 3);// 3 循环条件

2. 用do/while实现打印100以内的奇数

   1 2 3 4 5

   int j = 1; do{ cout << j << endl; j += 2; } while (j < 100);

3. 100 以内能够被3整除，但是不能被5整除的数打印输出

   1 2 3 4 5 6 7

   int z = 3; do{ if(z % 3 == 0 && z % 5 != 0){ cout << z << endl; } z++; }while(z<=100);

1.4.2.9. for循环的基础语法

1
2
3
4
5

// for语句由关键字for、小括号、大括号以及相关语句组成
// 基本格式如下
for(循环起点; 循环条件; 循环步长) {
    循环体
}

循环起点: 循环变量初始化语句，比如 int i = 0;

循环条件: 循环终止的判断条件语句，要求为布尔表达式，也就是结果为真或假值 比如 i < 10;

循环步长: 循环改变的控制条件语句，比如 i++

循环体: 循环要执行的语句

三个表达式之间用分号分隔

1.4.2.10. for循环的结构图

流程说明：

1. 执行循环起点，也就是执行循环变量初始化语句
2. 执行判断条件，也就是执行循环终止的判断条件语句,看其结果是true还是false
   如果是 false，循环结束。
   如果是 true，继续执行第三步。
3. 第三步:执行循环体语句，也就是执行大括号中的实际代码
4. 第四步:执行表达式3，也就是执行循环改变的控制条件语句，使循环变量的值发生改变
5. 第五步:回到第二步再次执行第二到第五步，直到第二步的表达式结果为false，循环结束

1
2
3
4
5
6
7
8
9
10
11

//实操代码
for(int i = 0; i < 10; i++){
  cout << "当前循环变量的值是" << i << endl;
}
/*
第一步：执行 int i=0;
第二步：执行 i<10;(此时 i值为0) 结果为true,所以程序继续执行第三步
第三步：执行 cout << "当前循环变量的值是" << i << endl; 打印输出
第四步：执行 i++ (执行后 i值为 1)
第五步：执行（回到第二步执行）i<10;(此时 i值为1) 表达式结果依然为 true,所以程序继续（执行三到五步，直到某次第二步的语句结果为false ,程序结束）
*/

1.4.2.11. for循环基础案例

1. 打印输出3次helloworld

   1 2 3

   for(int i = 0; i < 3; i++) { cout << "Hello World!" << endl; }

2. 打印100以内，能被4整除不到能被7整除的数据，每行打印6个

   1 2 3 4 5 6 7 8 9 10

   int count = 0; for(int i = 1; i <= 100; i++) { if(i % 4 == 0 && i % 7 != 0){ cout << i << "\t"; count++; if(count % 6 == 0) { cout << "\n"; } } }

3. 打印1到100的所有整数

   1 2 3 4

   //注意 正常循环变量初值一般为0，这里从1开始，结束条件是否包括等于，需要根据实际需求决定 for(int i = 1 ; i <= 100 ; i++){ cout << "整数值:" << i << endl; }

4. 计算1+2+3+…+100的和

   1 2 3 4 5 6

   //注意 正常循环变量初值一般为0，这里从1开始，结束条件是否包括等于，需要根据实际需求决定 int sum = 0; for(int i = 1 ; i <= 100 ; i++){ sum += i; } cout << "1到100的所有整数和为:" << sum << endl;

5. 统计1到100之间分别能被3整除或5整除或同时被3和5整除的数字个数并打印

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   #include <iostream> #include <sstream> using namespace std; int main() { // 记录能被3整除的数字个数、能被5整除的数字个数、能被3和5整除的数字个数 int count3 = 0, count5 = 0, count35 = 0; // 使用字符串流记录能被3整除的数字、能被5整除的数字、能被3和5整除的数字 ostringstream oss3, oss5, oss35; // 循环遍历数字 for (int n = 1; n <= 100; n++) { if (n % 3 == 0 && n % 5 == 0) { count35++; oss35 << n << ", "; } else if (n % 3 == 0) { count3++; oss3 << n << ", "; } else if (n % 5 == 0) { count5++; oss5 << n << ", "; } } cout << "能被3整除，不能被5整除的数字有" << count3 << "个" << endl; cout << "分别是: " << oss3.str() << endl; cout << "能被5整除，不能被3整除的数字有" << count5 << "个" << endl; cout << "分别是: " << oss5.str() << endl; cout << "能同时被3和5整除的数字有" << count35 << "个" << endl; cout << "分别是: " << oss35.str() << endl; return 0; }

6. 打印九九乘法表

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   // 九九乘法表 共有45个结果，所以需要循环45次 第一行输出一个结果，第二行输出二个结果，...第九行输出九个结果 // 用来记录当前行号 int row = 1; // 用来记录当前列号（也就是当前行的第几个结果） int col = 1; for (int i = 0; i < 45 ; i++) { //输出row行的第col个结果,不换行 cout << col << " x " << row << " = " << (col*row); //同一行中多个结果之间的分隔符 cout << "\t"; //如果行号和列号相等，说明第row行已打印完成 if(row == col){ //打印换行符 cout << endl; //列号重置 col = 1; //行号加1 row++; } else{ //列号加1 col++; } }

7. 判断指定的数字是否是质数并输出

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   // 用来记录是否是质数的布尔变量 false 就是质数 bool flag = false; // 需要判断的数字，实际可由用户通过键盘输入 int checkNumber = 100; // 循环判断当前数字是否能被1和它本身外的数字整除 for(int i = 2; i < checkNumber; i++){ // 如果能被整除，说明不是质数 if(checkNumber % i == 0){ // 设置标质不是质数 flag = true; } } //根据标记变量的真假，直接输出结果 cout << "整数" << checkNumber << (flag?"不是质数":"是质数") << endl;

1.4.2.12. for循环的特殊用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//第一种，将表达式一省略，放到循环前面
int i = 0;
for(; i < 10; i++){
    cout << "当前循环变量的值是" << i << endl;
}
//第二种，将表达式3省略，放到循环体中
int i = 0;
for(; i < 10;){
    cout << "当前循环变量的值是" << i << endl;
    i++;
}
//第三种，将表达式1，2，3全部省略 此种为死循环，一般需要在循环体中给出结束条件
for( ; ; ){
    cout << "当前循环变量的值是" << i << endl;
}

1.4.2.13. 流程控制关键字break

1
2

1. 作用：break语句用于终止某个语句块的执行
2. 用法：如果是循环中，作用为跳出所在的循环，如果是在switch语句中，则为跳出所在的switch语句

跳出break语句所在的循环

1
2
3
4
5
6
7
8

for (int i = 1; i < 3 ; i++ ) {
    for (int j = 1; j< 5 ;j++ ) {
        if(j == 2){
            break;// 跳出内层循环，进行下一次外层循环
        }
        cout << i << " " << j << endl;
    } 
}

1.4.2.14. 流程控制关键字continue

1
2

1. 作用：跳过本次循环，执行下一次循环（如果有多重循环，默认继续执行离自己最近的循环）提前终止本次循环
2. 使用：只能在循环结构中使用

当 j==2时，跳过本次循环，不进行打印输出

1
2
3
4
5
6
7

for (int j = 1;j<4 ;j++ ){
    if(j==2){
        continue;
    }
    System.out.println("i="+i + "  j="+j);
}
System.out.println("Hello World!");

1.4.2.15. 流程控制关键字goto

1

在程序中，可以任意的设置“标签”，使用关键字goto可以直接跳转到指定的标签位置继续执行程序！

1
2
3
4
5
6
7
8
9

label1:
cout << "1" << endl;
goto label3;

label2:
cout << "2" << endl;

label3:
cout << "3" << endl;

1
2
3
4
5
6
7
8
9
10

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < i; j++) {
        cout << "i = " << i << ", j = " << j << endl;
        if (i == 4 && j == 3) {
            goto label1;
        }
    }
}
label1:
cout << "end" << endl;

1.4.2.15. 多重循环

1. 概念：多重循环就是指 在循环内嵌套其它循环，和选择语句嵌套类似，嵌套几层就是几重循环，最常见的为双重和三重
2. 说明：外层循环执行一次，它的内层循环执行一轮（也就是内循环正常循环一遍结束）

1
2
3

第一步: 从外层循环开始执行 先执行一次进入循环体（里面包括内层循环）
第二步: 遇到内层循环，开始正常执行，直到内循环循环结束
第三步: 继续外循环的下一次循环（回到第一步）

1. 用双重循环实现九九乘法表的打印

   1 2 3 4 5 6

   for (int i = 1; i <=9 ; i++) { for (int j = 1; j <=i ; j++) { cout << j << "x" << i << "=" << (i*j) << "\t"; } cout << endl; }

2. 打印直角三角形

   1 2 3 4 5 6

   for (int i = 1;i<=5 ;i++ ){ for (int j = 1;j<=i ;j++ ){ cout << "*" << endl; } cout << endl; }

3. 打印等腰三角形

   1 2 3 4 5 6 7 8 9

   for (int i = 1;i<=5 ;i++ ){ for(int k=1;k<=5-i;k++){ cout << " "; } for (int j = 1;j<=i*2-1 ;j++ ){ cout << "*"; } cout << endl; }

4. 求1000以内的完数

   1 2 3 4 5 6 7 8 9 10 11 12

   //完数定义：若一个自然数，恰好与除去它本身以外的一切因数的和相等，这种数叫做完全数。例如，6=1+2＋3 for (int i=2;i<1000;i++){ int sum=0; for (int j=1;j<i;j++){ if (i%j==0){ sum+=j; } } if (sum==i){ cout << "1000之内的完整数：" << i << endl; } }

1.5. 函数

1.5.1. 函数的介绍

1.5.1.1. 函数的概念

函数，指一段可以直接被另一段程序或代码引用的程序或代码。一个较大的程序一般应分为若干个程序块，每一个模块用来实现一个特定的功能。所有的高级语言中都有子程序这个概念，用子程序实现模块的功能。

面向过程语言中，整个程序就是由函数（相互调用）组成的

面向对象语言中，函数是类的组成部份，整个程序是由很多类组成的

通俗讲，函数就是解决某件事情的办法，比如 我要上班，可以选择 步行，骑车，开车，公共交通，而每一个方式，在程序中就可能是一个函数。

1.5.1.2. 函数的组成

函数的组成要素：****返回值、函数名、参数、函数体

1.5.1.3. 使用函数的好处

1. 使程序变得更简短清晰
2. 有利于程序的维护（修改）
3. 可以提高开发效率
4. 可以提高代码的重用性

1.5.2. 函数的基础使用

1.5.2.1. 函数的定义

1
2
3
4
5
6
7
8

// 函数定义的基础语法是：
返回值类型 函数名字(参数列表) {
    函数体
}
// 返回值类型: 表示函数执行的结果，在返回值部分详解，暂时写void
// 函数名字: 遵循标识符的命名规则
// 参数列表: 定义若干个参数的部分，在参数部分详解，暂时不写
// 函数体: 函数的功能实现，在这里也业务逻辑代码

1
2
3

void sayHello() {
    cout << "Hello!" << endl;
}

1.5.2.2. 函数的调用

函数在定义完成之后，其中的代码并不会自动的执行。如果我们需要执行函数中定义的代码，需要“调用”这个函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
using namespace std;

// 定义一个函数，打印九九乘法表
void sayHello() {
    for (int i = 1; i <=9 ; i++) {
        for (int j = 1; j <=i ; j++) {
            cout << j << "x" << i << "=" << (i*j) << "\t";
        }
        cout << endl;
    }
}

int main() {
    // 我们已经定义了一个函数，来打印九九乘法表，但是这个函数中的代码不会自动执行的，需要我们调用函数。
    // 通过函数的名字来调用函数
    sayHello();
    return 0;
}

1.5.2.3. 函数调用的顺序

函数中，除了能进行我们的业务逻辑实现之外，还可以再调用其他的函数。而在新调用的函数中，又可以调用另外的函数。那么，函数在多次调用的时候，应该按照什么样的顺序去执行呢？我们以下方代码为例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void print1() {
    cout << 1 << endl;
    print2();
}

void print2() {
    print(3);
    cout << 2 << endl;
}

void print3() {
    cout << 3 << endl;
}

int main() {
    cout << "start..." << endl;

    print1();

    cout << "end" << endl;
}

函数的执行，需要压到栈中去执行。

这种结构的特点是: “先进先出”

也就是先调用的函数，在栈的底部存放。而新调用的函数，会在栈的顶部存放。程序先处理栈顶的函数中的逻辑，因此最新调用的函数中的内容会执行。

1
2
3
4
5
6

上述代码的执行结果是：
start...
1
3
2
end

1.5.2.4. 参数的介绍

我们已经知道了函数是什么以及应该如何定义，也已经把部分逻辑代码段封装进了一个函数中。我们什么时候需要使用这个逻辑代码段，直接调用函数即可。

但是，有时候我们在调用函数，执行这段逻辑代码的时候，是需要有一些数据传入的。调用方必须传入指定的数据，才能够完成对应的功能。那么在这种情况下，我们应该怎么做？

1
2
3

例如: 
ATM取款机，封装了取钱的功能。我们在需要取钱的时候，将银行卡插入ATM取款机，输入密码之后就可以取钱了。
在这个功能实现中，ATM就类似一个函数，为我们封装了一个逻辑代码段，提供了指定的功能。但是，也需要我们有对应的数据传入。比如，我们需要告诉这个ATM取款机，银行卡是哪个？密码是多少？我需要取多少钱等信息。

我们如果需要将函数之外的一些数据，带入到函数的内部，最常见的做法就是通过****参数来实现。

1.5.2.5. 参数的定义

参数，其实就是一个变量。只不过，这个变量和我们之前学习的变量有不一样的地方:

1. 定义的位置不同: 参数是定义在函数的参数列表小括号中的。
2. 明确数据的类型: 即便是相同类型的参数，我们也需要为每一个参数明确自己的类型，不能省略类型。

1
2
3

void add(int num1, int num2) {
    cout << "num1 = " << num1 << ", num2 = " << num2 << ", num1 + num2 = " << (num1 + num2) << endl;
}

1.5.2.6. 有参函数的调用

调用函数的时候，我们通过函数的名字添加小括号的方式来调用。但是，如果这个函数是有参数的函数，那么在调用的时候必须要明确参数的值是什么。这就类似于每一个变量必须要有值才能够使用。

调用函数的时候，必须为每一个参数进行赋值

• 将需要给参数赋的值，直接写在调用时候的小括号内即可
• 小括号内的值的数量，需要与定义时候的数量相同
• 小括号内的值的数据类型，需要与定义时候的数据类型一致
• 小括号内的值，会依次的赋值给每一个参数

1
2
3
4
5
6
7
8
9
10
11
12

// 定义了一个带有参数的函数
void cal(const int num1, int num2) {
    cout << "num1 = " << num1 << ", num2 = " << num2 << ", num1 + num2 = " << (num1 + num2) << endl;
}

int main() {
	// 调用函数的时候，就需要带上参数
    cal(100, 200);
    cal(1000, 2000);

    return 0;
}

1.5.2.7. 几个关键名词

• **形参: **在定义函数的时候，小括号中定义的参数。由于这样的参数只有形式上的定义，并没有具体的值，因此被称为形式参数。
• 实参: 在调用函数的时候，小括号中定义的参数。由于这样的参数，为形参提供了确切的值。因此将这样的参数叫做实际参数。
• **传参: **在调用函数的时候，用实参给形参赋值，这样的过程叫做传参。

1.5.2.8. 返回值的介绍

在我们之前定义的函数中，可以通过****参数将函数外的数据传递到函数的内部，那么有没有发现函数变得灵活点了呢？但是现在还有一个问题: 我们如何将函数内的数据传递到函数的外部呢？？

函数，其实就是对一段逻辑功能的封装。例如: 我封装了一个函数，用来计算两个数字的差值绝对值。那么需要计算的两个数字，我可以使用参数传递到函数的内部，可是计算出来的差值绝对值，我应该怎么样传递出去呢？？这就需要借助****返回值来实现了。

1

前面在讲参数的时候，提到了一个ATM取款机的例子。我们将银行卡作为参数传递到了ATM取款机里面，在我们进行了取款的操作之后，ATM也需要将我们需要的结果（取到的钱）返回给我们。这就是将数据从函数内传递到函数的调用方那里，需要借助返回值来实现。

返回值，表示的是一个函数执行结束之后，得到的结果。

1.5.2.9. 有返回值的函数定义

1
2
3
4

// 设计一个函数，计算一个数字的绝对值
int abs(int number) {
    return number > 0 ? number : -number;
}

1.5.2.10. return关键字

在函数中，return是一个非常重要的关键字！有两种作用:

1. 后面跟上某一个值，作为一个函数的执行结果，也就是返回值。
2. 结束一个函数的执行。

注意事项:

1. 在返回值类型不是void的函数中，函数执行结束之前，必须要使用return明确的返回一个结果。
2. 在返回值类型是void的函数中，仍然可以使用return关键字，此时仅表示结束函数的执行。

1.5.3. 函数的高阶使用

1.5.3.1. 函数的参数默认值

在定义参数的时候，我们可以给参数一个默认的值，例如:

1
2
3

int add(int num1, int num2 = 100) {
    return num1 + num2;
}

此时在调用函数的时候，因为num2是有默认值的，因此可以给num2设置实参，也可以不设置

1
2
3
4
5
6

int main() {
    // 给num2实参，此时的num2的值就是实参给定的值
    cout << add(100, 200) << endl;
    // 不给num2实参，此时的num2的值就是默认值
    cout << add(100) << endl;
}

但是需要注意，有默认值的参数，必须放到参数列表的末尾。

1
2
3
4
5
6
7
8

// 这个是正确的
void cal(int num1 = 10, int num2 = 20) {}

// 这个是正确的
void cal(int num1, int num2 = 10) {}

// 这个是错误的！！！
void cal(int num1 = 10, int num2) {}

1.5.3.2. 函数的重载

如果在一个类中的多个函数，满足如下两点，则这两个函数就构成了重载关系(Overload)

1. 函数名相同
2. 参数不同

   参数的不同，体现在数量不同、类型不同上。

注意: 重载只与函数的名字、参数有关系，****与返回值没有关系！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 重载函数的定义
int add(int num1, int num2) {
    return num1 + num2;
}
double add(int num1, double num2) {
    return num1 + num2;
}
double add(double num1, int num2) {
    return num1 + num2;
}
double add(double num1, double num2) {
    return num1 + num2;
}

int main() {

    // 区分调用不同的重载方法，应该从实参入手
    cout << add(10, 20) << endl;		// 调用的是add(int, int)的方法 
    cout << add(10, 11.3) << endl;		// 调用的是add(int, double)的方法
    cout << add(11.2, 10) << endl;		// 调用的是add(double, int)的方法
    cout << add(11.1, 22.2) << endl;	// 调用的是add(double, double)的方法

    return 0;
}

有了函数的重载，可以使得我们的程序更加的灵活！

1.5.3.3. 函数的递归

递归，是一种程序设计的思想。在解决问题的时候，可以将问题拆分成若干个小问题。这些小问题的解决方式，与大的问题解决方式相同。通过解决这些小的问题，逐渐解决这个大的问题。那么什么情况下可以使用递归呢？

• 当需要解决的问题可以拆分成若干个小问题，大小问题的解决方法相同。
• 有固定规律，方法中调用自己。

那我们应该如何正确的使用递归呢？

递归，由于涉及到方法的循环调用，因此容易出现死递归的情况。即所有的方法调用没有出口，只能将方法压栈执行，但是无法结束方法。因此，在使用递归的时候，需要设置有效的出口条件，避免无穷递归。

1
2
3
4
5
6

int multiply(int num) {
    if (num == 1) {
        return 1;
    }
    return num * multiply(num - 1);
}

1.5.3.4. 调用其他文件中的函数

我们程序中默认只能调用当前文件中定义的函数，但是一个大型的项目不止由一个文件来组成，很多时候是需要跨文件来调用、访问的。例如，我们将常用的数学计算的功能定义在某一个文件中，那么如何调用这个文件中定义的函数呢？

首先我们需要知道，.cpp文件中的内容是无法跨文件直接访问的，如果我们需要让某一个函数跨文件访问，需要为其定义一个 .h文件，我们称为“头文件”。在头文件中添加函数的声明部分即可。需要使用的时候，直接使用#include来包含指定的头文件即可完成。

1
2
3

// 文件名: qfmath.h
int abs(int num);
int add(int num1, int num2);

1
2
3
4
5
6
7
8
9
10
11
12

// 文件名: qfmath.cpp
int abs(int num) {
    return num >= 0 ? num : -num;
}

int add(int num1, int num2) {
    return num1 + num2;
}

void test() {
    cout << "this is a test method" << endl;
}

1
2
3
4
5
6
7
8
9
10
11

// 文件名: other.cpp
#include <iostream>
#include "qfmath.h"		// 包含用户自己定义的头文件，只能使用双引号，不能使用尖括号

int main() {
    // 此时可以直接使用qfmath.h中定义的方法，实现部分写在了qfmath.cpp文件中
    cout << abs(-10) << endl;
    cout << add(10, 20) << endl;
    // 由于qfmath.h中并没有定义test方法，因此无法在这里调用test方法
    return 0;
}

1.5.4. 函数的练习

1. 设计方法，计算两个日期之间相差多少天。两个日期的年月日由参数控制。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

   // 设计方法，计算两个日期之间相差多少天。两个日期的年月日由参数控制。 int getDelta(int fromYear, int fromMonth, int fromDay, int toYear, int toMonth, int toDay) { // 1、起始那一天，是fromYear的第几天 // 2、终止那一天，是toYear的第几天 // 3、计算 fromYear的1月1日 ~ toYear的1月1日相差多少天 // 4、 3 + 2 - 1 int fromDays = getDays(fromYear, fromMonth, fromDay); int toDays = getDays(toYear, toMonth, toDay); int days = 0; for (int y = fromYear; y < toYear; y++) { days += check(y) ? 366 : 365; } return days + toDays - fromDays; } // 计算一个日期是当年的第几天 int getDays(int year, int month, int day) { int days = day; for (int m = 1; m < month; m++) { if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12) { days += 31; } else if (m == 4 || m == 6 || m == 9 || m == 11) { days += 30; } else if (m == 2) { days += check(year) ? 29 : 28; } } return days; } // 验证一个年份是不是一个闰年 static boolean check(int year) { return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; }

2. 开发一个标题为“FlipFlop”的游戏应用程序。它从 1 计数到 100，遇到 3 的倍数就替换为单词“Flip”，5 的倍数就替换为单词“Flop” ，既为 3 的倍数又为 5 的倍数则替换为单词“FlipFlop”

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   void flipFlop() { for (int i = 1; i <= 100; i++) { if (i % 3 == 0 && i % 5 == 0) { cout << "FlipFlop" << endl; } else if (i % 3 == 0) { cout << "Flip" << endl; } else if (i % 5 == 0) { cout << "Flop" << endl; } else { cout << i << endl; } } }

3. 两个自然数X，Y相除，商3余10，被除数、除数、商、余数的和是163，求被除数、除数。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   void test() { for (int x = 0; x < 163; x++) { for (int y = 1; y < 163; y++) { // 求商 int s = x / y; // 求余 int l = x % y; if (s == 3 && l == 10 && (x + y + s + l == 163)) { cout << "x = " << x << ", y = " << y << endl; } } } }

4. 使用递归计算1+2+3+…+100的和

   1 2 3 4 5 6

   int sum(int num) { if (num == 1) { return 1; } return num + sum(num - 1); }

5. 使用递归输出30位的斐波那契数列

   1 2 3 4 5 6

   int getFibonacci(int index) { if (index == 1 || index == 2) { return 1; } return getFibonacci(index - 1) + getFibonacci(index - 2); }

1.6. 指针与引用

1.6.1. 内存分析

1.6.1.1. 内存分区

程序在执行的时候，会在内存中开辟一些空间，存储一些数据。而内存又可以分为四个分区:

• 栈区
• 堆区
• 全局区
• 代码区

1.6.1.2. 各分区作用

• 代码区

  1 2	存放程序编译之后生成的二进制代码，例如我们写的函数，就是存储在这里的。 PS: 函数在程序编译之后，存储于代码区。调用函数的时候，会压到栈区执行其中的代码。

• 全局区

  1	全局区内的变量在程序编译阶段已经分配好内存空间并初始化。这块内存在程序的整个运行期间都存在，主要存放静态变量、全局变量和常量。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

  #include <iostream> using namespace std; // 定义全局变量 int g_num1 = 100; // 定义全局常量 const int g_num2 = 100; // 定义全局静态变量 static int g_num3 = 100; // 定义全局静态常量 static const int g_num4 = 100; int main() { // 定义局部变量 int num1 = 10; // 定义局部常量 const int num2 = 10; // 定义局部静态变量 static int num3 = 10; // 定义局部静态常量 static const int num4 = 10; cout << &g_num1 << endl; // 全局区 cout << &g_num2 << endl; // 全局区 cout << &g_num3 << endl; // 全局区 cout << &g_num4 << endl; // 全局区 cout << &num1 << endl; // 栈区 cout << &num2 << endl; // 栈区 cout << &num3 << endl; // 全局区 cout << &num4 << endl; // 全局区 return 0; }

• 栈区

  1	由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自行释放栈区内存，不需要用户管理。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream> using namespace std; int* getNumber() { int number = 100; cout << "&number = " << &number << endl; return &number; } int main() { int* p = getNumber(); cout << "p = " << p << endl; cout << "*p = " << *p << endl; return EXIT_SUCCESS; }

• 堆区

  1	由编程人员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  #include <iostream> using namespace std; int* getNumber() { int* number = new int(100); cout << "number = " << number << endl; return number; } int main() { int* p = getNumber(); cout << "p = " << p << endl; cout << "*p = " << *p << endl; return EXIT_SUCCESS; }

1.6.1.3. 内存中的数据残留

1
2
3
4

我们在硬盘上存储了很多的数据，假如你不小心误删除了一个数据文件，想要恢复。你请教了身边的大神，怎么恢复这些数据啊？大神跟你说，你可以借助一些数据恢复的工具进行操作，但是从现在开始，不要再使用这个硬盘了！
为什么大神不让你再用这个硬盘了呢？？
原因在于，其实我们所谓的“删除数据”，删除的只是你对指定地址范围空间的“使用权”，你不能够再去使用这块空间了，但是这块空间中原来的内容是不会被删除掉的！所谓的数据恢复的软件就是帮你找到之前你使用的这个空间的地址范围是什么，然后读取这里的内容即可。但是为什么误删除掉数据之后，你就不能再使用这个硬盘了呢？
如果你再次使用这个硬盘去存储文件，新的文件需要开辟一块空间来存储吧，那么就有可能存储在你之前释放的那一部分，而此时新的数据文件会将你原来的数据文件给覆盖掉，这个时候，你再想找回原来的数据，难度就非常大了！

通过上述案例我们知道，其实所谓的“删除”，只是释放掉了你对某一块空间的使用权。在硬盘上是这样的，在内存中也是如此。我们定义了一个变量，此时会在内存中开辟了一块空间出来。那么这个空间中还残留着之前的数据呢！

1
2
3
4
5
6
7
8
9

int main() {
    int a;
    cout << a << endl;	// 是不是发现一些很奇怪的值？
    // 局部变量a是在栈空间中开辟，栈空间内存不需要我们手动管理，开辟新的空间的时候，也不会进行初始化的操作。

    int* p = new int();
    cout << *p << endl;	// 此时可以看到是0
    // new表示在堆空间中开辟内存，同时会进行初始化操作，将这块内存中原来的值给覆盖掉，初始化为0。
}

1.6.2. 指针的介绍

我们在前面的代码中定义了一些变量，其实定义变量就是在内存中开辟了一块指定大小的空间，空间开辟的大小取决于不同的数据类型所占用的空间大小。并且可以在这样的空间中进行值的填充。那么指针是什么呢？每一个开辟中的内存空间，都是有一个唯一的地址的，而这样的地址我们就称为是“指针”。

1
2
3
4
5
6
7
8
9
10
11

如果我们把计算机的内存比作是一个酒店，在这个酒店中有很多的房间，这些房间有不同的类型，有标准间、大床房、套房、亲子房等等，每一个房间也都起了自己的名字，例如听云轩、风雅阁等，每一个房间也都有自己的门牌号，例如1001、1202等，每一个房间中也都住有不同的客人。
在这里我们做一个类比：
酒店			计算机内存
房间			内存中开辟的一块空间
房间的名字	  变量的名字
房间门牌号	  内存的地址（指针）
房间的住客	  空间中存储的值，也就是这个变量的值

例如: int number = 10;
这段代码执行的时候，会在内存中开辟出4字节的空间，命名为number，这个空间中存储的值为10
而指针是什么呢？指针就是number的内存地址，也就是这个酒店房间的门牌号

1.6.3. 指针变量的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 定义了一个int类型的变量num，值为100
// 也就是在内存中开辟了一个4字节的空间，存储的值为100
int num = 100;

// 那么，num的地址怎么获取呢？
// &num 就可以获取到变量num的地址！
// 那么，这个地址应该用什么类型的变量来接收呢？
int* p = #

// 我们可以直接输出指针类型的变量p中存储的内存地址
cout << p << endl;	// 输出的就是一个内存地址，一般是用一个十六进制的数字来表示

// 那么我们如何通过这个地址来找到它指向的空间呢？
// *p
cout << *p << endl;	// 输出的就是指针变量p中存储的地址所指向的空间中存储的值！也就是变量num的值！

1.6.4. 空指针与野指针

1.6.4.1. 空指针

空指针，指的是没有存储任何内存地址的指针变量，一般使用NULL来表示一个空的地址。通常情况下，使用空指针可以对指针变量进行初始化。

1
2
3
4
5

int* p = NULL;		// 这里的指针变量p没有存储任何的地址，就是一个空指针。

// 设置为NULL的指针变量，存储的地址其实是0，但是地址0到255的内存为系统内存，不允许访问
// 因此这里会出现“读取访问权限”的问题
cout << *p << endl;

1.6.4.2. 野指针

野指针中存储有一个内存地址，但是这个地址指向的空间已经不存在了。在这种情况下，这个指针变量中存储的地址已经没有什么意义了，这样的指针称为野指针。

1
2
3
4

// 这里定义了一个指针变量，随便写了一个地址，这个地址对应的空间极有可能是不存在的
int* p = (int*)0x1234;
// 访问野指针，也是会出现问题的
cout << *p << endl;

1.6.5. 常量指针与指针常量

• 常量指针
  • const放在*之前，表示常量指针，即常量的指针
  • 指针的指向是可以修改的，但是不能通过指针来修改指向空间的值
• 指针常量
  • const放在*之后，表示指针常量，即指针是一个常量值
  • 可以通过指针来修改指向空间的值，但是不能修改指针的地址指向

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int num1 = 100;
int num2 = 200;

// const放在*之前，表示常量指针，即常量的指针
// 指针的指向是可以修改的，但是不能通过指针来修改指向空间的值
const int* p1 = &num1;
p1 = &num2;
// *p1 = 200;

// const放在*之后，表示指针常量，即这个指针是一个常量
// 可以通过指针修改指向空间的值，但是指针的指向是不可以修改的
int* const p2 = &num1;
// p2 = &num2;
*p2 = 300;

1.6.6. 指针在函数中的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>

using namespace std;

void changeNumber(int number) {
    number = 100;
}

void changeNumber(int* number) {
    *number = 100;
}

int main() {

    int num = 10;

    // 这里是值传递，传递到函数changeNumber中的是10，因此在函数中修改参数number的值，对这里的变量num没有影响
    changeNumber(num);
    cout << "num = " << num << endl;

    // 这里是地址传递，传递到函数changeNumber中的是变量num的地址，在函数中通过地址修改指向空间的值，这里的num会受到影响
    changeNumber(&num);
    cout << "num = " << num << endl;

    return 0;
}

1.6.7. 引用的介绍

变量名实质上是一段连续内存空间的别名，是一个标号(门牌号)，程序中通过变量来申请并命名内存空间，通过变量的名字可以使用存储空间。

对一段连续的内存空间只能取一个别名吗？

c++中新增了引用的概念，引用可以作为一个已定义变量的别名。

**基本语法: **

Type& ref = val;

注意事项：

• &在此不是求地址运算，而是起标识作用。
• 类型标识符是指目标变量的类型
• 必须在声明引用变量时进行初始化。
• 引用初始化之后不能改变。
• 不能有NULL引用。必须确保引用是和一块合法的存储单元关联。
• 可以建立对数组的引用。

1.6.8. 引用的基础使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int main() {
    // 定义一个整型变量
    int num = 10;
    // 定义一个num的引用（起一个别名）
    int& a = num;

    // 比较值
    cout << "num = " << num << ", a = " << a << endl;

    // 比较地址，可以看到地址是完全相同的，也就是指向的同一块空间
    cout << "&num = " << &num << ", &a = " << &a << endl;

    // 因为指向的是同一块空间，因此对任意一个的修改，都会影响到另外的一个
    num = 200;
    cout << "num = " << num << ", a = " << a << endl;
}

1.6.9. 引用在函数中的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19