【C语言从不挂科到高绩点】03-C语言运算符

听潮阁

于 2024-08-28 10:22:36 发布

阅读量642

点赞数 14

分类专栏： C语言程序设计文章标签：算法 c++ c语言开发语言 qt 嵌入式硬件

本文链接：https://blog.csdn.net/yueyehuguang/article/details/141633421

版权

C语言程序设计专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本套课程将会从0基础讲解C语言核心技术，适合人群：

大学中开设了C语言课程的同学
想要专升本或者考研的同学
想要考计算机等级证书的同学
想要从事C/C++/嵌入式开发的同学

前文传送：

【C语言从不挂科到高绩点】01-C语言概述-CSDN博客

【C语言从不挂科到高绩点】02-变量、数据类型、标识符、关键字-CSDN博客

分享不易，耗时耗力，麻烦给个不要钱的关注和赞吧

承接毕设指导，技术答疑，学习路上缺少导师的同学可以私信我

更多学习资料，公众号：墨轩学习网，B站：墨轩大楼

四、 C语言中的运算符

4.1 算术运算符

加法	减法	乘法	除法	取余
+	-	*	/	%

【参考案例】

/**算术运算符**/

#include <stdio.h>

int main(){

	int a = 12;
	int b = 100;

	printf("%d+%d=%d\n",a,b,(a+b));  //112
	printf("%d-%d=%d\n",a,b,(a-b)); // -88
	printf("%d*%d=%d\n",a,b,(a*b)); //1200

	// 对于除法 / 而言，如果左右两边都是整数
	// 就会做相除取整运算
	printf("%d/%d=%d\n",b,a,(b/a)); // 8


	// 对于除法 / 而言，如果左右两边有任意一边是小数，就做正常的除法运算
	float c = 12;
	printf("%d/%f=%f\n",b,c,(b/c));

	double d = 100;
	printf("%lf/%d=%lf\n",d,a,(d/a));


	// 取余： % ，两个数相除，取余数
	// 在输出语句中%有特殊的含义，如果需要输出%，就需要用到%%
	printf("%d %% %d=%d\n",b,a,(b%a));//4
    // 取余% ，只适用于整数对整数取余
	// printf("%d %% %f=%d\n",b,c,(b%c));

	// 整数和小数发生运算之后，结果就会被自动转换成小数
	printf("%d+%f=%f\n",a,c,(a+c));
	printf("%d-%f=%f\n",b,c,(b-c));

	return 0;
}

需要注意的问题：

对于除法 / 而言，如果左右两边都是整数，就会做相除取整运算
对于除法 / 而言，如果左右两边有任意一边是小数，就做正常的除法运算
取余： % ，两个数相除，取余数，只适用于整数对整数取余
整数和小数发生运算之后，结果就会被自动转换成小数。

4.2 算术运算符的其他写法

当我们希望对某个变量进行运算，然后运算的结构再赋值给变量本身

int q = 5;
// 在q的基础上加8，再将计算的结果再赋值给q
q = q+8; // 先将q的值取出来，然后加上8，结果再赋值给q

而 c 语言对此情况提供另外的写法，假设#代替某种运算符，那么可以写成如下格式：

a = a#b  可以写成  a #= b
其中：# 可以是 + - * / % 其中的一个

【参考案例】

#include <stdio.h>

int main(){

	int q = 5;
	q = q+8;
	printf("q=%d\n", q); //13


	int m = 5;
	m += 8;// 等价于 ： m = m+8;
	printf("m=%d\n",m );


	int n=2;
	n *= 8;  // n = n*8;
	printf("n=%d\n",n ); //16


	int w = 5;
	int e = 4;

	// *= 运算符优先级小于算术运算符-
	// 会先左算术运算，然后再做 *=
	w *= e-2;
	printf("w=%d\n",w);

	return 0;
}

需要注意的问题：

a#=b 只是一种简写形式，不会影响程序执行效率。
简写形式运算符优先级要低于算术运算符。

