3.运算符，分支结构

盄俁

已于 2024-01-02 10:33:04 修改

阅读量1k

点赞数 21

文章标签：开发语言 c++ c#

于 2023-12-29 11:45:00 首次发布

本文链接：https://blog.csdn.net/qq_54064293/article/details/135277729

版权

运算符，分支结构

1. 运算符

1.1 算术运算符

算术运算符是基本运算符，对应的就是加减乘除等

/*
运算符格式:
	+ 加
	- 减
	* 乘
	/ 除
	% 取余
	= 赋值
	() 小括号

运算符操作有什么要求
	1. 先乘除，后加减
	2. 按照最基本的从左至右计算
	3. 有括号优先处理括号中的内容
	4. 除数不能为 0 
	5. 取余操作有且只能用于【整数】
	6. 算术运算符是【二元/二目运算符】，对应两个操作数，运算符两端需要空格隔开
		1+1 = 推荐写法 => 1 + 1
	7. 赋值运算符，是将赋值号右侧的数据，赋值给左侧的变量
*/

//c++
#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
	// 定义一个 int 类型的变量 num1
	int num1 = 10;
	// 定义一个 int 类型的变量 num2
	int num2 = 20;
	
	/*
	 1. 变量数据在整个程序的运行过程中，存储数据内容有可能会发生改变
	 在使用当前变量时，注意当前变量数据存储情况。
	 2. 变量有且只有在被赋值的情况下才可以改变数据内容
	 3. % 操作仅针对与整数
		例如：5 除 3 商 1 余数 2
	 */
	num1 = num1 + num2; // num1 = 30 num2 = 20
	num1 = num1 * num2; // num1 = 600 num2 = 20
	num1 = num1 - num2; // num1 = 580 num2 = 20
	num1 = num1 / num2; // num1 = 29 num2 = 20
	num1 = num1 % num2; // num1 9 num2 = 20;

	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	return 0;
}

//c语言
#include <stdio.h>

int main(int argc, char * argv[])
{
	// 算术运算符演示
	int num1 = 20;
	int num2 = 30;

	/*
	 * 关注点：
	 *	1. 关注变量在代码运行过程中的数据存储变化过程
	 *	2. 变量数据有且只有被赋值的情况下才会修改存储数据内容
	 *	3. 双目运算符，例如 + - * / % 要求运算符两端有空格
	 */
	num1 = num1 + num2; // num1 = 50 num2 = 30
	num1 = num1 * num2; // num1 = 1500 num2 = 30
	num1 = num1 - num2; // num1 = 1470 num2 = 30
	num1 = num1 / num2; // num1 = 49 num2 = 30
	num1 = num1 % num2; // num1 = 19 num2 = 30
	
	printf("num1 = %d\n", num1);
	printf("num2 = %d\n", num2);


	return 0;
}

1.2 增强版算术运算符【常用】

基于算法运算符，简化一定的操作

int num1 = 10;
int num2 = 20;

num1 = num1 + num2; == 采用增强版算术运算符 ==> num1 += num2;
/*
+= -= *= /= %=
*/
num1 = num1 - num2; == 采用增强版算术运算符 ==> num1 -= num2;
num1 = num1 * num2; == 采用增强版算术运算符 ==> num1 *= num2;
num1 = num1 / num2; == 采用增强版算术运算符 ==> num1 /= num2;
num1 = num1 % num2; == 采用增强版算术运算符 ==> num1 %= num2;

/*
开发中也会使用
 	+= 1 和 -= 1 替换【自增自减运算符操作】
*/

1.3 自增自减运算符

1.3.1 使用建议和基本语法

自增自减运算符使用建议

自增自减运算符尽量单独成行，或者单独一个模块，不影响其他代码，降低代码中的歧义性
自增自减在某些语言中已经被【淘汰】，推荐使用 += 1 和 -= 1 操作
自增自减运算符是【一元/单目运算符】，只有一个操作数，运算符和操作数之间不允许有空格
【重点】自增自减运算符有且只允许操作【变量】

自增自减运算符语法规则

自增自减运算符，在变量之后，首先取值当前变量数据存储内容参与当前行代码执行，数据提供之后，num 执行自增自减操作
自增自减运算符，在变了之前，首先进行变量存储数据自增自减操作，之后取值当前变量存储数据内容参与当前代码行执行。

