C++学习笔记1

---

0 前言

C++是一种面向对象的程序设计语言，包括面向对象开发的四大特性：封装、抽象、继承、多态。C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互：

• 对象具有状态和行为。对象是类的实例。
• 类可以定义为描述对象行为与状态的模板。
• 方法表示一种行为。一个类可以包含多个方法。
• 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。

在 C++ 中，分号是语句结束符——每个语句必须以分号结束，以表明一个逻辑实体的结束。C++ 不以行末作为结束符的标识，因此可以在一行上放置多个语句，可以根据需要在代码中适当增加一些空格。除此之外，包含注释将提高源代码的可读性。注释一般有两种：

• //一般用于单行注释。

• /* ... */一般用于多行注释。

---

1 数据类型

下表列出了几种基本的 C++ 数据类型：

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void

默认情况下，int、short、long都是带符号的(signed)。

可以使用 typedef 为一个已有的类型取一个新的名字。下面是示例代码：

typedef int my_int;

现在，下面的声明是完全合法的，它创建了一个整型变量 line：

my_int line;

本文不介绍枚举类型，请另寻资料进行学习。

---

2 变量作用域

作用域是程序的一个区域，一般来说有三个地方可以定义变量：

• 在函数或一个代码块内部声明的变量，称为局部变量——只能被函数内部或者代码块内部的语句使用。
• 在函数参数的定义中声明的变量，称为形式参数。
• 在所有函数外部声明的变量(通常是在程序的头部)，称为全局变量。全局变量的值在程序的整个生命周期内都是有效的，且在整个程序中都是可用的。下面的实例使用了全局变量和局部变量：

#include<iostream>
using namespace std;
int a; //全局变量
int main() {
	int d=9; //局部变量
	return 0;
}

在程序中，局部变量和全局变量的名称可以相同，但是在函数内部中局部变量的值会覆盖全局变量的值。当局部变量被定义时，系统不会对其初始化，必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：

数据类型	初始化默认值
int	0
char	‘\0’
float	0
double	0
pointer	NULL

---

3 常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数，如：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。浮点常量由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。带符号的指数是用 e 或 E 引入的。

布尔常量共有两个，它们都是标准的 C++ 关键字(注意是小写的单词)：

• true 值代表真。
• false 值代表假。

字符常量被括在单引号中，可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’)。下表列出了一些转义序列码：

转义序列	含义
\\	\ 字符
\'	’ 字符
\"	" 字符
\?	? 字符
\a	警报铃声
\b	退格键
\f	换页符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

字符串字面值或常量是括在双引号""中的。一个字符串一般包含多个字符：普通的字符、转义字符序列和通用的字符。

有两种简单的定义常量的方式：

1、使用 #define 预处理器。示例代码如下：

#define LENGTH 10;

2、使用 const 关键字。示例代码如下：

const int WIDTH=5;

注意：一般把常量定义为大写字母形式。

---

4 修饰符类型

C++ 允许在 char、int 和 double 数据类型前放置修饰符，用于改变基本类型的含义。下面列出了数据类型修饰符：

• signed
• unsigned
• long
• short

上面四个修饰符均可应用于整型，除此之外signed 和 unsigned 可应用于字符型，long 可应用于双精度型。修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数，即可以不写 int，只写单词 unsigned、short 或 long，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量：

unsigned x;
unsigned int y;

下面的代码演示了有无符号整数之间的区别：

#include <iostream>
using namespace std;

int main() {
    short int i; //有符号短整数
    short unsigned int j; //无符号短整数
    j = 50000;
    i = j;
    cout << "i=" << i << endl;
    cout << "j=" << j << endl;
    return 0;
}

输出如下：

i=-15536
j=50000

上述结果中，无符号短整数 50000 的位模式被解释为有符号短整数 -15536。

---

5 存储类

存储类定义 C++ 程序中变量/函数的范围(可见性)和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto，从 C++ 17 开始不再是 C++ 存储类说明符；
• register， 从 C++ 17 开始被弃用；
• static；
• extern；
• mutable；
• thread_local (C++11)。

