hello~~，我是~小鹿，超级详细的操作符讲解来康康吧
可以收藏随时找到这里哦~

1.算数操作符：+，-，*，/，%

算数操作符：+ ， - ， * ， /（除） ， %（取余）

%（取余）： 两端都必须为整数

int a=9%2;
printf("a=%d",a);//运行结果为 a=1

/（除）： 两端都为整型时，结果为整数；若有一端为浮点数，则结果为小数

int a=9/2;
printf("a=%d",a);//运行结果为 a=4

float a=9/2;//（ / 两边都为整型，结果为整数）
printf("a=%d",a);//运行结果为 a=4.000000

float a=9/2.0;
printf("a=%d",a);//运行结果为 a=4.500000

2.位移操作符：<< , >>（详解）

位移操作符： <<(左移操作符)，>>(右移操作符)
注意：
位移操作符移动的是二进制位

整数在存储中存放的是补码
正整数：原码=反码=补码
负数：存放在内存中，存放的是补码
原码：直接根据数值写出的二进制序列
反码：原码的符号位不变，其他位按位取反
补码：反码+1
例如：-1
原码：10000000 00000000 00000000 00000001
反码：11111111 11111111 11111111 11111110
补码：11111111 11111111 11111111 11111111

(左移操作符) <<： 左边丢弃，右边补0
例如：2的二进制数整体向左移动一位

代码：

int a=2;
int b=a<<1;
printf("b=%d",b);//运行结果为 b=4

(右移操作符) >>：
1.算数右移： 右边丢弃，左边补原符号位
2.逻辑右移： 右边丢弃，左边补0

例如：
int a=-1；
int b=a>>1;

算数右移：

逻辑右移：

代码示例
可以判断编译器使用的是算数右移还是逻辑右移

//我使用的编译器是vs2019
#include <stdio.h>
int main()
{
    
    int a = -1;
    int b = a >> 1;
    printf("%d\n", b);

    return 0;
}

运行结果：-1
证明，vs2019编译器使用的是算数右移

注意：对于移动运算符，不要移动负数位（例：a>>-1），这是标准未定义的

3.位操作符：&，|，^

位操作符：&（按位与）， |（按位或），^（按位异或）
位操作符是按二进制位进行计算