#include <iostream>

using namespace std;

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

    /*
    自增运算符，操作的变量数据存储内容 += 1
    【特征语法】
        1. 自增自减运算符，在变量之后，首先取值当前变量数据存储内容
            参与当前行代码执行，数据提供之后，num 执行自增自减操作
        2. 自增自减运算符，在变了之前，首先进行变量存储数据自增自减
            操作，之后取值当前变量存储数据内容参与当前代码行执行。
    */
	cout << "num++ = " << num++ << endl; // 10
	cout << "num = " << num << endl;     // 11
	
	cout << "++num = " << ++num << endl; // 12
	cout << "num = " << num << endl;     // 12

    cout << "num-- = " << num-- << endl; // 12
	cout << "num = " << num << endl;     // 11
	 
	cout << "--num = " << --num << endl; // 10
	cout << "num = " << num << endl;     // 10
	return 0;
}

#include <stdio.h>

int main(int argc, char * argv[])
{
	int num = 10;
	
	/*
	 * 自增运算符在变量之后，首先取值变量数据，参与当前行代码运行
	 * 之后执行自增操作。第一行代码打印结果为 10, 第二次打印结果为 11
	 */
	printf("num++ : %d\n", num++);
	printf("num : %d\n", num);
	
	/*
	 * 自增运算符在变量之前，首先执行自增操作修改变量存储的数据内容，
	 * 之后提取变量数据，参与代码运行
	 */
	printf("++num : %d\n", ++num);
	printf("num : %d\n", num);
	
	return 0;
}

1.3.2 自增自减运算符常见面试题

题目一推荐拍照发群里，大家一起看

int num = 5;
int ret = num++ * ++num;

/*
请问:
	1. num 最终的数据是多少? 7
	2. ret 的最终结果是多少? 35
解释:
	【重点】自增自减运算符如果在变量之后，首先取值变量数据内容，参与当前行代码执行，数据提
	供之后，变量数据执行自增自减操作
	num++ * ++num;
		num++ ++ 在后，首先取值 num 目前存储的数据，对于整个表达式提供数据 5 ，同时提
		供之后，num 执行自增操作，num 存储结果为 6
		++num ++ 在前，首先执行自增操作，num 数据存储 6 ==> 7，在提供数据给当前整个表
		达式，提供数据 7
		
		整个表达式结果为 5 * 7
	
	ret = 35
	num = 7
*/

题目二

int num = 10;
int ret = ++num++;
/*
请问:
	1. num 最终的数据是多少?
	2. ret 的最终结果是多少?
语法错误
	++num++
	拆解分析
		++num 首先执行自增操作，num 数据自增之后，存储内容为 11，num 提供数据 11 参与
		表达式执行
		表达式变为 11++，自增运算符操作的数据为常量，语法不允许，【ERROR】
		【重点】自增自减运算符有且只允许操作【变量】
*/

题目三

int num = 5;
int ret = num++ + num++ * num-- + (num++ / ++num);

ret = 47;
num = 8;

/*
该类型题目
	1. 直接拍照发群里！！！不要自己推理！！！很容易出错！！！
	2. num 基本数据操作需要学会推理
		num 自增了 4 次，自减了 1 次，最终 num += 3 
	3. 不会！！！爱咋咋地！！！·
*/

1.4 关系运算符

判断关系运算符两端的数据情况是否满足关系运算符要求，对外的最终结果为【真假关系】，在 C++ 中是 bool 类型(true->1, false->0)，在 C 语言中就是 0 or 1

关系运算符是一个【二元/双目运算符】，需要运算符两端都有空格

/*
关系运算符:
	> < >= <= != ==
*/
//c++
#include <iostream>

using namespace std;

int main(int argc, char * argv[])
{
	// C++ 中是 bool 类型，可以采用 bool 类型的变量存储结果数据
	// 关系运算符对外的结果内容都是 bool 类型
	bool ret = 10 > 5;
	cout << "ret : " << ret << endl; // 1 ==> true

	ret = 20 < 5;
	cout << "ret : " << ret << endl; // 0 ==> false;
	
	ret = 20 <= 20;
	cout << "ret : " << ret << endl; // 1 ==> true;
	
	ret = 20 != 5;
	cout << "ret : " << ret << endl; // 1 ==> true;
	
	ret = 20 == 5;
	cout << "ret : " << ret << endl; // 0 ==> false;

	/*
	开发建议：
	    常量和变量等值(==)判断，建议常量在前，变量在后
	 */
	int num = 10;
	ret = num == 10; // 1 ==> true;
	ret = 10 == num; // 1 ==> true; [墙裂推荐]
}

