单目运算符
~按位取反
功能:将数据中每一位都进行取反操作。
#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.
异或运算符运算规则:
-
-
- 异或两个相同的数为0;
- 0异或任何数,等于任何数。0 ^ 20 = 20;
- 异或与顺序无关: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;
}
显示类型转换(强制类型转换)
简介:显示类型转换 就是 我们自己 书写的转换。
格式:
(转换的类型) 需要转换的变量