目录
操作符
//算术操作符 + - * / %
//移位操作符 << >>
//位操作符 & | ^
//赋值操作符 =
//复合赋值符 += -= *= /= %= >>= <<= &= |= ^=
//单目操作符 ! - + & sizeof ~ -- ++ * (类型)
//关系操作符 > >= < <= != ==
//逻辑操作符 && ||
//条件操作符 exp1 ? exp2 : exp3
//逗号表达式 exp1, exp2, exp3, …expN
//下标引用 [ ] 下标引用操作符
//函数调用 ( ) 函数调用操作符
//结构成员 . 结构体.成员名 -> 结构体指针->成员名
//二进制操作符 >> << & | ^ ~
%d 是十进制的形式打印有符号整型
%u 是十进制的形式打印无符号整型
//给编译器一个数,%d,%u自己当成了有符号和无符号,不存在看原来创建的变量是有符号还是无符号。
%s 是打印字符串
%c 是打印字符
%p 是打印地址
%fl %f 是打印浮点型
% .2 lf 是保留二位小数
% .3 lf 是保留三位小数
二进制
在内存中,对于存储一个整数需要4个字节,也就是32个比特位。
一个整数写出二进制序列的时候,就是32个比特位。
有符号整数:最高位就是符号位。符号位是1,则表示负数。符号位是0,则表示正数。
无符号整数(unsigned int):没有符号位,所有位都是有效位。
无符号整数一般放置都是正数,表示正数,所以一般原码,反码,补码相同。
但是非要放置负数,按照负数的原码 反码 补码来计算。不妨碍放负数。
0:+0和-0
在内存中,整数的二进制表示形式有3种:原码,反码,补码。
对于正的整数:原码,反码,补码相同,无需计算。
对于负的整数:原码,反码,补码是需要计算的。
原码:按照数值的正负,直接写出的二进制序列就是原码。
反码:原码的符号位不变,其他位按位取反。
补码:反码的二进制 +1 就是得到补码。
整数在内存中的存储的都是补码的二进制序列。
整数在计算的时候使用的是补码的二进制序列。
原码,反码,补码相互转换:
计算机采用的就是一直取反+1的这条线路。
//10:
原码:00000000000000000000000000001010
反码:00000000000000000000000000001010
补码:00000000000000000000000000001010
//-10
原码:10000000000000000000000000001010
反码:11111111111111111111111111110101
补码:11111111111111111111111111110110
算数操作符
+ - * / %
- 除了%操作符之外,其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作数如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。
- %操作符的两个操作数必须为整数。返回的是整数之后的余数。
在前面初识C语言中我们重点介绍 / 和 %,这里再回顾一下。
整数除法
//整数除法
#include<stdio.h>
int main()
{
int m = 7 / 2;
int x = 7.0 / 2;
int y = 7.0 / 2.0;
double n = 7 / 2;
printf("m=%d\n", m);
printf("x=%d\n", x);
printf("y=%d\n", y);
printf("n=%f\n", n);
return 0;
}
整数除法:两端的操作数整数和浮点数均可。
存放到的变量类型 整数和浮点数 均可(浮点数会有小数位)。
在打印中选择相应的字符和变量类型对齐。
小数除法
//小数除法
#include<stdio.h>
int main()
{
double m = 7.0 / 2;
double b = 7 / 2.0;
double n = 7.0 / 2.0;
printf("m=%lf\n", m);
printf("b=%lf\n", b);
printf("n=%lf\n", n);
return 0;
}
小数除法: 两端操作数必须至少有一方为小数,才可以得到小数。
运算的小数要放到浮点类型的变量里。
打印的小数所对应的printf所需字母是浮点类型的。
取余(取模)
//取模取余
#include<stdio.h>
int main()
{
int n = 7%2;
printf("n=%d\n", n);
return 0;
}
取模(取余):
两端操作数必须均为整数。
得到的结果要放到整形的变量中去。
移位操作符
<< 左移操作符
>> 右移操作符
- 移位操作符移动的是二进制的位
- 移位操作符的操作数必须是整数
- 左移操作符>> 移位规则:左边抛弃,右边补0
- 右移操作符<< 移位规则:
逻辑移位:左边用0填充,右边丢弃
算术移位:左边用原该值的符号位填充,右边丢弃
- 对于移位运算符,不要移动负数位,这个是标准未定义的。
- 移位操作符的应用:可以移动你想要的位上去,改变数值。
<< 左移操作符
正数
//正数
#include<stdio.h>
int main()
{
int m = 7;
int n = m << 1;
printf("%d\n", m);
printf("%d\n", n);
return 0;
}
运算如下:
负数
//负数
#include<stdio.h>
int main()
{
int m = -7;
int n = m << 1;
printf("%d\n", m);
printf("%d\n", n);
return 0;
}
运算如下:
总结
左移操作符 移位规则:
左边抛弃,右边补0。(有一个*2的效果)
整数在内存中的是二进制,计算时是二进制的补码,转化成十进制是二进制的原码。
正数原码反码补码均相等。
负数反码补码均需要计算。
>> 右移操作符
正数
//正数
#include<stdio.h>
int main()
{
int a = 10;
int b = 10 >> 1;
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
运算如下:
负数
//负数
#include<stdio.h>
int main()
{
int a = -10;
int b = -10 >> 1;
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
VS编译器采用的是算数移位,绝大多数编译器均采用的是算数移位!
逻辑移位运算
算数移位运算
总结
右移操作符 移位规则:
- 逻辑移位 左边用0填充,右边丢弃。(负数符号改变,/2的效果)
- 算数移位 左边用原改值得符号位填充,右边丢弃。(/2的效果)
对于正数,逻辑和算数移位均达到相同的效果/2,原码补码反码相同无需计算均相等。
对于负数,逻辑移位改变正负,移位不改变。同时,都有/2效果,原码反码补码需计算。
位操作符
- & 按位与
对应的二进制位上,只要有0则为0,两个同时为1才为1。
- | 按位或
对应的二进制位上,只要有1则为1,两个同时为0才为0。
- ^ 按位异或
对应的二进制位上,相同为0,相异为1。
- 位操作符的两个操作数必须为整数。
- 位操作数的运算是在二进制的补码基础上运算。
&与
//计算3&-5
//00000000 00000000 00000000 00000 011 //3原码补码反码
//10000000 00000000 00000000 00000 101 //-5原码
//11111111 11111111 11111111 11111 010 //-5反码
//11111111 11111111 11111111 11111 011 //-5补码
//00000000 00000000 00000000 00000 011 //3原码补码反码
//00000000 00000000 00000000 00000 011 //3补码反码原码
//&与——在对应的二进制位上,只要有0则为0,两个同时为1才为1
#include<stdio.h>
int main()
{
int a = 3;
int b = -5;
int c = a & b;
printf("%d", c);
return 0;
}
| 或
//计算3|-5
//00000000 00000000 00000000 00000 011 //3原码补码反码
//10000000 00000000 00000000 00000 101 //-5原码
//11111111 11111111 11111111 11111 010 //-5反码
//11111111 11111111 11111111 11111 011 //-5补码
//00000000 00000000 00000000 00000 011 //3原码补码反码
//11111111 11111111 11111111 11111 011 //补码
//11111111 11111111 11111111 11111 010 //反码
//10000000 00000000 00000000 00000 101 //原码 -5
//|或——在对应的二进制位上,只要有1则为1,两个同时为0才为0
#include<stdio.h>
int main()
{
int a = 3;
int b = -5;
int c = a | b;
printf("%d", c);
return 0;
}
^异或
//计算3^-5
//00000000 00000000 00000000 00000 011 //3原码补码反码
//10000000 00000000 00000000 00000 101 //-5原码
//11111111 11111111 11111111 11111 010 //-5反码
//11111111 11111111 11111111 11111 011 //-5补码
//00000000 00000000 00000000 00000 011 //3原码补码反码
//11111111 11111111 11111111 11111 000 //补码
//11111111 11111111 11111111 11110 111 //反码
//10000000 00000000 00000000 00001 000 //原码 -8
//两个重要点
//a^a=0
//0^a=a
//支持交换律
//^异或——相同为0,相异为1
#include<stdio.h>
int main()
{
int a = 3;
int b = -5;
int c = a ^ b;
printf("%d", c);
return 0;
练习
1.不能创建临时变量(第三个变量),实现两个数的交换。
2.编写代码实现:求一个整数存储在内存中的二进制中1的个数。(后面讲解,可以先动手写一写,小脑瓜子想想)
//不能创建临时变量(第三个变量),实现两个数的交换
在前面的初识C语言和函数中,我们已经知晓如下方法:
//创建临时变量
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
int c = 0;//创建中间变量
printf("a=%d b=%d\n", a, b);
c = a;
a = b;
b = c;
printf("a=%d b=%d", a, b);
return 0;
}
//函数
#include<stdio.h>
void change(int* a, int* b)
{
int tmp = 0;
tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
int a = 3;
int b = 5;
printf("a=%d b=%d\n", a, b);
change(&a,&b);
printf("a=%d b=%d", a, b);
return 0;
}
那如果我们不创建临时变量呢?
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
printf("a=%d b=%d\n", a, b);
a = a + b;
b = a - b;//b=a+b-b=a
a = a - b;//a=a+b-a
printf("a=%d b=%d", a, b);
return 0;
}
以上这个加减方法存在缺陷,变量的值如果太大就出现了问题,会超出整形所容纳的范围。 还有没有其他方法呢?
#include<stdio.h>
int main()
{
int a = 3;
int b = 5;
printf("a=%d b=%d\n", a, b);
a = a ^ b;//3^5
b = a ^ b;//3^5^5=3
a = a ^ b;//3^5^3=5(支持交换律)
printf("a=%d b=%d", a, b);
return 0;
}
以上异或的方法
优点:不会溢出。
缺点:效率不高,只适用整形,可读性差,因此不建议使用。
赋值操作符
赋值操作符是一个很棒的操作符!🙂🙂在变量创建好了之后,我们将其修改成自己满意的值。
#include<stdio.h>
int main()
{
int a = 3;//不是赋值是初始化
a = 4;//赋值
return 0;
}
连续赋值
赋值操作符可以连续使用,如下:
#include<stdio.h>
int main()
{
int a = 10;
int x = 0;
int y = 20;
a = x = y + 1;//连续赋值,从右往左依次赋值
return 0;
}
连续赋值虽然缩短代码,达到了简练的效果。但是它的可读性很差,不易于调试,建议应该分开。
//连续赋值
a=x=y+1;
//非连续更加清爽
x = y+1;
a = x;
复合赋值
#include<stdio.h>
int main()
{
int a = 10;
a = a << 1;
a <<= 1;
int b = 7;
b = b >> 1;
b >>= 1;
return 0;
}
单目操作符
单目操作符指的就是只有一个操作数。
- ! 逻辑反操作
- - 负值
- + 正值
- & 取地址
- sizeof 操作数的类型长度(以字节为单位)
- ~ 对一个数的二进制按位取反
- -- 前置,后置--
- ++ 前置,后置++
- * 间接访问操作符(解引用操作符)
- (类型) 强制类型转换
!
!逻辑反操作符:
把真的变成假的,把假的变成真的。
//!
#include<stdio.h>
int main()
{
int a = 0;
int flag = !a;
printf("%d\n", flag);
if (!a)//表达式为真 才打印
{
printf("haha\n");
}
return 0;
}
-和+
+正值:没有什么具体的意义。
- 负值: 改变数值的符号。正变负,负变正。
//+ -
#include<stdio.h>
int main()
{
int a = 10;
printf("%d\n", a);
a = +a;
printf("%d\n", a);
a = -a;
printf("%d\n", a);
int b = -10;
printf("%d\n", b);
b = +b;
printf("%d\n", b);
b = -b;
printf("%d\n", b);
return 0;
}
&和*
& 取地址:int* p=&a;(需要存放到指针变量里去)
* 解引用操作符:
*p 对p进行解引用操作,*p是通过p中存放的地址,找到p指向的对象。*p其实是a。
#include<stdio.h>
int main()
{
int a = 10;
int* p = &a;//a变量的地址
printf("%p\n", &a);
printf("%d", *p);//*p=a
int arr[10] = {1,2,3,4,5};
int(*pa)[10] = &arr;//数组的地址
return 0;
}
sizeof
- sizeof 是在计算类型创建变量或者变量的大小,单位是字节。
- sizeof 计算的结果是size_t 类型的
- sizeof 后面的括号在括号中写的不是类型的时候,括号可以省略。说明sizeof不是函数
- sizeof 是操作符(单目操作符),不是函数,函数不能省略括号。
- sizeof在计算字符串数组的元素个数时,需要计算"\0"
- size_t 是无符号整型的
- size_t类型的数据 进行打印 ,可以使用%zd
//sizeof
#include<stdio.h>
#include<string.h>
int main()
{
int a = 10;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//4
int arr[10] = { 0 };
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr[0]));
printf("%d\n", sizeof(arr) / sizeof(arr[0]));
char arr1[] = "abcde";
printf("%d\n", sizeof(arr1));
printf("%d\n", strlen(arr1));
return 0;
}
~
~对一个数的二进制按位取反。
#include<stdio.h>
int main()
{
int a = 0;
printf("%d", ~a);
return 0;
}
//00000000 00000000 00000000 00000000
//11111111 11111111 11111111 11111111 补码
//11111111 11111111 11111111 11111110 反码
//10000000 00000000 00000000 00000001 原码-1
--和++
- ++前置:先+1,再使用
- 后置++:先使用,后+1
- --前置:先-1,再使用
- 后置--:先使用,后-1
- ++操作符是一种自增1的操作
- - - 操作符是一种自减1的操作
(谁在前面,就先进行什么操作)
后置++的一个规则:先行性赋值操作。
*dest++ = *src++
两个指针先使用 * 和 = ,再去++
#include<stdio.h>
//++ 前置++ 后置--
//-- 前置-- 后置--
int main()
{
int a = 7;
int b = a++;//后置a++ 口诀:先使用,后+1
//相当于b=a a=a+1
printf("a=%d b=%d\n",a,b);//8 7
return 0;
}
int main()
{
int a = 7;
int b = ++a;//前置++a 口诀:先+1,再使用
//相当于a=a+1 b=a
printf("a=%d\n", a);//8
printf("b=%d\n", b);//8
return 0;
}
int main()
{
int a = 7;
int b = a--;//后置a-- 口诀:先使用,后-1
//相当于b=a a=a-1
printf("a=%d b=%d\n",a,b);//6 7
return 0;
}
int main()
{
int a = 7;
int b = --a;//前置--a 口诀:先使用,后-1
//相当于a=a-1 b=a
printf("a=%d b=%d\n",a,b);//6 6
return 0;
}
(类型)
(类型) 强制类型转换
不到不得已的情况下,不要使用。强扭的瓜毕竟不甜。最好是设置类型匹配的变量。
#include<stdio.h>
int main()
{
int a = (int)3.14;
//3.14被编译器识别为double类型
//time_t——>unsigned int
srand((unsigned int)time(NULL));
rand();
//生成随机数
return 0;
}
练习
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(4)
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//(1)
printf("%d\n", sizeof(ch));//(3)
test1(arr);
test2(ch);
return 0;
}
//问:
//(1)、(2)两个地方分别输出多少?40 10
//(3)、(4)两个地方分别输出多少?4 4/8 8
- (1)sizeof(arr)计算的是arr数组全部的大小,数组存放了10个元素的整形, 一个整型大小是4所以是40
- (2)sizeof(ch)计算的是ch数组全部的大小,数组存放了10个元素的字符型, 一个字符型大小是1所以是4
- (3)test1 test2函数调用,传arr过去,本质上是把数组的首地址传过去,指针接收。 无论是整型,字符型的地址,均是一个指针变量(地址),大小相等。(4/8)
指针变量是用来存放地址的
指针变量的大小,就取决于存放一个地址需要多大的空间
在32位的环境下:
一个地址大小是32bit位,需要4个字节。所以不管什么类型的指针变量,大小都是4个字节。
在64位的环境下:
一个地址大小是64bit位,需要8个字节。所以不管什么类型的指针变量,大小都是8个字节。
综上:指针大小在32位平台是4个字节,64位平台是8个字节。
不要在门缝里看指针,把指针看扁了。不管是什么类型的指针都是4/8个字节的。
关系操作符
这些关系操作符都是 用来 测试两边操作数的大小关系。
特别注意:在编程的过程中==和=不小心写错,导致错误。(辨析)
逻辑操作符
- && 逻辑与 并且:操作数有一方为假,都为假。只有双方都为真,才为真。
- | | 逻辑或 或者:操作数有一方为真,则为真。只有双方都为假,才为假。
#include<stdio.h>
int main()
{
//3~5月春季
int a = 0;
scanf("%d", &a);
if (a >= 3 && 5 >= a)
printf("春天");
//12或1或2 都是冬天
if (a == 12 || a == 1 || a == 2)
printf("冬天");
return 0;
}
这里还有一道练习题,动手写一写。
#include <stdio.h>
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
#include <stdio.h>
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
return 0;
}
//程序输出的结果分别是什么?
//提示:&& 左边操作数如果为假,右边无需计算。
// || 左边操作数如果为真,右边无需计算。
如果把a初始化值换成1,结果又是怎样呢?(后面操作符题讲解🆗🆗)
条件操作符
exp1?exp2:exp3
有三个操作数,是三目操作符
将下面两端代码改写成条件操作符。
//练习1
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
scanf("%d", &a);
if (a > 5)
b = 3;
else
b = -3;
printf("%d", b);
return 0;
}
//练习2
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int m = 0;
scanf("%d %d", &a,&b);
if (a > b)
m = a;
else
m = b;
printf("%d", m);
return 0;
}
修改后
//练习1
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
scanf("%d", &a);
b = (a > 5 ? 3 : -3);
printf("%d", b);
return 0;
}
//练习2
#include<stdio.h>
int main()
{
int a = 0;
int b = 0;
int m = 0;
scanf("%d %d", &a, &b);
m = (a > b ? a : b);
printf("%d", m);
return 0;
}
逗号操作符
exp1,exp2,exp3,.......expN
- 逗号表达式,就是用逗哈隔开的多个表达式。
- 逗号表达式,从左向右依次执行。(依次计算,前面的表达式会影响后面)。
- 整个表达式的结果是最后一个表达式的结果。
//练习1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少?
//13
//练习2
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
a = get_val();
count_val(a);
}
//改写成逗号表达式
//如果使用逗号表达式,改写:
while (a = get_val(), count_val(a), a>0)
{
//业务处理
}
注意:不能因为最后一个表达式起决定性作用就不计算前面的表达式,前面的表达式很有可能影响最后的表达式。
下标引用,函数调用和结构成员
下标引用
[ ]下标引用操作符
操作数:一个数组名和一个索引值。
#include<stdio.h>
int main()
{
int arr[5] = { 1,2,3,4,5 };
// 0 1 2 3 4 索引值
printf("%d", arr[2]);//操作数arr和2
return 0;
}
函数调用
( )函数调用操作符
接受一个或者多个操作数。第一个操作数是函数名,剩余的操作数就是传递给函数的参数。(函数调用操作符至少有1个操作数)
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(int a,int b)
{
printf("%d\n", a+b);
}
int main()
{
test1();
test2(3,5);//实用()作为函数调用操作符。
return 0;
}
结构体成员
. 结构体.成员名
-> 结构体->成员名
#include<stdio.h>
struct Book
{
char name[20];
int price;
};
void Print(struct Book* pb)//结构体指针变量
{
printf("%s %d\n", (*pb).name, (*pb).price);
printf("%s %d\n", pb->name, pb->price);
}
int main()
{
struct Book b = { "C语言",55 };
printf("%s %d\n", b.name, b.price);
Print(&b);
return 0;
}
✔✔✔✔✔最后,感谢大家的阅读,有任何错误和不足,欢迎指正!!!!
代码-------------------→【gitee:https://gitee.com/TSQXG】
联系--------------------→【邮箱:2784139418@qq.com】