//c语言
#include <stdio.h>

int main(int argc, char * argv[])
{
	/*
	 * ret ==> result 结果，关系运算符对外结果是 0 or 1
	 * 使用 int 类型在 C 语言满足数据存储要求
	 */
	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 逻辑运算符

1.5.1 逻辑运算符基本语法

在后续的开发中，多重判断条件的组合都需要逻辑运算符来完成。

语法概述

&& 与，同真为真，有假【即】假
|| 或，有真【即】真，同假为假
! 非/取反，真变假，假变真，强牛–>犟

逻辑运算符中，逻辑与和逻辑或是【二元/双目运算符】，两端需要空格，逻辑非，是【一元/单目运算符】，不需要空格

//c++
#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
	// 逻辑运算符对外结果为 bool 类型真假关系
	bool ret = 10 > 5 && 5 > 3;
	cout << "ret : " << ret << endl; // 1 ==> true

	ret = 10 > 15 && 5 > 3;
	cout << "ret : " << ret << endl; // 0 ==> false

	ret = 10 > 15 || 5 > 3;
	cout << "ret : " << ret << endl; // 1 ==> true

	ret = 10 > 15 || 5 < 3;
	cout << "ret : " << ret << endl; // 0 ==> false

	ret = !(10 > 15); // 小括号中的内容表示一个整体
	cout << "ret : " << ret << endl; // 1 ==> true
	
	ret = !(10 > 15) && 5 > 3;
	cout << "ret : " << ret << endl; // 1 ==> true

    return 0;
}

//c语言
#include <stdio.h>

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 = 1
	printf("ret : %d\n", ret);

	return 0;
}

1.5.2 逻辑运算符短路原则

案例一逻辑与短路原则

核心知识点：&& 与，同真为真，有假【即】假

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

/*
请问:
	1. ret 结果为? false(0)
	2. num 结果为? 10
分析:
	1. ret 结果为 false 是显而易见
	2. num 结果为什么是 10 ???
		【逻辑与短路原则】当前逻辑与表达式中，存在一个 false(0) 条件，整个表达式结果已经明
		确为 false(0)，计算机为了不浪费计算资源，从 false(0) 条件开始，之后的所有内容不在
		执行判断
		10 > 15 && ++num > 5;
			10 > 15 结果为 false ,整个表达式结果为 false，第二个条件 ++num > 5 CPU 没
			有执行
		最终结果 num = 10
*/

案例二逻辑或短路原则

核心知识点：|| 或，有真【即】真，同假为假

int num = 10;
bool ret = 10 < 15 || ++num > 5;

/*
请问:
	1. ret 结果为? true (1)
	2. num 结果为? 10
分析:
	1. ret 结果为 true 是显而易见
	2. num 结果为什么是 10 ???
		【逻辑或短路原则】当前逻辑或表达式中，存在一个 10 < 15 明确为 true(1) 的条件，整
		个表达式结果可以明确为 true，所以在逻辑或表达式中，计算机为了降低运算复杂度，降低资
		源浪费，从第一个 true(1) 条件开始，之后的表达式内容不在执行。
		10 < 15 || ++num > 5;
			10 < 15  ==> true 已经明确为 true
			++num > 5 没有执行
		num = 10
*/

1.6 位运算符【重点】

100 ==> 0110 0100

5 ==> 0000 0101

1.6.1 计算

位与 & : 同 1 为 1 ，有 0 则 0

100 & 5 
  0110 0100 ==> 100
& 0000 0101 ==> 5
  0000 0100 ==> 4

位或 |：有 1 则 1，同 0 为 0

100 | 5 
  0110 0100 ==> 100
| 0000 0101 ==> 5
  0110 0101 ==> 101

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

100 ^ 5 
  0110 0100 ==> 100
^ 0000 0101 ==> 5
  0110 0001 ==> 97

