运算符和分支结构

运算符和分支结构

1.运算符

1.1 算数运算符

算数运算符主要有：+ - * / （） = %

• 先乘除后加减
• 小括号优先级最高，优先处理先括号内容
• 优先级一致时表达式运算顺序从左至右
• 使用 / 时除数不能为 0
• 复制号 ：将 = 右侧的数据赋值给左侧的变量

#include 

int main(int argc, char * argv[])
{
	int num1 = 10;
	int num2 = 20;

	num1 = num1 + num2; 
    printf("num1 = %d\n", num1);// num1 = 30
	printf("num2 = %d\n", num2);// num2 = 20

	num1 = num1 * num2;
    printf("num1 = %d\n", num1);// num1 = 600
	printf("num2 = %d\n", num2);// num2 = 20

    num1 = num1 - num2; 
    printf("num1 = %d\n", num1);// num1 = 580
	printf("num2 = %d\n", num2);// num2 = 20

    num1 = num1 / num2; 
    printf("num1 = %d\n", num1);// num1 = 29
	printf("num2 = %d\n", num2);// num2 = 20

    num1 = num1 % num2;
    printf("num1 = %d\n", num1);// num1 = 9
	printf("num2 = %d\n", num2);// num2 = 20


	return 0;
}

1.2 进阶版算术运算符

// += -= *= /= %=
int num1 = 10;
int num2 = 20;

num1 = num1 + num2; <==> num1 += num2;
// num1 += num2 num1 与 num2 相加的和重新赋值给 num1

num1 = num1 - num2; <==> num1 -= num2;
// num1 -= num2 num1 与 num2 相减的和重新赋值给 num1

//其他同理

• 代码实现

#include 

int main(int argc, char * argv[])
{
	int num1 = 20;
	int num2 = 30;
	
	num1 += num2;

	printf("num1 = %d\n", num1); // num1 = 50
	printf("num2 = %d\n", num2); // num2 = 30
	
	return 0;
}

1.3 自增自减运算符

基本样式

• ++ 和 –

要求

• 只能操作变量，不能操作常量
• 自增操作++对于操作变量的内部数据是 +=1，同理自减操作 – 对应的是 -=1

语法特征

• 自增自减运算符在变量之前时，先取值变量数据参与代码运行，后执行自增自减操作
• 自增自减运算符在变量之前时，先执行自增自减操作，再取值变量数据参与代码运行

#include 

int main(int argc, char * argv[])
{
	int num = 10;
	

	printf("num++ : %d\n", num++); // num++ = 10 
	printf("num : %d\n", num); // num = 11
	

	printf("++num : %d\n", ++num); // ++num = 12
	printf("num : %d\n", num); // num = 12
	
	return 0;
}

1.4 关系运算符

< >= <= != ==

关系运算符对外的数据结果都是真假关系
在 C 语言中结果为 0(假) 和 1(真)

关系运算符常用于条件判断，条件组合

#include 

int main(int argc, char * argv[])
{

	int ret = 10 > 5;			// ret = 1;
	printf("ret = %d\n", ret);
	
	ret = 10 < 5; 				// ret = 0;
	printf("ret = %d\n", ret);

	ret = 10 >= 10;				// ret = 1;
	printf("ret = %d\n", ret);

	ret = 10 <= 15;				// ret = 1;
	printf("ret = %d\n", ret);

	ret = 10 != 5; 				// ret = 1;
	printf("ret = %d\n", ret);
	
	ret = 10 == 5; 				// ret = 0;
	printf("ret = %d\n", ret);

	return 0;
}

1.5 逻辑运算符

逻辑运算符对外的结果也是真假关系
与  && ：同真为真，有假【即】假
或  || ：有真【即】真，同假为假
取反 ！：真变假，假变真

#include 

int main(int argc, char * argv[])
{
	int ret = 10 > 5 && 5 > 1; 	      // ret = 1
	printf("ret : %d\n", ret);

	ret = 10 > 15 && 5 > 1;			 // ret = 0
	printf("ret : %d\n", ret);
	
	ret = 10 > 15 || 5 > 1;			 // ret = 1
	printf("ret : %d\n", ret);

	ret = 10 > 15 || 5 > 10;		 // ret = 0
	printf("ret : %d\n", ret);

	ret = !(10 > 15);				 // ret = 1
	printf("ret : %d\n", ret);
	
	ret = !(10 > 5) && 5 > 1;		 // ret = 0
	printf("ret : %d\n", ret);

	return 0;
}

1.6 逻辑运算符的短路原则

案例一：

int num = 10;

int ret = 10 > 15 && ++num > 5;

 // ret = 0 
 // num = 10