4.3 自增和自减运算符

当要让一个变量自身加 1 的时候，可以这样写

a = a+1;
a +=1;

C 语言还支持另外一种协大

a ++;
++ a;

这种写法称为自增或者自加，每次在自己的基础上加 1

相应的，也有 a-- 或者 --a, 这种叫做自减，表示每次在自己的基础上-1

#include <stdio.h>

int main(){

	/**
		自增： 
			前 ++  ++j  表示先对j的值自加1，然后再将自加后的结果参与运算
			后 ++  j++  表示先将j的值参与运算，然后再将j的值自加1

		自减：
			前--  --j  表示先对j的值自减1，然后再将自减后的结果参与运算
			后--  j--  表示先将j的值参与运算，然后再将j的值自减1

	**/

	int j = 1;

	// = 也是运算符，表示赋值运算
	int i = j++;  // j++ 自加等价于： j+=1 或者 j=j+1

	printf("i=%d,j=%d\n",i,j); // i=1,j=2

	i = ++j; //
	printf("i=%d,j=%d\n",i,j); //i=3,j=3

	int m = 1;
	int n = --m;
	printf("n=%d,m=%d\n",n,m ); // n=0, m=0


	int a=12,b=1;
	int c = a-b--;
	printf("b=%d,c=%d\n",b,c);// b=0 ,c=11

	int d = ++a-(--b);
	printf("a=%d,b=%d,d=%d\n",a,b,d );// a=13 b=-1  d=14

	return 0;
}

4.4 键盘输入

C语言中可以用 scanf()函数进行键盘输入，scanf 是 scan format 的缩写，意思是格式化扫描。也就将用户输入的内容扫描到程序中。

使用 scanf() 函数的一般步骤：

先定义变量，用来接收输入的内容
提示用户输入内容（打印一条输出语句，告诉用户应该输入什么样的数据）
使用 scanf 函数，将输入的内容，扫描到第 1 步定义的变量中

scanf 函数格式：

scanf(格式化占位符，&存储数据的变量);
格式化占位符： 
    输入的是int类型的数据：用 %d  (以int类型的形式扫描内容)
    输入的double类型的小数： 用 %lf
    输入的float类型的小数，用 %f
    输入的是char类型的字符， 用%c

【参考案例】


#include <stdio.h>

/**
	scanf 格式化扫描

	1. 先定义变量，用来接收输入的内容
	2. 提示用户输入内容
	3. 使用 scanf 函数，将输入的内容，扫描到第 1 步定义的变量中
**/

int main(){
	// 使用scanf扫描键盘输入的整数

	//1.先定义变量，用来接收输入的内容
	int num = 0; // 稍后用来保存scanf扫描出来的数据
	// 2. 提示用户输入内容
	printf("请输入一个整数：");
	//3. 使用 scanf 函数，将输入的内容，扫描到第 1 步定义的变量中
	//   scanf(格式化占位符，&存储数据的变量);
	scanf("%d",&num);
	//printf("您输入的数据为：%d\n",num);


	// 输入第二个数
	int num2 = 0;
	printf("请输入一个整数：\n");
	scanf("%d",&num2);

	printf("%d+%d=%d\n",num,num2,(num+num2) );


}

需要注意的问题是：scanf 也可以同时扫描多个数据，多个数据之间的占位符用空格隔开

【参考案例】


/**
	使用scanf需要注意的问题
**/

#include <stdio.h>