~按位取反:

~5
~ 0000 0101 ==> 5
  1111 1010 ==> -6

1.6.2 移动

左移 <<

左移相对于当前数据 * 2^n, n 是移动的位数
0000 0101 << 1 ==> 0000 1010 ==> 10
0000 0101 << 2 ==> 0001 0100 ==> 20

右移 >>

算术右移最高位补 1
逻辑右移最高位补 0
右移操作，不管是什么形式的数据，统一认为是 / 2 n 次方法操作，除了 -1 右移无论多少位都是 -1

二进制数据:
	1011 1100
	逻辑右移 >> 1 ==> 0101 1110
	算术右移 >> 1 ==> 1101 1110
	到底执行是算术右移还是逻辑右移，需要考虑数据的真实情况，涉及到原码，反码和补码，尤其是负数
	相对于除以 2 的 n 次数

-98 内存存储形式
	对应正整数原码 0110 0010
	原码:
		1110 0010
	反码:
		1001 1101
	补码:
		1001 1110
	
	-98 >> 1 ==> 1001 1110 >> 1 ==> 1100 1111(补码)
	补码: 1100 1111
	反码: 1100 1110
	原码: 1011 0001 ==> -49

1.7 运算符案例

完成条件: 用户提供的字符是否为数字字符的判断

char ch = '1';
/*
数字字符的范围: '0' ~ '9' 
按照数学形式完成对应的范围约束:
	'0' <= ch <= '9'; 当前写法无法满足【代码需求】
代码方式完成:
	ch >= '0' && ch <= '9'
*/
ch >= '0' && ch <= '9';

完成条件: 用户提供的字符是否为大写英文字符的判断

/*
字符集中大写英文字母的范围是 'A' ~ 'Z'
代码形式完成:
*/
char ch = 'I';
ch >= 'A' && ch <= 'Z';

完成条件: 用户提供的字符是否为英文字符的判断

/*
注意: 
	1. 大写英文字母和小写英文字母之间非连续
	2. 大写英文字母编码值小于小写字母
	 'A' ~ 'z' 错误范围！！！
	两个范围的组合:
		'A' ~ 'Z'
		'a' ~ 'z'
*/
char ch = 'x';