下面只介绍static：

1、使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

2、使用 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

3、当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享(我不太懂这句话)。

---

6 运算符

C++提供了以下类型的运算符：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 杂项运算符

6.1 算术运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

6.2 关系运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

6.3 逻辑运算符

假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都 true，则条件为 true。	(A && B) 为 false。
||	称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。	(A || B) 为 true。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false。	!(A && B) 为 true。

6.4 位运算符

位运算符作用于“位”，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

• A = 0011 1100
• B = 0000 1101

则有：

• A&B = 0000 1100=12
• A|B = 0011 1101=61
• A^B = 0011 0001=49
• ~A = 1100 0011=-61

除了上面的位运算符外，还有：

运算符	描述	实例
<<	二进制左移运算符。将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃，右边补0)。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。	A >> 2 将得到 15，即为 0000 1111

6.5 赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A

6.6 杂项运算符

运算符	描述
sizeof	sizeof 运算符返回变量的大小。例如，若a 是整数，则sizeof(a) 将返回 4。
Condition ? X : Y	条件运算符。如果 Condition 为真，则值为 X；否则值为 Y。
,	逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。如：int j = (5, 6, 7);时，j=7。
.(点)和 ->(箭头)	成员运算符用于引用类、结构和共用体的成员。
&	指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

6.7 运算符优先级

运算符的优先级会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面：

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %= >>= <<= &= ^=	=
逗号	,	从左到右

---

7 循环

可以在 while、for 或 do…while 循环内使用一个或多个循环。

7.1 while 循环

只要给定的条件为真，while 循环语句会重复执行一个目标语句。语法如下：

while(condition){
	statements(s);
}

其中statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。当条件为假时，程序流将继续执行紧接着循环的下一条语句。示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    while (a < 15) {
        cout << "a为：" << a << endl;
        a++;
    }
    return 0;
}

输出如下：

a为：10
a为：11
a为：12
a为：13
a为：14

7.2 for 循环

使用for 循环可以编写一个执行特定次数的循环的重复控制结构。语法如下：

for(init;condition;increment){
	statement(s);
}

for 循环的控制流：

1、init 会首先被执行，且只会执行一次。这一步需要声明并初始化循环控制变量。也可以不在这里写任何语句，只要有一个分号出现即可。

2、接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。

3、在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。

4、条件再次被判断。如果为真，则执行循环，这个过程会不断重复(循环主体，然后增加步值，再然后重新判断条件)。在条件变为假时，for 循环终止。

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    for (int a = 10; a < 15; a++) {
        cout << "a：" << a << endl;
    }
    return 0;
}

输出如下：

a：10
a：11
a：12
a：13
a：14

7.3 do…while 循环

do…while 循环与 while 循环类似，但是 do…while 循环会确保至少执行一次循环。do…while 循环是在循环的尾部检查它的条件。语法如下：

do{
	statement(s);
}while(condition);

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    do {
        cout << "a：" << a << endl;
        a++;
    } while (a < 15);
    return 0;
}

输出如下：

a：10
a：11
a：12
a：13
a：14

7.4 循环控制语句

7.4.1 break语句

break 语句有以下两种用法：

1、当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。

2、它可用于终止 switch 语句中的一个 case。

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    do {
        cout << "a：" << a << endl;
        a++;
        if (a > 13)
            break;
    } while (a < 15);
    return 0;
}

输出如下：

a：10
a：11
a：12
a：13

如果使用的是嵌套循环(即一个循环内嵌套另一个循环)，break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。

7.4.2 continue语句

continue 会跳过当前循环中的代码，强迫开始下一次循环。

对于 for 循环，continue 语句会导致执行循环增量和条件测试部分。对于 while 和 do…while 循环，continue 语句会导致程序控制回到条件测试上。

示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    do {
        if (a++ % 2 != 0)
            continue;
        cout << "a：" << a << endl;
    } while (a < 20);
    return 0;
}

输出如下：