/*
	【逻辑与短路原则】
	在逻辑与 && 表达式中，出现了第一个假条件 (10 > 15) ，整个逻辑与表达式结果已经明确为假，计算机为了降低计算逻辑复杂度，提升计算机效率，从第一个假条件开始，之后的内容不再执行。
*/

案例二：

int num = 10;

int ret = 10 > 5 || ++num > 5;

 // ret = 1 
 // num = 10
/*
解释:
	【逻辑或短路原则】
	在逻辑或 || 表达式中，出现了一个真条件(10 > 5)，整个逻辑或表达式结果已经明确为真, 计算机为了降低计算逻辑复杂度，提升计算机效率，从第一个真条件开始，之后的内容不再执行。
*/

1.7 位运算符

位运算符包括

与 ：&

或： |

异或 ： ^

取反 ：~

移动 : 左移： <<

     右移： >> 

• 与 ：同 1 为 1 有 0 则 0

​ 0 1 0 1 1 1 0 0 ： 92

& 0 1 1 0 0 1 0 0 ： 100

​ 0 1 0 0 0 1 0 0 ： 68

• 或 |：有 1 则 1 同 0 为 0

​ 0 1 0 1 1 1 0 0 ： 92

| 0 1 1 0 0 1 0 0 ： 100

​ 0 1 1 1 1 1 0 0 ： 124

• 异或 ^ ：不同为 1，相同为 0

​ 0 1 0 1 1 1 0 0 ： 92

^ 0 1 1 0 0 1 0 0 ： 100

​ 0 0 1 1 1 0 0 0 ： 56

• 取反 ~: 1 变 0, 0 变 1

​0 1 0 1 1 1 0 0 ： 92

~1 0 1 0 0 0 1 1 : - 93

• 左移 ： <<

  << n // 表示当前数据 * 2 ^ n
  

• 右移 ： >>

  >> n // 表示当前数据 / 2 ^ n
  

2. 分支结构

2.1 分支结构概述

常用分支结构有

• if 分支结构
• if else 分支结构
• if else if 分支结构
• switch case 分支结构

2.2 if 分支结构

if (// 条件判断，提供真假关系) 
{
    // 满足条件执行内容
}

#include 

int main(int argc, char * argv[])
{
	int num = 10;

	if (num > 5)
	{
		printf("执行 if 条件内容\n");
	}
	
	printf("代码正常执行\n");

	return 0;
}

2.3 if else 分支结构

if (// 条件判断，提供真假关系)
{
    // 满足条件执行内容
}
else
{
    // 不满足条件执行内容
}

#include 

int main(int argc, char * argv[])
{
	int num = 10;

	if (num > 5)
	{
		printf("满足条件执行内容\n");
	}
    else
    {
        printf("不满足条件执行内容\n")
    }
	
	printf("代码正常执行\n");

	return 0;
}

2.4 if else if 分支结构

if (// 条件匹配1 )
{
    // 满足条件 1 执行内容，不再匹配其他条件
}
else if (/* 条件匹配2 */)
{
    // 满足条件 2 执行内容，不再匹配其他条件 
}
else if (/* 条件匹配3 */)
{
    // 满足条件 3 执行内容，不再匹配其他条件   
}
else
{
    // 以上所有条件都没有匹配，执行 else 大括号语句
}

#include 

int main(int argc, char * argv[])
{
    int num = 10
        
    if (num >= 10)
	{
        printf("满足条件 (num >= 10 ) 执行内容，不再匹配其他条件\n");
	}
	else if (num >= 5)
	{
        printf("满足条件 (num >= 5) 执行内容，不再匹配其他条件 \n");
	}
	else if (num >= 2)
	{
        printf("满足条件 (num >= 2) 执行内容，不再匹配其他条件 \n\n");	
	}
	else
	{
        printf("// 以上所有条件都没有匹配，执行 else 大括号语句\n");
	}
	return 0;
}
	

2.5 switch case 结构

switch (/* 用于选择的变量 */)
{
    case 常量1:
        处理方式1;
        break;
    case 常量2:
        处理方式2;
       	break;
    case 常量3:
        处理方式3;
       	break;
    default:
        未匹配任何一个 case 的最终处理方式;
        break;
}
/*
	程序执行到switch case 结构时，根据 switch 后的变量和 case 后的常量进行匹配，
	如果在 case 后有与变量匹配的常量，那便执行匹配常量后的处理方式。
	然后 break挑出 switch case 结构。如果没有匹配的常量，那便 执行 default 后的处理方式，
	然后 break；跳出 switch case 结构
	【注意】
	1. case 后支持的常量类型有 short int long char
	2. case 后的常量不可以重复（如常量 1 等于常量 2 ）
	3. case 后的 break 在语法上可以省略，程序不会报错。例如case :常量 1 后没有braek，
程序不会跳出 switch case 结构，将继续执行case :常量 2 的处理方式
*/