现代C语言程序设计之数据计算
3.1 运算符概述
计算机最核心的任务就是完成数据的计算，C语言提供了丰富(多达34种)的运算符来实现不同数据的各种运算，之前在求数据类型的大小时已经使用过的sizeof()就是一种运算符，最常用的运算符有算术，关系，逻辑以及比较和位运算符，在介绍具体的运算符之前先要明确关于运算符的一些概念。
- 操作数:就是参与运算的数据，例如2，(3+2)都是一个操作数
- 运算符:指定数据执行的运算类型，例如算术，逻辑，关系,比较,位运算等等
- 表达式:由操作数和运算符组成，通常都是完成某种业务数据计算而设计的，例如计算圆的面积等等。
- 优先级:在各种运算符参与运算时，有不同的执行顺序，由它们的优先级决定，可以使用()来改变执行的顺序。
- 结合性:执行运算的方向，例如从左到右或者从右到左。
关于运算符概念的应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
关于运算符的概念
*/
void main(){
//运算符:参与数据的运算方式，这里的+就是运算符
//3+5就是表达式
//3,5就是操作数
int result = 3 + 5;
//优先级:计算的先后顺序，这里就是先乘除，后加减 ，可以通过()提高优先级
//结合性:计算的方向:这里就是从左往右开始计算
int precedence = (45 + 5) / 5 * 10;
//运算符不能相邻
// 1 + *3;
//但是在执行加减法运算时，编译器把+3当成了正数
1 + +3;
1 + -3;
system("pause");
}
3.2 算术运算符
算术运算符就是数学意义上的加减乘除，还有取模运算(即求余数)，取模主要用于数据的截取。
算术运算符是按照先乘除，后加减的优先级，从左到右的结合性执行计算，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
算术运算符
+ - * / % 的常规应用 以整数为例
*/
void main() {
printf("1 + 3 = %d\n", (1 + 3));
printf("8 - 2 = %d\n", (8 - 2));
//运算结果的类型是参与运算中的最大数据类型 整数和整数运算的结果是整数
printf("5 / 2 = %d\n", (5/2 ));
//整数和小数运算的结果类型是小数
printf("5 / 2.0 = %f\n", (5/2.0 ));
//3.5*2的结果是浮点数，这里通过强制类型转换为整数
printf("3.5 * 2 = %d \n",(int) (3.5 *2));
//求模运算符 就是求余数
printf("5 %% 2 = %d\n", (5%2));
//需要注意的是，只有整数才能求模，如下代码会发生编译错误
//printf(5%1.2);
//求模结果的符号类型与被除数相同
printf("5 %% -2 = %d\n", (5 % -2));
printf("-5 %% -2 = %d\n", (-5 % 2));
system("pause");
}
在执行算术运算时，会发生自动类型转换，结算结果的数据类型是其中最大的数据类型，例如整数和浮点数参与算术运算，结果一定是浮点类型，如果想要获得整数，则需要进行强制类型转换，应用案例如下所
#include <stdio.h>
#include <stdlib.h>
void main() {
// 13/4=3 自动转换为float 就是3.0
float fl = 13 / 4;
//输出结果为3.000000
printf("%f\n",fl);
//先运算出浮点类型 13/4.0=3.25
fl = 13 / 4.0;
printf("%f", fl);
printf("5.0 /2 = %d",(int)(5.0 / 2));
system("pause");
}
取模只能是整数参与运算，运算结果的符号和被除数一致，也就意味着如果被除数是正数，那么取模的结果就是正数，反之亦然，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
取模运算要求左右两边必须是整数类型
*/
void main() {
//被除数/除数的余数 就是取模
printf("3%%5=%d\n",(3%5));//3
printf("5%%3=%d\n",(5%3));//2
printf("3%%-5=%d\n",(3%-5));// 3
printf("5%%-3=%d\n",(5%-3));//2
printf("-3%%5=%d\n",(-3%5));// -3
printf("-5%%3=%d\n",(-5%3));// -2
system("pause");
}
取模的应用案例
将一个两位数实现倒转
#include <stdio.h>
#include <stdlib.h>
/*
取模的应用场景
数据切割
将一个二位数实现颠倒 例如输入95 反转结果是59
*/
void main() {
printf("请输入一个整数\n");
int num = 0;
scanf("%d",&num);
//个位
int unit = num % 10;
//十位
int decade = num / 10;
int reversalResult = unit * 10 + decade;
printf("%d反转之后的结果是%d\n",num,reversalResult);
system("pause");
}
将一个三位数倒转
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
将一个三位数实现颠倒 例如输入123 反转结果是321
*/
void main() {
printf("请输入一个整数\n");
int num = 0;
scanf("%d", &num);
//个位 123/10=12..3
int unit = num %10;
printf("unit= %d\n",unit);
//十位 123%10=12...3
int decade = num /10%10;
int hundreds = num / 100;
int reversalResult = unit * 100 + decade*10+ hundreds;
printf("%d反转之后的结果是%d\n", num, reversalResult);
system("pause");
}
3.3 赋值运算符
在学习变量赋值时用到的=实际上就是赋值运算符，它的作用就是用来将右边的值赋值给左边的变量，当表达式中有多个变量同时赋值时按照从右往左的结合性进行赋值，优先级在所有运算符中仅高于逗号运算符，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
赋值运算符
优先级:
结合性: 如果有多个赋值运算，则是从右向左赋值
*/
void main() {
int num = 3;
num = 10;
printf("num = %d\n", num = 20); //num=20 赋值表达式整体的值就是num被赋值的变量
int left;
int right;
//结合性:从右向左计算
left = right = 88;
printf("left = %d \t right = %d \n",left,right);
system("pause");
}
在赋值时，赋值运算符左边的值叫做左值，就是有内存实体的变量，右值就是能放在赋值号右边，并且能够赋值给其他变量的值，左值可以当作右值赋值给其他变量.
在赋值时会进行自动类型转换，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
赋值是在CPU内部的寄存器完成的
*/
void main() {
int num = 10;
//有内存实体的变量才能赋值
//右值:能放在赋值号右边，能赋值给其他变量的值
//20 = num;
//左值:被赋值的值，必须有内存实体，左值一定能当作右值
int target_num = num;
//赋值号会进行自动类型转换
int val = 10.999;
printf("val = %d\n",val);
system("pause");
}
在日常开发中，赋值运算还可以和算术运算结合在一块使用，用于简化表达式，但是需要注意的是它们在一起使用时不能使用空格隔开，否则会发生编译错误，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
赋值运算符结合算术运算符的使用
注意不能有空格 例如 + =,会造成编译错误
*/
void main() {
int num = 80;
printf("num =%d\n", num);
num += 8; //等价于 num =num +8;
printf("num+8 =%d\n", num);
num -= 20;
printf("num-20 =%d\n", num);
system("pause");
}
赋值和算术运算符的复杂案例
首先定义一个打印方法，用于输出三个整数参数的值
/*
输出三个整数参数的结果并换三行
*/
void print_result(int a,int b,int c) {
printf(" a = %d \n b = %d \n c = %d \n", a, b, c);
}
赋值运算结合算术运算的案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
赋值运算符结合算术运算符的复杂案例
理解赋值运算符的优先级，低于算术运算符，可以通过()提高优先级
遇到复杂的表达式时，先拆减，后计算
*/
void main() {
int a, b, c;
a = b = c=5;
print_result(a,b,c); // 5 5 5
//改变了优先级 先计算b=5
a = (b=5);
print_result(a, b, c); // 5 5 5
//先执行赋值，后执行加法 再把相加的结果赋值给a
a = 5 + (c = 6);//11 5 6
print_result(a, b, c);
//先执行 c=6，再执行b=4,再执行6+4 并把相加的结果赋值给a
a = (b = 4) + (c = 6); // 10 4 6
print_result(a, b, c);
//先执行c=2,再执行b=10 最周执行10/2并赋值给a
a = (b = 10) / (c = 2);// 5 10 2
print_result(a, b, c);
int num = 12;
//首先明确 赋值运算符低于算术运算符
//拆解表达式 num =num+(num=num-(num*num))
//计算步骤 num= -132+ (12-144)
num += num -= num * num;
printf(" num =%d \n ",num);
int tmp = 2;
tmp %= 4 - 1;
printf("tmp = %d",tmp); //目前tmp=2
//拆解表达式
// 0 0 0 6 6
//tmp=tmp+(tmp=(tmp*(tmp=tmp-(tmp=tmp*3))))
//tmp=
tmp += tmp *= tmp -= tmp *= 3;
printf("tmp += tmp *= tmp -= tmp *= 3 = %d",tmp);
system("pause");
}
3.4 自增运算符
自增运算符的作用就是用于变量的加1,主要用于控制循环的自增，由++两个加号组成，可以放到变量的前面或者是后面，如果是单独一行语句，前置或者是后置结果是一样的，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
自增运算符
当自增运算符作为单独的语句，无论前置++或者后置++结果都是一样的
*/
void main() {
int num = 10;
num++;
printf("num = %d\n", num);
int val = 10;
++val;
printf("val = %d\n", val);
system("pause");
}
当自增运算符不是一条单独的语句时，前置和后置会影响表达式的计算结果，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
表达式中的自增运算符
*/
void main() {
int num = 10;
int result = num++;
printf("result = %d \t num = %d\n", result, num);
int tmp = 10;
int target = ++tmp;
printf("target = %d \t tmp = %d\n", target, tmp);
system("pause");
}
而如果自增运算符和算术运算符同时参与运算时，自增运算符的优先级高于算术运算符，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
自增运算符的优先级高于算术
*/
void main() {
int num = 10;
int data = 5;
printf(" num = %d\n", ++num*5); //num先自增1 再参与乘法运算 结果是55
system("pause");
}
3.5 逗号运算符
在日常开发中，可以将多个表达式合并到一块，表达式之间使用逗号分隔，它们就构成了逗号表达式，其优先级是所有运算符中最低的，结合性是会按照从左到右的顺序执行计算，整个表达式的值就是最后那个逗号之后的表达式的值，应用案例如下所示。
#include <stdio.h>
#include <stdlib.h>
/*
逗号表达式的运算结果是最后一个逗号的值
优先级是所有运算符中最低的
*/
void main() {
int num = (5, 8);
printf("num = %d\n",num);
}
#include <stdio.h>
#include <stdlib.h>
/*
逗号运算符的每条语句都会被执行
结合性：从左向右
*/
void main() {
//使用逗号将多个表达式连接起来，整个表达式的值就是最后那个逗号之后的表达式的值
system("calc"), system("notepad"), system("ipconfig");
}
#include <stdio.h>
#include <stdlib.h>
/*
逗号表达式的复杂案例
*/
void main() {
//使用逗号将多个表达式连接起来，整个表达式的值就是最后那个逗号之后的表达式的值
printf("3+4,6的运算结果是%d\n",(3+4,6));
int a = 0;
printf(" a = (a=3,6*3) 的运算结果是%d\n",(a = (a = 3, 6 * 3)));
printf(" a = a=3,6*3 的运算结果是%d\n",(a = a = 3, 6 * 3));
printf(" a = 3 ,a+=2,a+3 的运算结果是%d\n",(a = 3, a += 2, a + 3)); //8
printf(" a = 3*5，a*4 的运算结果是%d\n",(a = 3 * 5,a * 4)); //60
printf(" (a = 3*5，a*4,a+5)的运算结果是%d\n",((a = 3 * 5,a * 4,a+5))); //20
system("pause");
}
3.6 条件运算符
条件运算符也被称为三目运算符，其表现形式为表达式1?表达式2:表达式3，其中如果表达式1的条件成立，那么表达式的计算结果就是表达式2，否则计算结果就是表达式3，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
条件运算符的应用案例
*/
void main() {
//表达式为非0，执行打开记事本，否则打开计算器
3 > 1 ? system("notepad"):system("calc");
system("pause");
}
三目运算符在进行数据计算时会自动类型转换，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
三目运算符的自动类型转换
*/
void main() {
int num = 20;
float fl = 10.9;
//这里发生了自动类型转换
printf("num > fl ? %f",(fl>num?fl:num));
system("pause");
}
使用关系运算符实现求两个整数的最大值应用案例
#include <stdio.h>
#include <stdlib.h>
/*
使用条件运算符实现取两个数的最大值
*/
void main() {
int first = 100;
int second = 200;
int max = first > second ? first : second;
printf("最大值是%d\n",max);
system("pause");
}
条件运算符的优先级仅仅优先于赋值运算符，当有多个条件表达式执行运算时，会按照从右到左的结合性进行计算，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
优先级:优先于赋值运算符
结合性:从右向左
*/
void main() {
int a = 5, b = 6, c = 7, d = 8;
//拆解表达式
// c>d?c:d ->8
// a>b?a:8 -> 8
//最后结果就是8
int result = a > b ? a : c > d ? c : d;
printf("result =%d \n",result);
system("pause");
}
使用关系运算符实现求四个整数中的最大值
#include <stdio.h>
#include <stdlib.h>
/*
求四个整数的最大值
*/
void main() {
int a = 5, b = 6, c = 7, d = 8;
int max = (a > b ? a : b) > (c > d ? c : d)? (a > b ? a : b): (c > d ? c : d);
printf("四个整数之间的最大值是%d\n",max);
system("pause");
}
3.8 关系运算符
没有对比就没有伤害，生活中处处都存在着比较，回归到程序中亦是如此，因为程序来源于生活,是对生活的一种仿真实现。
C语言的关系运算符以及说明如下表格所示
| 运算符 | 功能 |
|---|---|
| > | 大于 |
| < | 小于 |
| == | 等于 |
| != | 不等于 |
| >= | 大于等于 |
| <= | 小于等于 |
关系运算符的运算结果取决于参与运算的关系表达式，如果表达式成立，结果为1，否则为0，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
关系表达式的运算结果：成立为1，不成立为0
*/
void main() {
printf(" 88 <99 %d ",(88<99));
printf(" 88 >99 %d ",(88>99));
system("pause");
}
关系运算符的结合性是从左向右依次开始计算，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
关系运算符的结合性也是从左到右开始运算的
*/
void main() {
printf("5>4>3 %d", (5 > 4 > 3));
system("pause");
}
在使用关系运算符进行相等性判断时，如果数据类型是浮点数，还要注意浮点数的精度问题，应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
关系运算符的相等性判断
*/
void main() {
float left = 10.00000000001;
float right = 10.00000000000001;
//因为超过了float精确范围，所以是相等，即结果为1
printf(" left == right ? %d\n",(left==right));
system("pause");
}
C语言中使用字符串可以通过指针和字符数组两种方式，字符串也可以实现相等行判断，应用案例如下所示。
#include <stdio.h>
#include <stdlib.h>
/*
字符串相等性判断
*/
void main() {
//C语言使用字符串可以通过指针和数据两种方式
char *p1 = "BAT";
//相同常量的字符串，存储的是同一个地址
char *p2 = "BAT";
printf("p1的地址是%p\np2的地址是%p\n",p1,p2);
//因此这里是相等的。
printf("*p1 == *p2 ? %d\n ",(*p1 == *p2));
char str1[100] = "我要去阿里";
//这里会重新开辟内存，拷贝常量
char str2[100] = "我要去阿里";
printf("str1的地址是%p\n str2的地址是%p\n", str1, str2);
//此时不等，因为这里比较的是两个字符串的引用地址
printf("str1 == str2 ? %d\n",str1==str2);
system("pause");
}
关系运算符案例1:实现是否通过面试
#include <stdio.h>
#include <stdlib.h>
//定义一个名为面试分数的常量
#define INTERVIEW_SCORE 90
void main() {
int score = 0;
printf("请输入你面试的评分\n");
scanf("%d", &score);
//根据输入的分数判断是否符合面试
score >= INTERVIEW_SCORE ? printf("恭喜你通过面试\n") : printf("回家等电话\n");
system("pause");
}
关系运算符案例2:实现是否满足结婚条件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAN_AGE 22
#define WOMEN_AGE 20
/*
使用三目运算符结合关系运算符和逻辑运算符实现判断是否符合结婚条件
*/
void main() {
char boy[2] = "男";
char girl[2] = "女";
printf("请输入你的性别\n");
char gender[3] = {0};
scanf("%s",&gender);
printf("请输入你的年龄\n");
int age = 0;
scanf("%d",&age);
printf("你的性别是%s\t你的年龄是%d",gender,age);
//strcmp表示两个字符串的比较，如果返回0则为相等，需要引入<string.h>头文件
// //判断要么满足年龄大于等于22周岁并且性别为男性，或则年龄大于等于20周岁并且性别为女性的才能结婚。
(strcmp(gender,boy)==0&&age >= 22 || strcmp(gender,girl)&&age >= 20 )? printf("你已经到了法定的结婚年龄\n") : printf("你还没有到结婚的年龄，好好学习吧\n");
system("pause");
}
关系运算符案例3:使用程序实现根据不同的性别销售不同的商品
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MEN "男"
#define WOMEN "女"
/*
根据不同的性别制订不同的销售策略(卖不同的东西)
*/
void main() {
printf("请输入你的性别\n");
char gender[3] = {0};
scanf("%s",&gender);
strcmp(gender, MEN) == 0 ? printf("销售刮胡刀\n") : printf("销售化妆品\n");
system("pause");
}
3.9 逻辑运算符
逻辑运算是根据数据的逻辑关系，生成一个0或者1的值,常用的逻辑运算符有逻辑与(&&)，逻辑或(||)和逻辑非(!)
- 逻辑与(&&):表达式左右两边都是1，逻辑与的结果为1，否则为0
- 逻辑或(||):表达式左右两边只要有1边为1，逻辑或为1，否则为0
- 逻辑非(!):表达式结果1，逻辑非为0，否则为1
应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
逻辑运算符
*/
void main() {
//逻辑与:&&两边结果为1，逻辑与为1
printf(" 1 && 1 %d\n",(1&&1));
//&&两边有一个为0，结果为0
printf(" 1 && 0 %d\n",(1&&0));
//逻辑或: ||两边有一边为1 结果为1
printf(" 1 || 1 %d\n",(1||1));
//||两边同时为0，结果为0
printf("0 || 0 %d\n",(0||0));
//逻辑非 ！0 就是1 反之就是0
printf("!1 %d\n",(!1));
printf("!0 %d\n",(!0));
system("pause");
}
逻辑与和逻辑或还存在短路特性:一旦明确整个表达式的值，就不再计算表达式余下的部分,应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
逻辑运算符的短路特性:一旦明确整个表达式的值，就不再计算表达式余下的部分
*/
void main() {
int left = 5;
int right = 8;
//
0 && ++left;
1 || ++right;
printf("left =%d \n",left);
printf("right =%d \n", right);
system("pause");
}
运算符的优先级：
逻辑非(!)>算术运算符>逻辑与(&&)>逻辑或(||)>赋值运算符(=)
3.10 位运算符
位(bit)是计算机底层最基本的数据单位，使用二进制的0或则1来表示，而位运算就是基于二进制的运算。常用的运算符及其规则如下:
- 按位与(&):如果&两边都是1，结果位1，否则位0
- 按位或(|):如果|两边都是0，结果为0，否则为1
- 按位异或():如果两边都是0或者都是1，结果为0，否则为1
- 按位左移(<<):移动1位表示乘以2，依次类推
- 按位右移(>>):移动1位表示除以2，依次类推
- 按位取反(~):1变成0，0变成1
位运算符的应用案例如下所示
#include <stdio.h>
#include <stdlib.h>
/*
按位与运算符 1&1 =1 否则 0&1,1&0 也就是只要有1个0，结果为0
*/
void bit_and() {
unsigned char ch = 255; // 无符号的255的二进制表示为 1111 1111
unsigned char nch = 15; // 无符号的15的二进制表示为 0000 1111
//将1111 1111和0000 1111 进行按位与运算
printf("255 & 15 = %d\n",(255&15));
// 结果为1111 转换为十进制就是15
}
/*
按位或运算符 0|0=0 0|1=1 1|0=1 也就是只要有1个1，结果就是1，否则就是0
*/
void bit_or() {
unsigned char ch = 255; // 无符号的255的二进制表示为 1111 1111
unsigned char nch = 15; // 无符号的15的二进制表示为 0000 1111
//将1111 1111和0000 1111 进行按或与运算
printf("255 | 15 = %d\n", (255 | 15));
// 结果为1111 1111 转换为十进制就是255
}
/*
按位亦或: 1^1=0 0^0=0 1^0=1 0^1=1 也就是相同为0，不同为1
*/
void bit_xor() {
unsigned char ch = 255; // 无符号的255的二进制表示为 1111 1111
unsigned char nch = 15; // 无符号的15的二进制表示为 0000 1111
//将1111 1111和0000 1111 进行按或与运算
printf("255 ^ 15 = %d\n", (255 ^ 15));
// 结果为11110000 转换为十进制就是240
}
/*
使用异或完成变量交换
*/
void bit_xor_swap() {
//
int left = 10;
int right = 20;
printf("before left = %d right =%d\n",left,right);
left = left ^ right;
right = left ^ right;
left = left ^ right;
printf("after left = %d right =%d\n", left, right);
}
/*
取反运算符 将数据转换成二进制形式后，0变成1，1变成0
*/
void NOT() {
//二进制表现形式为 0000 0001
unsigned char ch = 1;
//取反之后的二进制是 1111 1110
unsigned char not_ch = ~ch;
printf("无符号字符1取反的结果是%d\n",not_ch);
// 整数1的二进制是 0000 0000 0000 0000 0000 0000 0000 0001
unsigned int num = 1;
//取反后的结果是 1111 1111 1111 1111 1111 1111 1111 1110
unsigned int not_num = ~num;
printf("无符号整数1取反的结果是%u\n", not_num);
}
/*
左移运算符 就是乘以2的N次方，例如左移1位，就是乘以2的1次方,左移2位，就是乘以2的2次方 依次类推
*/
void bit_left_move() {
int num = 10;
//10的二进制是0000 0000 0000 0000 0000 0000 0000 1010
//左边移一位是0000 0000 0000 0000 0000 0000 0001 0100
printf("10左移动1位的结果是%d\n",10<<1);
printf("10左移动2位的结果是%d\n",10<<2);
}
/*
右移运算符 就是除以2的N次方 例如右边移动1位，就是除以2的1次方，右移动2位，就是除以2的2次方
*/
void bit_right_move() {
int num = 10;
//10的二进制是0000 0000 0000 0000 0000 0000 0000 1010
//右移动一位是0000 0000 0000 0000 0000 0000 0000 0101
printf("10 右移1位的结果是%d\n",num>>1);
printf("10 右移1位的结果是%d\n",num>>1);
}
/*
位运算符和赋值运算符的结合使用
*/
void bit_assignment() {
unsigned char ch1 = 10;
unsigned char ch2 = 20;
ch1 &= ch2;
ch1 |= ch2;
ch1 ^= ch2;
ch1 <<= ch2;
ch1 >>= ch2;
}
void main() {
//bit_and();
//bit_or();
//bit_xor();
//bit_xor_swap();
//NOT();
bit_left_move();
bit_right_move();
system("pause");
}