a：11
a：13
a：15
a：17
a：19

---

8 判断语句

8.1 if 语句

if 语句的语法：

if(boolearn_expression){
	//若布尔表达式为真时执行的语句
}

任何非零和非空的值假定为 true，把零或 null 假定为 false。

8.2 if…else 语句

if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。语法如下：

if(boolearn_expression){
	//若布尔表达式为真时执行的语句
}
else{
	//若布尔表达式为假时执行的语句
}

示例代码如下：

#include<iostream>
using namespace std;

int main() {
	int a = 100;
	if (a < 20) {
		cout << "a小于20" << endl;
	}
	else {
		cout << "a大于20" << endl;
	}
	cout << "a的值为：" << a << endl;
	return 0;
}

输出如下：

a大于20
a的值为：100

一个 if 语句后可跟一个可选的else if...else语句，这可用于测试多种条件。当使用 if…else if…else 语句时，以下几点需要注意：

• 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
• 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
• 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

语法格式如下：

if(boolearn_expression1){
	//若布尔表达式1为真时执行的语句
}
else if(boolearn_expression2){
	//当布尔表达式2为真时执行的语句
}
else if(boolearn_expression3){
	//当布尔表达式3为真时执行的语句
}
else{
	//若上面的条件均为假时执行的语句
}

8.3 嵌套 if 语句

可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。

嵌套 if 语句的语法：

if(boolearn_expression1){
	//若布尔表达式1为真时执行的语句
	if(boolearn_expression2){
	//若布尔表达式2为真时执行的语句
	}
}

也可以嵌套 else if…else，方式与嵌套 if 语句相似。

8.4 switch 语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。语法如下：

switch (expression) {
	case constant - expression:
		statement(s);
		break; //可选的
	case constant - expression:
		statement(s);
		break; //可选的

	//可有任意数量的case语句
	default: //可选的
		statement(s);
	}

switch 语句必须遵循下面的规则：

• switch 语句中的 expression 应该是一个整型或枚举类型变量。
• 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
• case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且应该是一个常量。
• 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
• 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
• 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会继续后续的 case，直到遇到 break 为止。
• 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。

示例代码如下：

#include<iostream>
using namespace std;

int main() {
	char grade = 'D';
	switch (grade) {
	case 'A':
		cout << "很棒" << endl;
		break;
	case 'B':
	case 'C':
		cout << "做的好" << endl;
		break;
	case 'D':
		cout << "您通过了" << endl;
		break;
	default:
		cout << "无效成绩" << endl;
	}
	cout << "您的成绩是" << grade << endl;
	return 0;
}

输出如下：

您通过了
您的成绩是D

8.5 嵌套 switch 语句

可以在一个 switch 语句内使用另一个 switch 语句，示例代码如下：

#include<iostream>
using namespace std;

int main() {
	int a = 100;
	int b = 200;
	switch (a) {
	case 100:
		cout << "这是外部switch的一部分" << endl;
		switch (b){
		case 200:
			cout << "这是内部switch的一部分" << endl;
		}
	}
	cout << "a的准确值为" << a << endl;
	cout << "b的准确值为" << b << endl;
	return 0;
}

输出如下：

这是外部switch的一部分
这是内部switch的一部分
a的准确值为100
b的准确值为200

8.6 ?: 运算符

条件运算符?:的语法如下：

Exp1?Exp2:Exp3;

其中，Exp1、Exp2 和 Exp3 是表达式。请注意冒号的使用和位置。? : 表达式的值取决于：

• 如果 Exp1 为真，则计算 Exp2 的值，且 Exp2 的计算结果则为整个 ? : 表达式的值。
• 如果 Exp1 为假，则计算 Exp3 的值，且 Exp3 的计算结果则为整个 ? : 表达式的值。

?:被称为三元运算符，因为它需要三个操作数，可以用来代替if-else 语句。示例代码如下：

if (y<10) {
	var = 30;
}
else {
	var = 40;
}

上面的代码可以写成以下语句：

var=(y<10)?30:40;

---

END