文章目录
运算符，分支结构
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'; // 期望的答案
- 完成条件: 用户提供的年份是否为闰年，闰年条件:
- 可以被 4 整除，但是不能被 100 整除
- 可以被 400 整除
- 满足以上任意一个条件，就是闰年
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;
}