运算

算术运算

+, -, * # 符合常规，分别是相加、相减、相乘
/ # 整除，如 5/3 = 1
% # 取模运算(整除之后的余数), 如 5%3 = 2
++ # 自增运算，自身整数值+1
-- # 自减运算，自身整数值-1

关系运算

== # 相等为真
!= # 不等为真
> # 左侧大于右侧为真
< # 左侧小于右侧为真
>= # 左侧大于或等于右侧为真
<= # 左侧小于或等于右侧为真

逻辑运算

&& # 逻辑与，符号两边都为真则为真
|| # 逻辑或，符号两边有一个为真则为真
! # 逻辑非，逆转逻辑状态，真的为假，假的为真

位运算

C/C++位运算详解
不过多解释，相对使用较少，现用先学。

赋值运算

灰常滴简单。
= # 最常见的赋值运算，C = A + B，把A+B的结果赋值给C
+= # 加且赋值，C+=A等价于C = C + A，把C+A的结果重新赋值给C
-= # 减且赋值，C-=A等价于C = C - A，把C-A的结果重新赋值给C
其他算术运算、位运算同理，不一一做解释:
*=, /=, %=, <<=, >>=, &=, ^=, |=

杂项运算

sizeof # 返回变量大小。详解
? : # 条件运算符(三目运算符)详解
. 和 -> # 成员运算符详解
(type) expr # 强制转换运算符，把一种数据类型转换为另一种数据类型。如：float a=1.12; (int)a详解
& # 指针运算符(取址运算符)，返回变量的地址。详解
* # 指针运算符(间接寻址运算符)，指向一个变量。详解
, # 逗号运算符，顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。详解

运算符优先级

详情查阅 C++运算符优先级和关联性表

条件判断语句

if语句及其嵌套衍生语句

if语句结构样式: 

1
2
3
4
5
6
// bool_expr 布尔返回值的表达式，如: a > b, a != c等等。
// code_block if条件中的代码块，当条件成立时执行代码块内容。

if (bool_expr) {
    code_block
}

if示例代码: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

int main()
{
    int a = 10;

    if (a < 20)
    {
        cout << "a 小于 20" << endl;
	}
    cout << "a 大于或等于 20" << endl;
    return 0;
}

输出: 

1
2
a 小于 20
a 大于或等于 20

if…else示例代码: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;

int main()
{
    int a = 10;

    if (a < 20)
    {
        cout << "a 小于 20" << endl;
	}
	else {
        cout << "a 大于或等于 20" << endl;
    }
    return 0;
}

输出: 

1
a 小于 20

嵌套if示例代码: 

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 a = 10;

    if (a < 20)
    {
        cout << "a 小于 20" << endl;
	}
	else {
        if (a == 20) {
            cout << "a 等于 20" << endl;
        }
        else
        {
			cout << "a 不等于 20" << endl;
        }
    }
    return 0;
}

输出: 

1
a 小于 20

if…else if… 示例代码 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;

int main()
{
    int a = 10;

    if (a < 20)
    {
		cout << "a 小于 20" << endl;
	}
	else if (a == 20)
    {
        cout << "a 等于 20" << endl;
    }
    else
    {
        cout << "a 大于 20" << endl;
    }
    return 0;
}

输出: 

1
a 小于 20

switch语句及其嵌套衍生语句

switch语句结构样式: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// expr 枚举类型表达式。  
// const-expr 常量表达式。  
// code_block 代码块。  

switch(expr){
    case const-expr1  : // 当expr与const-expr1匹配的时候执行代码块1
        code_block_1
        break; // 可选的
    case const-expr2  : // 当expr与const-expr2匹配的时候执行代码块2
        code_block_2
        break; // 可选的
    ......
    // 可以有任意数量的 case 语句
    default : // 默认值可选的，当前面的case没有任何一个匹配的时候，执行默认代码块
        code_block
}

switch 示例代码： 

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <iostream>
using namespace std;

int main() {
    int day = 4;

    switch (day) {  // 数字
    case 1:
        cout << "周一" << std::endl;
        break;
    case 2:
        cout << "周二" << std::endl;
        break;
    case 3:
        cout << "周三" << std::endl;
        break;
    case 4:
        cout << "周四" << std::endl;
        break;
    case 5:
        cout << "周五" << std::endl;
        break;
    case 6:
        cout << "周六" << std::endl;
        break;
    case 7:
        cout << "周日" << std::endl;
        break;
    default:
        cout << "无效日期" << std::endl;
    }

    // 局部变量声明
    char grade = 'D';

    switch (grade) // 字符
    {
    case 'A':
        cout << "很棒！" << endl;
        break;
    case 'B':
    case 'C': // 多重case用法
        cout << "做得好" << endl;
        break;
    case 'D':
        cout << "您通过了" << endl;
        break;
    case 'F':
        cout << "最好再试一下" << endl;
        break;
    default:
        cout << "无效的成绩" << endl;
    }
    cout << "您的成绩是 " << grade << endl;

    return 0;
}