(按位与) & ：对应的二进制位与(都为1才为1，否则为0）
int a=3;
int b=5;
int c=a&b; // c = 1
// 00000000 00000000 00000000 00000011 a =>3
// 00000000 00000000 00000000 00000101 b =>5
// 00000000 00000000 00000000 00000001 a&b =>1

(按位或) |：对应的二进制位或（有1则为1，都为0时才为0）
int a=3;
int b=5;
int c=a | b; // c = 7
// 00000000 00000000 00000000 00000011 a =>3
// 00000000 00000000 00000000 00000101 b =>5
// 00000000 00000000 00000000 00000111 a | b =>7

(按位异或) ^ ： 对应的二进制位异或（相同为0，相异为1）
int a=3;
int b=5;
int c=a ^ b; // c = 6
// 00000000 00000000 00000000 00000011 a =>3
// 00000000 00000000 00000000 00000101 b =>5
// 00000000 00000000 00000000 00000110 a ^ b =>6

例题1.不允许创建临时变量，交换两个整数的内容

首先，我们可以想到：

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
int main()
{
    
    int a = 3;
    int b = 5;
    a = a + b;//8
    b = a - b;//8-5=3
    a = a - b;//8-3=5
    printf("%d\n", a, b);

    return 0;
}

但这个方法有缺陷：a，b为整型，整型变量有上限，两数相加可能会溢出（数值太大会溢出）
我们可以使用异或，如下：
（原理）a ^ a = 000…000 => 0 ^ a = a , a ^ b ^ b = a

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
int main()
{
    
	int a = 3;
	int b = 5;
	a = a ^ b;
	//  a: 00000000 00000000 00000000 00000011   
	//  b: 00000000 00000000 00000000 00000101
	//a^b: 00000000 00000000 00000000 00000110
	b = a ^ b;//相当于a ^ b ^ b 得 a
	//  a: 00000000 00000000 00000000 00000110
	//  b: 00000000 00000000 00000000 00000101
	//a^b: 00000000 00000000 00000000 00000011 -->得到a原来的值3，然后赋值给b
	a = a ^ b;//相当于a ^ b ^ a 得 b
	//  a: 00000000 00000000 00000000 00000110
	//  b: 00000000 00000000 00000000 00000011
	//a^b: 00000000 00000000 00000000 00000101 -->得到b原来的值5，然后赋值给a
	printf("a=%d,b=%d\n", a, b);//输出交换后a,b的值

	return 0;
}

运行结果：a=5,b=3

异或：无进位，不会溢出

例题2.输入一个整数 n ，输出该数32位二进制表示中1的个数。其中负数用补码表示。

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
int main()
{
    
    int n = 0;
    scanf("%d", &n);
    int i = 0;
    int j = 0;
    for (i = 0; i < 32; i++)//32位机器中，一个int类型占4byte（字节），即32bit（比特），所以只用比对32位的数字
    {
    
        if ((n & 1) == 1)//n的二进制位的最后一位为1时，计算&1时才为1，否则为0
        {
    
            j++;//计算1的个数
        }
        n = (n >> 1);//将n的二进制向右移动一位
    }
    printf("%d\n", j);
    return 0;
}

运行结果：
-1（键盘输入）
32

例题3.获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
int main()
{
    
    int n = 0;
    scanf("%d", &n);
    int i = 0;
    printf("偶数位：");
    for(i = 31; i > 0; i -= 2)
    {
    
        printf("%d", (n >> i) & 1);
    }
    printf("\n");
    printf("奇数位：");
    for(i = 30; i >= 0; i -= 2)
    {
    
        printf("%d", (n >> i) & 1);
    }
    printf("\n");

    return 0;
}

运行结果：

例题4.编程实现：两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同？

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
int main()
{
    
   int n = 0;
   int m = 0;
   int i = 0;
   int j = 0;
   int num = 0;
   scanf("%d%d", &n,&m);
   num = n ^ m;//  ^ 符号，相同为0，相异为1，所以相当于计算它的1的个数
   for (i = 0; i < 32; i++)
   {
    
       if ((num & 1) == 1)
       {
    
           j++;
       }
       num = num >> 1;//将num的二进制位向右移动一位
   }
   printf("它们的二进制有%d位不同", j);

   return 0;
}

运行结果：
3 5（键盘输入）
它们的二进制有2位不同

4.赋值操作符:+=，-=，*=，/=，>>=，<<=，%=

赋值操作符：=(赋值)，复合赋值运算符：+ = ，- = ，* = ，/ = ，>> = ，<< = ，% =

(赋值) = :
= 的右边可以是变量或者常量或者表达式；
= 的左边必须是变量，不能是常量或者表达式。

复合赋值运算符：+ = ：
例如 a + = b （a，b都是变量）相当于 a = a + b 。

5.单目操作符：！，-，+，&，~，++，- -，*，(类型)，sizeof

单目操作符(只有一个操作符)：! (非)，- (负值)，+ (正值)，& (取地址)，~ (按进制位取反)，++，–，*(解引用操作符)，（类型）强制类型转换，sizeof (求操作数类型长度，单位：字节)

（非）! : 例如 a=0 时，!a = 1；a 的值为非0时，!a = 0; （0为假，非0为真）

（取地址）&： 例如函数 scanf("%d",&a) 中的 & 就是取地址符号，&a指变量a的地址

#include <stdio.h>
int main()
{
    
	int a = 10;
	printf("%p\n", &a);// 0056F81C 输出的是a的地址
	//%p: 打印地址
	//&: 取地址操作符

	return 0;
}

~： 按二进制位取反 ( 0 -> 1 , 1 -> 0 )
注意整数在内存中是以补码的形式存储
注：在上面讲解左移右移处有讲解原码，补码，反码

#include <stdio.h>
int main()
{
    
	int a = 0;
	printf("%d\n", ~a);//输出 -1
	//a的二进制:00000000 00000000 00000000 00000000  a所在内存
	//a取反(~a):11111111 11111111 11111111 11111111  取反后所在内存
	//整数在内存中存储的是补码，所以此时的~a是补码，需要还原为原码后输出
	//补码：11111111 11111111 11111111 11111111
	//反码：11111111 11111111 11111111 11111110 补码-1变为反码
	//原码：10000000 00000000 00000000 00000001 反码除符号位不变，其他按位取反变为原码 
	//此时的原码转为十进制为：-1

	return 0;
}

++，- -： a++，a- - 先使用(赋值)，后计算；++a，- -a 先计算，后使用

	int a = 10;
	printf("%d", a++);// 10
	printf("%d", a);// 11

	printf("%d", ++a);// 11
	printf("%d", a);// 11

	printf("%d", a--);// 10
	printf("%d", a);// 9

	printf("%d", --a);// 9
	printf("%d", a);// 9

(解引用) * ： 间接访问操作符（解引用操作符）

	int a = 10;
	int* pa = &a;// 这里的 * 是表示说明pa为指针变量
	*pa = 20;// * : 解引用操作符（间接访问操作符）
	//pa是地址，* 是通过地址(pa)找到值

（类型）： 强制转换； 例子：如以下代码

#include <stdio.h>
int main()
{
    
	float a = 3.3;
	int b = 10;
	b %= (int)a;//%:取余符号两边应均为整型
	printf("%d\n", b);//运行结果为1

	return 0;
}

sizeof详解

sizeof ： 返回一个对象或者类型所占的内存字节数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    
	int a = 0;
	char arr[10] = {
     0 };
	int arr2[10] = {
     0 };

	printf("%d\n", sizeof(a));//结果为 4 ;  a 是int类型，int类型所占内存字节数为4
	//sizeof(a) :计算变量，a 去掉 "()" 依旧可以运行（但一般都不省），证明sizeof不是函数，而是一个操作符

	printf("%d\n", sizeof(int));//结果为 4 ; int类型所占内存字节数为4
	//sizeof(int) :计算类型，计算类型时"()"不可省略

	printf("%d\n", sizeof(arr));//结果为 10 ，arr中共10个元素，每个元素占1个字节，所以arr2总共占10*1=10个字节
	printf("%d\n", sizeof(arr[10]));//结果为 10
	//数组名表示数组首元素地址
	//但有两个例外：
	//1.sizeof(数组名)->数组名表示整个数组--计算整个数组的大小，单位字节
	//2.&数组名->数组名表示整个数组，取出的是整个数组的地址（与数组首元素地址相同，但意义不同）

	printf("%d\n", sizeof(arr2));//结果为 40 ; arr2中共10个元素，每个元素占4个字节，所以arr2总共占10*4=40个字节

	return 0;
}