int main(){
	
	// scanf 也支持一次输入多个值,多个值之间用空格隔开
	// 1. 定义变量
	int num1=0,num2=0;
	// 2. 提示输入
	printf("请输入两个整数（用空格隔开）:");
	// 3. 接收扫描
	// 表示输入的第一个整数，存入到num1中，第二个整数，存入到num2中
	// scanf是遇到了空格会结束当前数据的扫描，空格后面的数据，是属于另一个数据
	// 特别注意：scanf中除了占位符和空格以外不要出现其他符号
	scanf("%d %d",&num1,&num2);

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

特别注意：scanf中除了占位符和空格以外不要出现其他符号。

4.5 关系（比较）运算符

关系运算符通常用来做比较。计算的结果只可能是 0 或者 1.如果关系运算符的结果为 1，表示它们之间的关系成立。如果为 0 表示关系不成立。通常用在判断场景中。

小于	小于或等于	大于	大于或等于	等于	不等于
<	<=	>	>=	==	!=

【参考代码】

/**关系运算符**/

#include <stdio.h>

int main(){

	int a = 5;
	int b = 3;

	printf("%d < %d = %d\n",a,b,(a<b));   //0
	printf("%d <= %d = %d\n",a,b,(a<=b));  //0
	printf("%d > %d = %d\n",a,b,(a>b));   //1
	printf("%d >= %d = %d\n",a,b,(a>=b)); //1
	printf("%d == %d = %d\n",a,b,(a==b));  //0
	printf("%d != %d = %d\n",a,b,(a!=b));  //1


	return 0;
}

需要注意的点：

使用关系运算符计算的结果只可能是 1 或者 0
结果为 1 表示关系成立，结果为 0 表示关系不成立
关系运算符==要和赋值运算符= 区分开。

4.6 位运算符

所谓的位运算符，就是对一个 bit（比特）位进行运算。比特是一个电子元器件，8 个比特位构成了一个字节。

C 语言中常用的位运算符一共有 6 中

&	\|	^	~	<<	>>
按位与	按位或	异或	取反	左移	右移

4.6.1 按位与运算

对一个 bit（比特）位来说，它的值只有 0 或者 1 两个值。按位与而言，参与运算的两位都是 1 的时候，结果才为 1，否则结果为 0

/** 位运算**/

#include <stdio.h>

int main(){

	int a = 9;
	int b = 5;

	printf("%d & %d = %d\n",a,b,(a&b) );//1
	return 0;
}

C 语言中不能直接使用二进制，对于位运算来说，运算时，需要将参与运算的数字，转换成 2 进制再进行运算

int 类型的长度 4 个字节，每个字节 8 个比特位，所以 int 一共占用 32 个比特位

对于：9&5 而言

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

----------------------------------------------------- （按位与&，上下两个数都是 1 的时候，结果才为 1，否则结果为 0）

0000 0000 0000 0000 0000 0000 0000 0001 （1 在内存中的存储）

&与运算就是对参与运算的两个数所有的二进制为进行&运算。

尝试： 7&5

0000 0000 0000 0000 0000 0000 0000 0111 （7 在内存中的存储）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

---------------------------------------------------------（按位与&，上下两个数都是 1 的时候，结果才为 1，否则结果为 0）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

负数的位运算：-9 & 5

负数的二进制：正数的二进制按位取反（原本是 1 就变成 0，原本是 0 就变成 1,）再加 1.

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

1111 1111 1111 1111 1111 1111 1111 0110 (9 按位取反)

1111 1111 1111 1111 1111 1111 1111 0111 (取反之后+1, 结果，-9 在内存中的存储)



1111 1111 1111 1111 1111 1111 1111 0111 (-9 在内存中的存储)

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

---------------------------------------------------------（按位与&，上下两个数都是 1 的时候，结果才为 1，否则结果为 0）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

4.6.2 按位或运算

参与 | 或运算的两个二进制位，有一个为 1 的时候，结果就位 1，只有当两个都是 0 的时候，结果才为 0

比如：9|5

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

---------------------------------------------------- （按位与 |，上下两个数都是 0 的时候，结果才为 0，否则结果为 1）

0000 0000 0000 0000 0000 0000 0000 1101 （13 在内存中的存储）

【参考代码】

/** 位运算**/

#include <stdio.h>

int main(){

	int a = 9;
	int b = 5;

	printf("%d | %d = %d\n",a,b,(a|b) );
	return 0;
}

算一下：-9|5

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

1111 1111 1111 1111 1111 1111 1111 0110 (9 按位取反)

1111 1111 1111 1111 1111 1111 1111 0111 (取反之后+1, 结果，-9 在内存中的存储)



1111 1111 1111 1111 1111 1111 1111 0111 (-9 在内存中的存储)

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

------------------------------------------------------（按位与 |，上下两个数都是 0 的时候，结果才为 0，否则结果为 1）

1111 1111 1111 1111 1111 1111 1111 0111 (-9 在内存中的存储)

4.6.3 按位异或

参与 ^ 运算的两个二进制位，相同的时候结果为 0，不同的时候结果为 1

比如：9^5

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

0000 0000 0000 0000 0000 0000 0000 0101 （5 在内存中的存储）

---------------------------------------------------- （按位 ^，上下两个数相同的时候结果为 0，不同的时候结果为 1）

0000 0000 0000 0000 0000 0000 0000 1100 (12 在内存中的存储)

【参考代码】

/** 位运算**/

#include <stdio.h>

int main(){

	int a = 9;
	int b = 5;

	printf("%d ^ %d = %d\n",a,b,(a^b) );
	return 0;
}

4.6.4 按位取反运算

参与~运算，原本是 1 就变成 0，原本是 0 就变成 1

比如：~9

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

1111 1111 1111 1111 1111 1111 1111 0110 (9 按位取反)

负数二进制转成 10 进制：

按位取反，然后再加 1 ，得到一个正数
这个正数前面加一个负号，就是最终结果

1111 1111 1111 1111 1111 1111 1111 0110 （负数）

0000 0000 0000 0000 0000 0000 0000 1001 （按位 取反）

0000 0000 0000 0000 0000 0000 0000 1010 （加 1 之后，结果为 10）

所以1111 1111 1111 1111 1111 1111 1111 0110 是 -10

4.6.5 左移运算

左移运算<<用来将操作数的各个二进制位全部向左移动若干位，高位超出的部分丢弃，低位补 0.

比如：9<<3

0000 0000 0000 0000 0000 0000 0000 1001 （9 在内存中的存储）

0000 0000 0000 0000 0000 0000 0100 1000 (左移移动 3 位)

结果：72

对于左移而言，如果数据较小，并且操作的不是负数或者高位丢弃不包含 1，那么左移 n 位，就相当于乘以 2 的 n 次方，比如：9<<3 位，实际上等同于：9 乘以 2 的 3 次方

再比如：5<<3

0101

00101000

结果：40

4.6.6 右移运算

右移运算>> 用来将操作数的各个二进制位向右移动若干位，低位被丢弃，高位原本是 1 就补 1，原本是 0 就补 0

比如：9>>3

00000000000000000000000000001001 （9 在内存中的存储）

00000000000000000000000000000001 (1 在内存中的存储)

比如：16>>3

00000000000000000000000000010000 (16 在内存中的存储)

00000000000000000000000000000010 （2 在内存中的存储）

printf("9>>3=%d\n",9>>3 );
printf("16>>3=%d\n",16>>3);

比如：-9>>3

1111111111111111111111111111 0111 (-9 在内存中的存储)

1111111111111111111111111111 1110



负数二进制转成 10 进制：

按位取反，然后再加 1 ，得到一个正数
这个正数前面加一个负号，就是最终结果
1111111111111111111111111111 1110 (将其转换成正数)

0000000000000000000000000000 0001 (按位取反）

0000000000000000000000000000 0010 （在加 1，结果为 2）

-9>>3 的结果为1111111111111111111111111111 1110，转成 10 进制就是-2

4.7 逻辑运算符

&&	\|\|	！
逻辑与	逻辑或	逻辑非

在 C 语言中，我们通常将 0 值称为“假”，非零值称为"真"。逻辑运算符的结果也只有真和假，真对应的值是 1，假对应的值是 0.

4.7.1 逻辑与运算

参与逻辑与运算的两个表达式都为真时，结果才为真，否则结果为假。

/**
逻辑与
**/

#include <stdio.h>

int main(){

	int a = 7;
	int b = 5;


	//按位与
	printf("%d & %d = %d\n",a,b,(a&b) ); // 5

	// 逻辑与 
	printf("%d && %d = %d\n",a,b,(a&&b) ); //1


	return 0;
}

代码解析：

a 的值是 7，是一个非 0 值，结果为真

b 的值是 5，是一个非 0 值，结果为真

逻辑与&&，只有当左右两边都为“真”最终结果，就为真（1），否则结果为假（0）

逻辑&&运算符通常会和关系运算符一起使用，表示并且的意思。左右两边的表达式必须同时成立，结果才为真，否则结果为假。

int a = 5;
int b = 0;
int c = 2;

int m = a>b && c<b;
// a>b成立，结果为1
// c<b不成立，结果为 0
// int m = 1 && 0  结果：0

printf("m=%d\n",m);

对于逻辑与&&而言，如果左边的表达式为假（0），就已经能说明整个表达式结果为假（0）。此时右边的表达式结果如何，不会影响整个表达式的最终结果。为了提升效率，此种情况 C 语言会直接屏蔽&&右侧的代码。此时右侧的表达式就被短路了。

#include <stdio.h>


int main(){

	int x = 1;
	int y = 2;
	int z = 3;

	// int ok = x++<y++&&z++>y++;

	// printf("ok=%d\n",ok);  // 0
	// printf("x=%d\n", x); //2
	// printf("y=%d\n", y);  //4 
	// printf("z=%d\n", z);  //4

	//         0 && 1
	int ok = x++>y++&&z++>y++;

	printf("ok=%d\n",ok);  //0
	printf("x=%d\n", x);  //2
	printf("y=%d\n", y);  //3
	printf("z=%d\n", z);  //3
	return 0;
}

4.7.2 逻辑或运算

参与逻辑或 || 运算的两个表达式都为假（0）结果才为假（0），否则结果就为真（1）

10 || 0

10 是非 0 值，结果为真（1）。而 0 是 0 值，结果为假。整体结果就为真（1）

5<0 || 5>8

5<0 结果为假（0），5>8 结果为假，左右两边都为假（0），整体的结果就为假（0）


int a = 5;
int b = 0;
int c = 2;

int n = a<b || a>c;
printf("n=%d\n",n );// 1

对于逻辑或 || 而言，如果左边的表达式结果为真（1），那么此时就已经能够说明整个表达式为真（1），右侧的表达式是否为真，不会影响最终的结果，此时右边表的表达式会短路。

int x = 1;
int y = 2;
int z = 3;

int ok = x++<y++||z++>y++;

printf("ok=%d\n",ok);  //1
printf("x=%d\n", x);  //2
printf("y=%d\n", y);  //3
printf("z=%d\n", z);  //3

4.7.3 逻辑非

参与逻辑非！运算的表达式为真（1）结果就为假（0），表达式为假（0）的时候，结果就为真（1）（颠倒黑白）

!0

0 为假，用了！非之后，就要颠倒过来，所以最终的结果就为 1

!(4>0)

4>0 结果为真，用了非运算之后，就要颠倒过来，所以最终的结果就为 0

int q = 5;
int t = 0;

printf("%d\n",!q); // 0
printf("%d\n",!t); // 1
printf("%d\n"!!!t); //1

4.8 三目运算符

三目运算符的应用格式：

条件表达式？值1：值2；

表示：如果条件表达式成立，结果为真（1），就选择值 1 作为最终的结果，如果条件表达式不成立，结果为假（0），就选择值 2 作为最终结果。

条件表达式：是由关系运算符或者逻辑运算符组成的，结果只可能是 1 或者 0 的表达式。


#include <stdio.h>

int main(){

	int age = 20;

	// 条件表达式？值1：值2
	// 条件表达式为真，就选择值1作为最终结果
	// 条件表达式为假，就选择值2作为最终结果

	int result = age<18?120:200;
	printf("result=%d\n",result );

	return 0;
}

需要注意的问题：

三目运算符的优先级要低于关系运算符。
三目运算?和:是一个整体，不能拆开来单独使用
三目运算符的结合方向是自右向左的

int a = 1;
int b = 2;
int c = 3;
int d = 4;

//三目运算符的结合方向是自右向左的
int re = a>b?a:c>d?c:d;
printf("re=%d\n", re); //4

// 等价于下面的表达式
int re1 = a>b?a:(c>d?c:d);
printf("re1=%d\n", re1);//4

【案例练习】输入任意两个数，找出这两个数中的最大值。

/**输入任意两个数，找出这两个数中的最大值**/

#include <stdio.h>

int main(){
	// 定义两个变量，用来存两个数
	int num1=0,num2=0;
	printf("请输入两个数：");
	scanf("%d %d",&num1,&num2);

	int max = num1>=num2?num1:num2;
	printf("%d 和 %d 之间的最大值是：%d\n",num1,num2,max );

	return 0;
}

4.9 运算符优先级

运算符的优先级可以按照如下方式进行

赋值运算符（=） < && 和 || < 关系运算符 < 算术运算符 < 逻辑非(!)

&&和 || 优先级低于关系运算符，而逻辑非!要高于算术运算符

/**
赋值运算符（=） <  && 和 ||  < 关系运算符 < 算术运算符 < 逻辑非(!)
**/

#include <stdio.h>

int main(){

	char c = 'k';

	int i=1,j=2,k=3;

	float x=3e+5,y=0.85;

	printf("%d ,%d\n",!x*!y,!!!!x);// 0  1

	printf("%d ,%d\n",x||0&&j-3,i<j&&x<y);//1 0

	printf("%d ,%d\n",i!=5&&c&&(j==8),x+y||i+j);//0 1

	return 0;
}

4.10 数据类型转换

4.10.1 自动类型转换

自动类型转换（隐式类型转换）是编译器默认的，自动进行的数据转换，不需要程序员干预，会自动发生

float f = 100;

100 是整数，C 语言中等号以等号左边为基准的。此时就需要将 100 转换为 float 类型才能赋值给 float 类型的变量 f。

float f = 12.34;
int n = f;

f 是 float 类型的数据，需要先转换成 int 类型才能赋值给 n；

在赋值运算中，赋值符号=两边数据类型不同时，需要将右侧的表达式的类型转换成左侧变量的数据类型。但是往往这种情况会导致数据失真或者精度丢失。

自动类型转换，不一定安全。



#include <stdio.h>

int main(){

	float w = 12.345;

	int n = w; // 需要将float类型的w转换成int类型，由编译器自动完成
	// 此种情况，如果赋值给n，那就需要将小数点后面的数据砍掉
	// 此时数据精度就丢失了
	printf("n=%d\n", n);//12

	float pi = 3.1415926;


	int s1,r=5;

	double s2 ;

	

	// 当整数类型和小数类型发生运算之后，运算的结果会被自动转换成小数类型
	s2 = r*r*pi;
	// r*r*pi 算出来的结果是小数类型，如果要赋值给int类型的s1
	// 此时，系统就会将这个小数类型自动转换成int类型
	s1 = r*r*pi;

	printf("s1=%d,s2=%lf\n", s1,s2);// 78  78.539810



	return 0;
}

需要注意的问题：

自动类型转换通常按数据长度增加的方向会进行，以保证数据不失真，比如：int 和 long 参与运算时，会将 int 类型转换成 long 类型再运算。int 和 double 类型参与运算时，会将 int 类型转换成 double 类型再运算。
所有的浮点运算都是以 double 双精度进行的，及时运算中只有 float 类型，也需要先转换成 double 类型才能进行运算。
short 和 char 参与运算时，会先转换成 int 类型。

4.10.2 强制类型转换

强制类型转换时程序员明确提出的，需要通过特定的格式（手段）来进行的一种转换。需要成员人为干预。

强制类型转换的格式:

(需要转换的数据类型)数据
比如：
    int a = 10;
    float c = (float)a;
表示：将int类型的a强制转换成float类型

【参考案例】

/**
	强制类型转换
**/

#include <stdio.h>

int main(){

	int sum = 103; // 总分
	int count = 7; // 科目数

	// 平均分
	double avg = sum/count;

	printf("平均分:%lf\n",avg);// 14.000000

	// 此种情况，就需要对整数类型进行强制转换
	// 将int类型的sum强制转换成了double类型
	avg = sum/(double)count;
	printf("平均分:%lf\n",avg);



	return 0;
}

4.10.3 类型转换只是临时的

无论是强制类型转换，还是自动类型转换，都只是为了本次运算而进行的临时转换，转换的结果会存放临时空间（原数据的副本），修改时只是修改了这个副本，不会改变原数据类型或者值。



#include <stdio.h>

int main(){

	double total = 400.8;// 总价

	int count = 5;// 数量

	double unit;// 单价

	/**
	无论是强制类型转换，还是自动类型转换，
	都只是为了本次运算而进行的临时转换，
	转换的结果会存放临时空间（原数据的副本），
	修改时只是修改了这个副本，不会改变原数据类型或者值。
	*/

	int total_int = (int)total;// 只是将转换后的结果赋值给了total_int

	unit = total/count; // unit=80.160000
	// 从结果来看，total还是400.8，说明 (int)total是没有改变total的值

	printf("unit=%lf,total=%lf,total_int=%d\n",unit,total,total_int );
	return 0;
}

4.11 C 语言中的随机数

随机数程序中分为两种：

真随机数：完全没有规则，无法预测接下来要产生的数。
伪随机数：通过一些预先设定好的规则产生不能简单预测的数

C 语言中使用的是伪随机数，产生伪随机数的步骤：

设置随机数种子：一般使用当前的时间作为种子（需要导入 time.h）
获取随机数

设置随机数种子和获取随机数，分别要使用 stdlib.h 头文件中的 srand 函数和 rand 函数

/**
	C 语言中的随机数
**/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(){

	// 1. 设置随机数种子
	//	 1) time(0)  获取当前时间的秒数：1970年1月1日0时0分0秒到当下秒数
	//     注意：使用time(0) 前提是需要导入 time.h头文件
	//printf("%ld\n",time(0));
	//   2) 使用srand将时间做为种子
	srand(time(0));

	// 2. 获取随机数
	//int num = rand(); // 使用rand() 生成随机数，然后给到变量num

	//printf("num=%d\n", num); // rand() 产生随机数的范围在unsigned int 范围内随机生成

	 // 随机生成0-8之间的整数
	int num = rand()%8;
	printf("1:num=%d\n", num);

	// 随机生成5-17之间的整数  [5,17)
	num = rand()%12+5;
	printf("2:num=%d\n", num);

	// 随机数种子只需要设置一次即可


	return 0;
}

各位彦祖，于晏，亦菲们，都看到这里了，给个关注和赞吧！！O(∩_∩)O哈哈~

听潮阁

关注

14
点赞
踩
16

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C语言从不挂科到高绩点】03-C语言运算符

表示：如果条件表达式成立，结果为真（1），就选择值 1 作为最终的结果，如果条件表达式不成立，结果为假（0），就选择值 2 作为最终结果。按位与而言，参与运算的两位都是 1 的时候，结果才为 1，否则结果为 0。参与 | 或运算的两个二进制位，有一个为 1 的时候，结果就位 1，只有当两个都是 0 的时候，结果才为 0。运算的表达式为真（1）结果就为假（0），表达式为假（0）的时候，结果就为真（1）（颠倒黑白）58 结果为假，左右两边都为假（0），整体的结果就为假（0）
复制链接

扫一扫