ch >= 'A' && ch <= 'Z' // 大写字母条件
ch >= 'a' && ch <= 'z' // 小写字母条件
ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z';  // 英文字符判断[推荐]
(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');  // 英文字符判断
ch < 'A' || ch > 'Z' && ch < 'a' || ch > 'z'; // 期望的答案

完成条件: 用户提供的年份是否为闰年，闰年条件:
1. 可以被 4 整除，但是不能被 100 整除
2. 可以被 400 整除
3. 满足以上任意一个条件，就是闰年

int year = 2008;
/*
可以被 4 整除
	year % 4 == 0;
不能被 100 整除
	year % 100 != 0
可以被 400 整除
	year % 400 == 0

可以被 4 整除，但是不能被 100 整除，需要两个条件同时满足，所有使用 && 连接两个判断
	year % 4 == 0 && year % 100 != 0
可以被 400 整除，两个条件满足其一就 OK，采用 || 连接
*/
year % 4 == 0 && year % 100 != 0 || year % 400 == 0

2. 分支结构【重点】

2.1 基本概述

	常用的分支结构有 if 分支和 switch case 分支结构，可以用于条件判断，条件触发，选择执行。大量存在于项目代码中。

2.2 if 分支结构

// 格式
if (/* 条件判断 */) 
{
    // 如果 if 之后小括号内容满足条件，执行大括号内容
    
}

#include <stdio.h>

int main(int argc,char * argv[])
{
    int money = 500;
    
    if(money > 200)
    {
        printf("%s\n","VIP充值成功！")；
    }
    
    printf("%s\n","代码正常执行")；
        
    return 0;
}

2.3 if - else 分支结构

语法格式

if(/*条件判断，要求结果提供真假关系，c 语言默认 0 假 1 真*/)
{
    //满足条件执行内容
}
else
{
    //不满足条件执行内容
}

#include <stdio.h>

int main(int argc,char * argv[])
{
    int money = 300;
    
    /*
    1.首先先完成整个 if else 分支结构架构，包括小括号，大括号
    2.后续填充代码内容
    3.注意，不允许省略任何一个大括号
    */
    if(money > 200)
    {
        printf("充值金额符合充值要求，充值成功\n")；
    }
    else
    {
        printf("充值金额不符合要求，充值失败\n")；       
    }
	return 0;
}

2.4 if - else if 分支结构

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

/*
案例：
小瑜丸子开了一个烘焙店
	消费满 100 元，送现烤鱿鱼宝宝一个
	消费满 200 元，送 4 英寸蛋糕一个
	消费满 500 元，送 6 英寸蛋糕一个 + 生日蛋糕装饰一套
	消费满 1000 元，打 75 折 + 4 英寸蛋糕一个
	消费满 2000 元，打 7 折 + 6 英寸蛋糕一个 + 生日蛋糕装饰一套 + 免费配送
*/

include <stdio.h>

int main(int argc,char * argv[])
{
    int money = 200;
    
    if(money >= 2000)
    {
        printf("消费满 2000 元，打 7 折 + 6 英寸蛋糕一个 + 生日蛋糕装饰一套 + 免费配送\n");
    }
    
    else if(money >= 1000)
    {
        printf("消费满 1000 元，打 75 折 + 4 英寸蛋糕一个\n");
    }
    
    else if(money >= 500)
    {
        printf("消费满 500 元，送 6 英寸蛋糕一个 + 生日蛋糕装饰一套");
    }
    
    else if(money >= 200)
    {
        printf("消费满 200 元，送 4 英寸蛋糕一个");
    }
    
    else if(money >= 100)
    {
        printf("消费满 100 元，送现烤鱿鱼宝宝一个");
    }
    
    else
    {
        printf("欢迎下次光临！");
    }
    return 0;
}

2.5 switch case 选择分支结构

//格式
swich(/* 选项存储对应的变量，变量数据类型推荐使用 int 类型 */)
{
    case 常量1:
    	//处理方式 1
    	break;
    case 常量2：
        //处理方式 2
        break;
    case 常量3：
        //处理方式3
        break;
    default：
        //最终处理方式
        break;
}
/*
执行流程：
	程序运行到 switch case 选择分支结构，根据 switch 之后小括号中的变量存储数据内容，
匹配 case 之后的常量，如果有匹配项，执行对应的处理方式，到 break 跳出 switch case 结构，如果没有任何一个 case 匹配，执行 default 中的最终处理方式。
*/

C++
#include <iostream>

using namespace std;

int main(int argc,char * argv[])
{
    cout << "请选择您今晚逛街的目标店铺：" << endl;
    cout << "1.优衣库" << endl;
    cout << "2.HM" << endl;
    cout << "3.ZARA" << endl;
    cout << "4.BM" << endl;
    cout << "5.三福" << endl;
    cout << "6.名创优品" << endl;
    
    //用户选择存储变量
    int choose = 0;
    cin >> choose;
    
    switch(choose)
    {
        case 1:
            cout << "100 ~ 200 之间" << endl;
            break;
        case 2:
            cout << "辱华不建议消费！" << endl;
            break;
        case 3:
            cout << "不适合小个子" << endl;
            break;
        case 4:
            cout << "emmm 可以去逛逛" << endl;
            break;
        case 5:
            cout << "种类繁多" << endl;
            break;
        case 6:
            cout << "性价比高！" << endl;
            break;
        default:
            cout << "回家歇歇吧！" << endl;
            break;
    }
    return 0;
}

c语言
#include <stdio.h>

int main(int argc, char *argv[])
{
    int choose = 1;
    int price = 0;

    printf("请输入您要点的菜:\n");
    printf("1.胡辣汤\n");
    printf("2.小笼包\n");
    printf("3.豆腐脑\n");
    printf("4.下单！\n");

    scanf("%d", &choose);

    switch (choose)
    {
    case 1:
        price += 8;
        printf("胡辣汤一份！消费：%d\n", price);
        break;
    case 2:
        price += 6;
        printf("小笼包一份！%d\n", price);
        break;
    case 3:
        price += 5;
        printf("豆腐脑一份！%d\n", price);
        break;
    case 4:
        printf("总消费:%d\n", price);
        break;
    default:
        printf("输入错误！\n");
        break;
    }
    return 0;
}