（Linux）嵌入式打卡第四天

最新推荐文章于 2024-08-30 09:47:11 发布

P...H...Q

最新推荐文章于 2024-08-30 09:47:11 发布

阅读量604

点赞数 6

文章标签：算法

本文链接：https://blog.csdn.net/2303_78438820/article/details/141687875

版权

单目运算符

~按位取反

功能：将数据中每一位都进行取反操作。

#include <stdio.h>

int main(int argc, const char *argv[])
{
	//定义一个无符号数 number = 5;
	//unsigned char number = 5;//number是无符号char型，占内存1字节
	
	unsigned int number = 5;
	printf("~number = %#x\n",~number);//%#x是一个十六进制数字，4字节
								  // number是char型，打印的需要打印4字节
								  // number不够4字节，会补充最高位的值
	
	//定义一个有符号的数字 value = -5;
	int value = -5;
	printf("~value = %d\n",~value);
//unsigned int a = -5;   // -5源码: 1000 0000 0000 0000 0000 0000 0000 0101 
//             计算机内存存储a ;  a: 1000 0000 0000 0000 0000 0000 0000 0101 
	
	return 0;
}
结果：
~number = 0xfffffffa
~value = 4

取地址运算符&

功能：获取变量的地址，地址是一串十六进制的数字。

使用方式：

&变量名 eg：&number -> 获取number的地址

C语言中，打印地址的占位符：%p

取值运算符

功能：获取地址中的值。

使用方式：

*指针； char *p = &number; //定义一个变量p，里面存放number的地址

*p -> 获取number里面的值

#include <stdio.h>

int main(int argc, const char *argv[])
{
	//打印number的地址
	int number = 10;
	printf("number 的地址%p\n",&number);


	//定义一个指针，指针用来存放number的地址
	int *p = &number;

	printf("*p = %d\n",*p);//*运算符 获取地址里面的值
	printf("p = %p\n",p);//p 的类型是地址 还要用%p来打印

	return 0;
}

算数运算符

算术运算符又称双目运算符，有两个操作数。

算术运算符的种类：+ - * / %

除法 /：C语言中/的意思是整除，计算机中数比可以进行 /0 操作的。

int number = 9/2;

number = 4; //C语言中 / 表示整除

取余 %：

int number = 9% 0.2; 错误：%必须是整数，不可以是小数。

移位运算符

简介：

移位运算符也是按位进行操作的运算符。

移位运算符：左移 << 右移 >>

移位运算符操作时：只计算正数，或者无符号数据。

运算规则：

左移 <<：

左移补足的位数补充数字 0 . 相当于数字扩大2倍 number * 2;

右移>>：

右移不足位数补充数字 0 ，相当于整除2；

#include <stdio.h>

int main(int argc, const char *argv[])
{
	//左移数字，相当于扩大2倍 ，补充0
	unsigned int number = 10;
	printf("number << 2 = %d\n",number << 2);

	//右移数字，相当于整除2 ，补充0
	unsigned int value = 10;
	printf("value >> 2 = %d\n",value >> 2);
	return 0;
}

关系运算符

简介：

关系运算符：主要用于比较大小关系

关系成员：

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

返回值：

关系运算符是有返回值：返回值真(1) 假(0)

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int number = !(5 > 3);
	printf("number = %d\n",number);
	// 0
	return 0;
}
结果：
number = 0

与运算符

与运算符：符号&

与运算符是一个二进制运算符，&与运算符需要使用二进制进行运算。

运算规则：

&运算符：两真则为真。（按位运算时，两个两个都是1，则结果为1）

1与任何数，等于任何数。

0与任何数，等于0。

异或运算符

简介：

异或运算符：二进制运算符。异或运算符的符号 ^ (异或)

运算规则：

二进制运算符，对应的数中，相同位数为0，不同位数为1.

异或运算符运算规则：

1. 1. 异或两个相同的数为0；
  2. 0异或任何数，等于任何数。0 ^ 20 = 20;
  3. 异或与顺序无关：1 ^ 2 ^3 ^ 3 ^ 2 =1;

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int number = 10;
	int value = 7;
	//计算number ^ value
	printf("number ^ value = %d\n",number ^ value);

	return 0;
}