输出： 

1
2
3
周四
您通过了
您的成绩是 D

嵌套 switch 示例代码： 

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

输出： 

1
2
3
4
这是外部 switch 的一部分
这是内部 switch 的一部分
a 的准确值是 100
b 的准确值是 200

循环语句

循环控制语句

break # 终止循环或switch语句，并跳出当前代码块
continue # 跳过循环主体部分，继续进行下一次循环
goto # 控制执行流程跳转到被标记位置(实际开发不建议使用，容易引起逻辑混乱)

for循环

for循环语句结构样式: 

1
2
3
4
5
6
7
8
9
// init 首先被执行，初始化循环控制变量。  
// condition 随后执行，循环判断条件，条件成立则执行code_block，反之执行increment，循环执行直到条件不成立结束循环。  
// increment 增量语句，用于改变循环控制变量。  
// code_block 代码块。

for ( init; condition; increment )
{
   code_block
}

for循环示例代码： 

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
using namespace std;

int main()
{
    // for 循环执行
    for (int a = 10; a < 20; a = a + 1)
    {
        cout << "a 的值：" << a << endl;
    }

    return 0;
}

输出： 

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

C++11 有基于范围的for循环，不在该系列文字基础范围，暂时不做更多展开。
基于范围的for循环

while循环

while循环语句结构样式: 

1
2
3
4
5
6
7
// condition 先进行循环判断条件的判断，条件成立则执行code_block，循环执行直到条件不成立结束循环。  
// code_block 代码块。

while(condition)
{
   code_block
}

while循环示例代码： 

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 a = 10;

    // while 循环执行
    while (a < 20)
    {
        cout << "a 的值：" << a << endl;
        a++;
    }

    return 0;
}

输出： 

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

do…while循环

do…while循环语句结构样式: 

1
2
3
4
5
6
7
// code_block 先执行代码块。
// condition 然后进行循环判断条件的判断，条件成立则再次执行code_block，循环执行直到条件不成立结束循环。 

do
{
   code_block
}while( condition );

do…while循环示例代码： 

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 a = 10;

   // do 循环执行
   do
   {
       cout << "a 的值：" << a << endl;
       a = a + 1;
   }while( a < 20 );
 
   return 0;
}

输出： 

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

嵌套循环

将上述的多种类型的循环组合在一起 

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
// 嵌套for循环
for ( init; condition; increment )
{
   for ( init; condition; increment )
   {
      code_block
   }
   code_block // 可以放置更多的语句
}

// 嵌套while循环
while(condition)
{
   while(condition)
   {
      code_block
   }
   code_block // 可以放置更多的语句
}

// 嵌套do...while循环
do
{
   code_block // 可以放置更多的语句
   do
   {
      code_block
   }while( condition );
 
}while( condition );

除此之外，for，while，do…while也可以互相嵌套，不常用，不做展开叙述。

死循环(无限循环)

上述三种循环，当循环条件(condition)恒为真(true)的时候，并且代码块(code_block)没有跳出语句，如break,return,goto，则循环不会结束，为死循环。

函数

使用函数的优点:

  1. 提高代码复用性 - 避免重复编写相同的代码，提高开发效率。
  2. 提高可读性 - 代码结构更加清晰，易于理解和维护。
  3. 降低耦合度，增强可维护性 - 修改一个函数不会影响其他部分，使程序更易修改和扩展。
  4. 便于调试 - 代码分块后更容易定位和修复错误。
  5. 支持递归 - 通过函数调用自身，实现复杂算法，如阶乘、斐波那契数列等。
  6. 增强可扩展性 - 通过参数化，适应不同的输入，提高灵活性。
  7. 减少代码长度 - 让 main() 及其他部分更加简洁，提高代码整洁度。
    函数结构样式:
1
2
3
4
5
6
7
8
9
// return_type 函数返回值类型。  
// function_name 函数名。  
// code_block 执行代码块(函数体)。  
// parameter 函数形式参数，可以有多个。可以传递的类型如：传值，传指针，传引用。  

return_type function_name( parameter1, parameter2, ...)
{
   code_block
}

函数示例代码： 

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
#include <iostream>
using namespace std;

// 函数声明
int max(int num1, int num2);

int main()
{
    // 局部变量声明
    int a = 100;
    int b = 200;
	int ret;
    // 调用函数来获取最大值
    ret = max(a, b);
    cout << "最大值为: " << ret << endl;
    return 0;
}

// 定义函数。
// 功能：函数返回两个数中较大的那个数
int max(int num1, int num2)
{
    // 局部变量声明
    int result;
    if (num1 > num2)
        result = num1;
    else
        result = num2;
    return result;
}

输出： 

1
最大值为: 200

扩展:
Lambda函数与表达式
C++中的Lambda表达式