目录
操作符
//算术操作符 + - * / %
//移位操作符 << >>
//位操作符 & | ^
//赋值操作符 =
//复合赋值符 += -= *= /= %= >>= <<= &= |= ^=
//单目操作符 ！ - + & 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】
1270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