练习：

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int value1 = 10;
	int value2 = 5;
	//交换value1 和 value2 的值
	//方案1：
	/*
	 *int temp = value1;
	 *value1 = value2;
	 *value2 = temp;
	 *
	 *printf("value1 = %d , value2 = %d\n",value1,value2);
	 * */
	
	//不申请第三个变量
	/*
	value1 = value1 + value2;
	value2 = value1 - value2;
	value1 = value1 - value2;

	printf("value1 = %d,value2 = %d\n",value1,value2);
	*/

	//缺点：当value1 + value2 大于类型范围的时候
	//value1 + value2 的值就是错误的，后面的交换也一定错
	
	//使用 ^ 运算符进行交换
	value1 = value1 ^ value2; //value1 = 10 ^ 5
	value2 = value1 ^ value2; //value2 = 10 ^ 5 ^ 5 = 10
	value1 = value1 ^ value2; //value1 = 10 ^ 5 ^ 10 = 5
	printf("value1 = %d,value2 = %d\n",value1,value2);

	return 0;
}
结果：
value1 = 5,value2 = 10

或运算符

简介：或运算符：二进制运算符，使用符号 "1" 表示

运算规则：

有真则真。（运算的相对应位置上，有一个是1，结果就是1）

0 | 任意数等于任意数

1 | 任意数等于 1

#include <stdio.h>

int main(int argc, const char *argv[])
{
	//定义两个变量 number value
	int number = 10;
	int value = 5;
	printf("number | value = %d\n",number | value);


	return 0;
}
结果：
number | value = 15

逻辑运算符

简介：用来连接多个表达式。逻辑表达结果：真(1) 假(0)

逻辑运算符：

&& ：逻辑与：两真则为真

格式：表达式1 && 表达式2

|| ：逻辑或：有一个表达式为真就是真。

格式：表达式1 || 表达式2

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 5;
	int b = 10;
	//计算逻辑运算符的结果
	int result = a > 3 && b > 5;
	printf("result = %d\n",result);



	//逻辑与 短路原则
	int ret = a < 5 && b++;//b =10;
						   //原因：a<5 假，结果可定
						   //不必再判断下一个表达式的结果
						   //不执行第二个表达式结果
	//int ret = a == 5 && b++
	printf("ret = %d,b = %d\n",ret,b);
	
	
	return 0;
}
结果：
result = 1
ret = 0,b = 10

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 5;
	int b = 10;
	int result = a > 2 || b < 20;
	printf("result = %d\n",result);

	//逻辑或同样遵循 短路原则
	int ret = a > 3 || (b++) > 5;
	//a > 3即可确定结果为真，不会继续执行（b++）> 5
	
	//int ret = a > 10 || (b++) > 5
	//a > 10为假，||有一个结果为真则为真
	//需要判断后面语句，则执行表达式(b++)>5
	
	printf("ret = %d,b = %d\n",ret,b);



	return 0;
}
结果：
result = 1
ret = 1,b = 10

条件运算符

简介：三目运算符，符号？：

格式：

表达式？ code1 : code2

运算规则：

判断表达式结果，如果表达式为真，则执行code1

如果表达式为假，则执行code2

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 10;
	int b = 20;
	
	int max = 0;
	//假设不知道a,b的值
	//使用三目运算符，将a,b中最大的值给max
	//
	//判断a,b哪个值大，如果a > b则a赋值给max
	//否则b的值赋值给max
	
	max = a > b ? a : b;

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


	return 0;
}
结果：
max = 20

课堂练习:

char ch = getchar(); // 从键盘中获取一个字符,将这个字符存入到ch这个变量中.

要求: 使用三目运算符:

如果这个字母是小写字母,输出大写字母,

如果是大写字母,则输出小写字母.

putchar()

#include <stdio.h>

int main(int argc, const char *argv[])
{
	char ch = getchar();//从键盘中输入一个字符

	char result = ('z' >= ch && ch <= 'A') ? ch + 32 : ch - 32 ;
	
	//打印result的结果
	putchar(result);
	putchar(10);//输出一个换行符


	return 0;
}
结果：
a
A

赋值运算符

简介：

赋值运算符的种类：

+= , -=, *=, /=, =(赋值), %=, >>=, <<=

逗号运算符

简介：

使用 ‘ ， ’进行标识，逗号运算符进行运算时需要使用（）括起来

运算原理：

int number = (表达式1，表达式2，表达式3，表达式4);

依次执行表达式1，表达式2，表达式3，表达式4，运算符的结果是表达式4 的结果。

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a,b,c,d,e;
	e = (a = 5, b = 6, c = a + 1, d = 20);

	printf("a = %d,b = %d , c = %d , d = %d ,e = %d\n",a,b,c,d,e);



	return 0;
}
结果：
a = 5,b = 6 , c = 6 , d = 20 ,e = 20