重点：
数组名表示数组首元素地址 但有两个例外：
1.sizeof(数组名)->数组名表示整个数组–计算整个数组的大小，单位字节
2.&数组名->数组名表示整个数组，取出的是整个数组的地址（与数组首元素地址相同，但意义不同）

#include <stdio.h>
int main()
{
    
	short s = 5;//short类型在内存中所占字节为2
	int a = 0;//int类型在内存中所占字节为4

	printf("%u\n", sizeof(s=a+2));//返回值为2
	      //%u: sizeof返回的是无符号整数
	      //sizeof(s=a+2): s 的空间不会变大，s是short类型，占内存2字节，所以输出2
	      //sizeof(s=a+2)中a+2压根没计算
	printf("%u\n", sizeof(s));//返回值为5
	//在上一步运行过sizeof(s=a+2)之后运行sizeof(s)后s值没变依旧为5;
	//sizeof括号中放的表达式是不参与运算的

	return 0;
}

每种数据类型所占内存大小，单位：字节，代码示例

#include <stdio.h>
int main()
{
    
	printf("%d\n", sizeof(char));// 1
	printf("%d\n", sizeof(short));// 2
	printf("%d\n", sizeof(int));// 4
	printf("%d\n", sizeof(long));// 4
	printf("%d\n", sizeof(long long));// 8
	printf("%d\n", sizeof(float));// 4
	printf("%d\n", sizeof(double));// 8

	return 0;
}

指针是用来存放地址的，所以指针需要多大空间取决于地址的储存需要多大空间；
32位机器(x86)中所组成的二进制序列（32bit）为地址，所以32位机器上的地址为：32bit(比特) 即4byte(字节)
同理，64位机器(x64)上的地址为64bit，即8byte；
所以每种数据类型指针所占内存大小取决于地址存放的时候需要多大空间，代码示例：