优先级问题

C语言复杂的表达式，遵循优先级原则。若不好区分，则通过加（）确定优先级。

（）的优先级最高。

优先级口诀

结合方式

单目运算符，赋值运算符，三目运算符从右向左开始运算；

eg： int number = 10；int result = ~number++；

其他运算符都是从左向右开始运算。

类型转换

前提：计算机中，必须是相同类型的数据，才可以进行运算。

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int number = 10;
	char ch = 5;
	//注意 number是32位，char 是8位
	int result = number + ch;
	//number 与 char 进行运算，计算机将number与ch变成了相同的类型
	
	printf("result = %d\n",result);

	return 0;
}
结果：
result = 15

隐式类型转换

没有显示写出的转换，但编译器给做了隐藏式类型转换。

隐式类型转换：

发生在赋值的情况下；

            #include <stdio.h>
            

            int main()
            {
                // 定义一个char类型的变量
                char ch = 5;   // 5 是一个数字，是一个int 类型，内存中占32个位
                               // 5: 0000 0000 0000 0000 0000 0000 0000 0101 
                               // ch 是char类型的数据， 只有1个字节的空间，所以
                               // 只会获取里面的一个字节， 这个字节 0000 0101
                
                unsigned int number = -5; 
                               // -5在内存中 
                               // 源码: 1000 0000 0000 0000 0000 0000 0000 0101
                               // 反码: 1111 1111 1111 1111 1111 1111 1111 1010
                               // 补码: 1111 1111 1111 1111 1111 1111 1111 1011 
            
                               // number 是4个字节， -5也是4个字节，所以全部都拿出来
                               // number 里面存在的数据： 1111 1111 1111 1111 1111
                               //                           1111  1111 1011 
                printf("number = %u\n", number);//%u 输出无符号占位符
                return 0;
            }

%u 输出无符号占位符

通过printf进行格式化输出的情况下，会发生隐式类型转换。

            #include <stdio.h>

            int main()
            {
                int number = 97;
            
                // 通过 printf输出number里面的值。
                printf("number = [%d], [%c], [%f]", number, number, number);
                            // %d: 整型输出。
                            // %c: 字符输出。
                            // %f: 浮点数输出。
            
            
                return 0;
            }

C语言：运算的数据，在运算时，必须是两个相同类型的数据，才能进行运算，如果给的类型不同，则编译器会将其转换成相同类型再进行计算。

隐士类型算数转换: 小类型向大类型进行转换--> 从下向上依次转换.

           unsigned double 
           double 
           unsigned float 
           float 
           unsigned long 
           long 
           unsigned int 
           int 
           ↑
           char, unsigned, short, unsigned short 
           不足四个字节的统一都向int类型转换.

           #include <stdio.h>
            
            
            int main()
            {
                float number = 9/2; // number = 4 
                                    // 首先计算 9 / 2 , 9是int  2 是 int 
                                    // 表达式 9 / 2 = 4;
                                    // number = 4// 4是int类型 ， number是float类型。
                                    // 在赋值的时候，会发生隐士类型转换。
                printf("number = %f\n", number);
            
            
                float value = 9.0 / 2; // 9.0是double类型， 2是int类型 
                                       // 9.0 和 2是不同的类型，
                                       // 所以编译器会将其这两个类型转换为相同的类型
                                       // 然后进行计算，
                printf("value = %f\n",value);
            
            
                int result = 9 / 2.0; // 9 / 2.0 向 double进行转换 值4.5
                                      // result 是int类型， 发生隐士类型转换，转换为4
                printf("result = %d\n", result);
            
            
            
            
                return 0;
            }

显示类型转换（强制类型转换）

简介：显示类型转换就是我们自己书写的转换。

格式：

（转换的类型）需要转换的变量

P...H...Q

关注

6
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
（Linux）嵌入式打卡第四天

依次执行表达式1，表达式2，表达式3，表达式4，运算符的结果是表达式4 的结果。大于 > 小于 < 等于 == 大于等于>= 小于等于 <= 不等于!+= , -=, *=, /=, =(赋值), %=, >>=, <<=除法 /：C语言中/的意思是整除，计算机中数比可以进行 /0 操作的。int number = (表达式1，表达式2，表达式3，表达式4);与运算符是一个二进制运算符，&与运算符需要使用二进制进行运算。前提：计算机中，必须是相同类型的数据，才可以进行运算。number = 4;
复制链接

扫一扫