#include <stdio.h>
int main()
{
    
	printf("%d\n", sizeof(char*));// 4/8    32位机器时为4，64位机器时为8
	printf("%d\n", sizeof(short*));// 4/8   
	printf("%d\n", sizeof(int*));// 4/8    
	printf("%d\n", sizeof(long*));// 4/8   
	printf("%d\n", sizeof(long long*));// 4/8
	printf("%d\n", sizeof(float*));// 4/8
	printf("%d\n", sizeof(double*));// 4/8

	return 0;
}

注意数组作为函数参数后使用sizeof获取的是地址大小：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void test(char* arr[])//或 void test(char* arr)
{
    
	printf("%d\n", sizeof(arr));// 4或8 //本质传的是一个地址
}

int main()
{
    
	char arr[10] = {
     0 };
	printf("%d\n", sizeof(arr));// 10  //sizeof(数组名)->数组名表示整个数组--计算整个数组的大小，单位字节
	test(arr);//数组名表示数组首页元素地址，所以这里本质传的是地址

	return 0;
}

6.关系操作符：>，>=，<，<=，!=，==

关系操作符：>，>=，<，<=，!=(不等于)，==(相等)

= ： 赋值
== ： 判断相等；
比较两个字符串相等时，不能使用==

7.逻辑操作符：&&，||

逻辑操作符：&&（逻辑与），||（逻辑或）

（逻辑与）&&： 都为真才为真
（逻辑或）||： 都为假才为假

#include <stdio.h>
int main()
{
    
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	//先计算a++得到a++为0，a为1; &&符号都为真才为真，此时a++为0(假)，已经可以得出结果，后面的均不计算
	printf(" a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);//a=1 b=2 c=3 d=4

	//同理 i = a++ || ++b || d++; //得a=1 b=3 c=3 d=4

	return 0;
}

运行结果：

8.条件操作符：exp1？exp2：exp3

条件操作符（三目操作符）： 表达式1？表达式2：表达式3 (exp1？exp2：exp3)
exp1为真，执行exp2
exp1为假，执行exp3

#include <stdio.h>
int main()
{
    
	int a = 1;
	int b = 0;
	b = (a > 5 ? 1 : -1);
	printf("b=%d",b);//b=-1
	return 0;
}

9.逗号表达式：exp1，exp2，exp3，······

逗号表达式：exp1，exp2，exp3，······
逗号表达式是要从左往右依次计算，但整个表达式结果是最后一个表达式结果。

例：

	int arr[] = {
     2, (5, 8), 7 };
	printf("%d\n", arr[1]);// 8
	printf("%d\n",sizeof(arr));// 12 一个元素占4个字节，共3个元素，即12字节

10.下标引用操作符：[ ]，函数调用：( )，访问结构的成员： . ， ->

下标引用操作符：[ ]，函数调用：( )，访问结构的成员： . ， ->

下标引用操作符：[ ]： 数组名+索引值

	int arr[10] = {
     0 };//创建数组
	arr[1] = 2;//使数组中下标为1的元素为2
	//以上两个[]就是下标引用操作符

函数调用：( )： 调用函数的时候，函数名后的（）就是函数调用操作符
例如：printf("%d",a);中的()就是函数调用操作符

访问结构的成员
. ：结构体变量名 . 成员名
-> ：结构体变量的地址（结构体指针）->成员名

#include <stdio.h>
struct stu//创建一个学生（结构体）
{
    
	//以下为成员变量/成员名
	char name[20];//姓名
	int age;//年龄
	double score;//成绩
};

int main()
{
    
	struct stu s = {
     "zhangsan",20,90 };//结构体的创建和初始化
	//s是结构体变量名
	struct stu* ps = &s;// s 的地址

	printf("%s %d %lf\n", s.name, s.age, s.score);//结构体变量名 . 成员变量名
	//运行结果：zhangsan 20 90.000000
	printf("%s %d %lf\n", (*ps).name, (*ps).age, (*ps).score);//结构体变量 . 成员变量名
	//运行结果：zhangsan 20 90.000000
	printf("%s %d %lf\n", ps->name, ps->age, ps->score);//结构体指针->成员变量名
	//运行结果：zhangsan 20 90.000000

	return 0;
}