1、算术操作符

+（加）  -（减）  *（乘）  /（除）    %（取余）

除法操作符 —— " / "

#include<stdio.h>
int main()
{int a = 5 / 2;  //对于/操作符，如果两个操作数都为整数，执行整数除法。float b = 5 / 2;float c = 5 / 2.0;   //对于/操作符，如果有浮点数，执行浮点数除法。printf("%d\n", a);printf("%f\n", b);printf("%f\n", c);return 0;
}

取余操作符 —— %

#include<stdio.h>
int main()
{int a = 5 % 2;  //% 操作符的两个操作数必须为整数。返回的是整除之后的余数。//int b = 5.0 % 2.0; 这样写是错误的，编译器会报错的printf("%d\n", a);return 0;
}

除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2、移位操作符

整型在内存中的储存：

整型有 —— 原码、反码、补码 —— 三种类型 —— 都是用二进制写出来的

正整数 ：—— 原码、反码、补码相同。

负数：—— 原码、反码、补码不相同。

原码 —— 直接用二进制写出来的数字。

反码 —— 符号位不变，其它位按位取反。

补码 —— 反码＋1。

在内存中储存的是补码

#include<stdio.h>
int main()
{int a = 5;//00000000000000000000000000000101 —— 原码 —— 反码 —— 补码int b = -1;//10000000000000000000000000000101 —— 原码//11111111111111111111111111111110 —— 反码 —— 符号位不变，其它位按位取反//11111111111111111111111111111111 —— 补码 —— 反码加一return 0;
}

左移操作符和右移操作符：

—— 左移操作符和右移操作符都是对二进制进行移位

<<（左移操作符）    >>（右移操作符）

左移操作符

—— 移位规则 —— 左边抛弃、右边补0

#include<stdio.h>
int main()
{int a = 5;int b = a << 1; //10//00000000000000000000000000000101 —— 原码 —— 反码 —— 补码//00000000000000000000000000001010 —— 左边抛弃，右边补零int c = -1;int d = c << 1; //-2//10000000000000000000000000000101 —— 原码//11111111111111111111111111111110 —— 反码 —— 符号位不变，其它位按位取反//11111111111111111111111111111111 —— 补码 —— 反码加一//11111111111111111111111111111110 —— 补码执行左移操作符 —— 补码//11111111111111111111111111111101 —— 反码 —— 补码-1//10000000000000000000000000000010 —— 原码 —— 反码符号位不变，其它位按位取反printf("%d\n", b);printf("%d\n", d);return 0;
}

右移操作符

—— 移位规则 ——

1. 逻辑移位 —— 左边用0填充，右边丢弃
2. 算术移位 —— 左边用原该值的符号位填充，右边丢弃

大多数的的编译器都是算术右移 —— VS2019也是用算术右移的

#include<stdio.h>
int main()
{int a = 5;int b = a >> 1; //2//00000000000000000000000000000101 —— 原码 —— 反码 —— 补码//00000000000000000000000000000010 —— 左边补原来数字的符号0，右边抛弃int c = -1;int d = c >> 1; //-1//10000000000000000000000000000101 —— 原码//11111111111111111111111111111110 —— 反码 —— 符号位不变，其它位按位取反//11111111111111111111111111111111 —— 补码 —— 反码加一// //11111111111111111111111111111111 —— 补码执行右移操作符 —— 补码//11111111111111111111111111111110 —— 反码 —— 补码-1//10000000000000000000000000000001 —— 原码 —— 反码符号位不变，其它位按位取反printf("%d\n", b);printf("%d\n", d);return 0;
}

注：

1. a >> 1 等价于 a / 2 ———— a << 1 等价于 a * 2
2. a >> 2 等价于 a / 2 / 2 ———— a << 2 等价于 a * 2 * 2 —— 依次类推
3. 对于左移，右移操作符，操作数的左边和右边都必须是整数 —— 不适用浮点型

警告：

对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：

int num = 10;
num >> -1;  //error

3、位操作符

&（按位与）    |（按位或）   ^（按位异或）
注：他们的操作数必须是整数。

按位与 —— &

按位与是按照二进制位与 —— 两数都为1则为1，两数不都为1则为0。

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011int b = -2;//10000000000000000000000000000010 —— 原码//11111111111111111111111111111101 —— 反码//11111111111111111111111111111110 —— 补码int c = a & b;//00000000000000000000000000000011 —— 3的补码//11111111111111111111111111111110 —— -2的补码//00000000000000000000000000000010 —— c的补码 —— 又因为c为正数，所以补码就是原码printf("%d", c);  //打印值为2//%d —— 表示打印有符号的整数//%u —— 表示打印无符号的整数return 0;
}

按位或 —— |

按位或是按照二进制位或 —— 两数都为0则为0，两数不都为0则为1。

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011int b = -2;//10000000000000000000000000000010 —— 原码//11111111111111111111111111111101 —— 反码//11111111111111111111111111111110 —— 补码int c = a | b;//00000000000000000000000000000011 —— 3的补码//11111111111111111111111111111110 —— -2的补码//11111111111111111111111111111111 —— c的补码 —— c为负数//11111111111111111111111111111110 —— c的反码//10000000000000000000000000000001 —— c的原码printf("%d", c);  //打印值为-1return 0;
}

按位异或 —— ^

按异或是按照二进制位异或 —— 两数相同为0，不相同为1

#include<stdio.h>
int main()
{int a = 3;//00000000000000000000000000000011int b = -2;//10000000000000000000000000000010 —— 原码//11111111111111111111111111111101 —— 反码//11111111111111111111111111111110 —— 补码int c = a ^ b;//00000000000000000000000000000011 —— 3的补码//11111111111111111111111111111110 —— -2的补码//11111111111111111111111111111101 —— c的补码 —— c为负数//11111111111111111111111111111100 —— c的反码//10000000000000000000000000000011 —— c的原码printf("%d", c);  //打印值为-3return 0;
}

一道变态的面试题：

我们经常用的两个数交换的函数：

#include<stdio.h>
int main()
{int a = 3;int b = 5;int tem = 0;printf("%d %d\n", a, b);tem = a;a = b;b = tem;printf("%d %d\n", a, b);return 0;
}

不能创建临时变量（第三个变量），实现两个数的交换。
第一种方法：

#include<stdio.h>
int main()
{int a = 3;int b = 5;printf("%d %d\n", a, b);a = a + b;b = a - b;a = a - b;printf("%d %d\n", a, b);return 0;
}

第二种方法：

#include<stdio.h>
int main()
{int a = 3;int b = 5;printf("%d %d\n", a, b);a = a ^ b;b = a ^ b;a = a ^ b;printf("%d %d\n", a, b);return 0;
}
解析：
//011 —— a
//101 —— b
//110 —— a = a ^ b
//011 —— b = a ^ b
//101 —— a = a ^ b

其中：

a ^ b 可以看做是一个钥匙

这个钥匙和 a 异或就是 b —— a ^ b ^ a = b

这个钥匙和 b 异或就是 a —— a ^ b ^ b = a

一些其他的 异或 公式：a ^ 0 = a b ^ b = 0。

4、赋值操作符

  =  (赋值操作符)

赋值操作符是一个很好的操作符，他可以让你得到一个你之前不满意的值。
也就是你可以给一个变量重新赋值。

int weight = 120;  //体重
weight = 100;  //不满意就赋值
double salary = 10000.0;
salary = 20000.0;  //使用赋值操作符赋值。//赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;  //连续赋值 —— 这样写不容易读懂 —— 可读性差
//下面是a = x = y + 1 的分部写法
x = y+1;
a = x;
//这样的写法更加清晰爽朗而且易于调试。

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

上面的这些复合赋值符是为了写起来更加的方便和便捷，提升我们写代码的效率。

举例：

#include<stdio.h>
int main()
{int c1 = 0;int c2 = 0;int d1 = 10;int d2 = 10;c1 += 10;d1 <<= 1;printf("%d\n", c1);   //打印值为10printf("%d\n", d1);   //打印值为20c2 = c2 + 10;d2 = d2 << 1;printf("%d\n", c2);   //打印值为10printf("%d\n", d2);   //打印值为20return 0;
}

从上面代码中可知：
c += 10 和 c = c + 10 是等价的
c >>= 10 和 c = c >> 10 是等价的

5、单目操作符

—— 只有一个操作数的操作符

!（逻辑反操作）      -（负值）                      +（正值）
& （取地址）        sizeof（操作数的类型长度）      ~（对一个数的二进制按位取反）
--（前置、后置--）   ++（前置、后置++）             * （间接访问操作符(解引用操作符)）
(类型) —— 强制类型转换

逻辑反操作 —— ！

#include<stdio.h>
int main()
{int a = 1;a = !a;printf("%d\n", a);  //打印值为0if (a)   //表示：a为真的时候打印heheprintf("hehe\n");if (!a)   //表示：a为假的时候打印hahaprintf("haha\n");return 0;
}
//注释：
//当a为非零数的时候 —— !a的值为0
//当a为零的时候 —— !a的值为1

正负值号 —— + -

#include<studio.h>
int main()
{int a = 10;a = -a;printf("%d\n", a);   //打印值为-10a = -a;printf("%d\n", a);   //打印值为 10return 0;
}

取地址和解引用操作符 —— & 和 *

取地址和解引用操作符一般都是一起使用的

#include<stdio.h>
int main()
{int a = 10;int arr[10] = {0};int* p = &a;  // *表示 p 是指针变量，int 表示p地址所指向的内容是整型// & —— 表示取出a的地址  p = &a —— 表示把a的地址放在P指针中*p = 20;   //*是解引用操作符， 能从地址找到地址中的内容//int* p 和 *p = 20 中的*p是不一样的//其中的int* p中的 * 表示p是一个指针变量//*p = 20 中的 * 表示解引用，利用p中存放的地址找到地址中的内容&arr;//—— 表示取出整个数组的地址 —— &arr + 1 跳过40个字节（10个整型）arr;//—— 表示取出首元素的地址 —— arr + 1 跳过4个字节（一个整型）&arr[0];// —— 表示取出首元素的地址 —— &arr[0] + 1 —— 跳过4个字节（一个整型）
}

补充：

左值和右值 —— 放在等号左边的值是左值，放在等号右边的值为右值
左值表示地址所指向的空间，右值表示所指向空间的内容
例如：a = 10  b = a
a = 10 —— a 为地址空间，10为值
b = a —— b 为地址所指向的那块空间， a为a所指向那块空间的值10

sizeof 操作符

—— 强调sizeof是操作符，不是函数
—— 计算数据类型或者是变量在内存中所占的空间大小，单位是字节，和变量中所存的值的大小无关

1. 数组名如果单独放在 sizeof（） 中，数组名表示的是整个数组 —— 计算整个数组的大小
2. &数组名 —— 也表示的是整个数组
3. 除了上面两种情况数组名表示的是整个数组，其他的数组名都表示的是首元素地址。

#include<stdio.h>
int main()
{char ch[10] = "abcd";int a = 10;printf("%d\n", sizeof(ch)); //打印值为10printf("%d\n", strlen(ch));  //打印值为4 —— strlen是计算字符串的大小，遇见\0停止printf("%d\n", sizeof(int)); //打印值为4printf("%d\n", sizeof(a)); //打印值为4printf("%d\n", sizeof a); //打印值为4 —— 从这个就可以说明sizeof是操作符，不是函数//如果是函数就必须有函数引用操作符 —— ()printf("%d\n", sizeof int); //这种写法是错误的return 0;
}

例题：

1. 第一题

#include<stdio.h>
int main()
{int a = 5;short b = 10;printf("%d\n", sizeof(b = a + 2));printf("%d\n", b);
}

答案：2 10
解析：因为 sizeof 内部的表达式不参与运算

1. 第二题

#include <stdio.h>
void test1(int arr[])
{printf("%d\n", sizeof(arr));//
}
void test2(char ch[])
{printf("%d\n", sizeof(ch));//
}
int main()
{int arr[10] = {0};char ch[10] = {0};printf("%d\n", sizeof(arr));//printf("%d\n", sizeof(ch));//test1(arr);test2(ch);return 0;
}

答案：40 10 4/8 4/8
解析：
sizeof（arr）—— arr单独放在 sizeof 中表示的是 —— arr是整个数组 —— 整个数组的大小为40字节
sizeof ( arr ) —— ch单独放在 sizeof 中表示的是 —— ch表示是整个数组 —— 大小为10
函数传参传的是数组首元素的地址 —— 只要是地址就是4（32位平台下）\8（64位平台下）个字节。

取反操作符 —— ~

—— 按二进制位取反 —— 原来为1的值取0，原来为0的值取1。

#include<stdio.h>
int main()
{int a = 0;a = ~a;printf("%d\n", a); //打印值为-1//解析：//00000000000000000000000000000000 —— a的原码，反码，补码//11111111111111111111111111111111 —— ~a的补码//11111111111111111111111111111110 —— ~a的反码//00000000000000000000000000000001 —— ~a的原码 —— 值为：-1
}

++ 和 - - 操作符

#include<stdio.h>
int main()
{int num1 = 10;int num2 = num1++;  //后置++ —— 先赋值，后++ —— num2先等于num1（10），然后num1再++int num = 11;int num3 = --num;   //前置-- —— 先++，后赋值 —— num先--，然后在对num3赋值printf("%d\n", num1);   //打印值为11printf("%d\n", num2);   //打印值为10printf("%d\n", num);   //打印值为10printf("%d\n", num3);   //打印值为10
}

(类型) —— 强制类型转换

int main()
{int a = 3.14  //直接赋给变量一个浮点数，默认的类型为double类型的浮点数，这样直接赋给int类型//的变量会出现警告， 为了不出现警告，用下面的写法int a = (int) 3.14 //其中(int)会把double类型的值转变成int类型的值return 0;
}

6、关系操作符

//关系操作符
>
>=
<
<=
!=     // 用于测试“不相等”
==     // 用于测试“相等”

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。

警告：
在编程的过程中== 和=不小心写错，导致的错误。

7、逻辑操作符

 && (逻辑与)     ||(逻辑或)

#include<stdio.h>
int main()
{int a = 0;int b = 1;int c = a && b;printf("%d\n", c);  //打印值为0 —— a 和 b 同时为真才为真 c = a || b;printf("%d\n", c);  //打印值为1 —— a 和 b 同时为假才为假return 0;
}

一道360的笔试题

#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);//上面的打印值为：1 2 3 4//分析：a++为后置++ —— 先使用a —— a等于0 —— 为假，当a为假的时候 —— 按位于后面的内容无论是什么//整体都为假 —— 所以后面的内容（++b， d++）不执行，只执行了a++；//a++执行 a为1，其他的不执行，为原值 b = 2，c = 3，d = 4；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);//上面的打印值为：1 3 3 4//分析：a++为后置++ —— 先使用a —— a等于0 —— 为假，当a为假的时候 —— 按位或后面的内容会影响整体//的结果 —— 执行++b —— ++b为真 —— 按位或后面的内容无论是什么 —— 整体都为真 —— 后面的内容不执行//a++执行 a = 1；++b执行 b = 3；其他的不执行 c = 3，d = 4。return 0;
}

8、 条件操作符

—— 三目操作符

exp1？ exp2 : exp3
//其中的exp1，exp2，exp3都是一个表达式
//翻译：如果exp1式子成立，打印exp2式子的结果，否则打印exp3式子的结果

练习：使用条件表达式实现找出两个数中的较大值

#include<stdio.h>
int main()
{int a = 0;int b = 4;int c = (a) > (b) ? (a) : (b); //如果a大于b，打印a，否则打印bprintf("%d\n", c);return 0;
}

9、逗号表达式

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
if (a =b + 1, c=a / 2, d > 0)   //从左到右一直执行，最终由最后一个表达式判断（d>0）。

10. 下标引用、函数调用和结构成员

10.1、[ ] 下标引用操作符

—— 操作数：一个数组名 + 一个索引值

 #include<stdio.h>int mian(){int arr[] = { 1,2,3,4,5 };int i = 0;for (i = 0; i < 5; i++){printf("%p --- %p\n", &arr[i], (arr + i));   //打印的两个地址相同}//由上面的结果可知：arr[i] 和 *(arr + i) 等价//arr[i] = *(arr + i) = *(i + arr) = i[arr]for (i = 0; i < 5; i++){printf("%d --- %d\n", arr[i], i[arr]);}//arr[i] 和 i[arr] 的打印值相同return 0;}

10.2、( ) 函数调用操作符

—— 接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传给函数的参数。

#include<stdio.h>
#include<string.h>test1()
{printf ("haha\n");
}test2(const char* p)
{printf("%s\n", p);
}int main()
{char arr[] = "abcdef";size_t c = strlen(arr);  //strlen为库函数 ——需要引用头文件<string.h>//strlen 的库函数的返回值为无符号整型 —— size_t表示无符号整型printf("%u\n", c);//%u —— 表示打印无符号整型//%d —— 表示打印有符号整型test1();  //实用（）作为函数调用操作符test2("hello bit");  //实用（）作为函数调用操作符return 0;
}

10.3、访问结构成员的操作符

. 结构体.成员名
-> 结构体指针->成员名

10.3.1、结构体 . 成员名

#include<stdio.h>
#include<string.h>//定义一个结构体类型
struct book
{char name[20];float price;char id[10];
};  // ; 不可少int main()
{//对结构体进行初始赋值struct book b = {"c语言", 40.0f, "OF010111"};printf("%s\n", b.name);  //要找到结构体中的成员 —— 需要用到 . 操作符printf("%f\n", b.price);printf("%s\n", b.id);printf("-----------------\n");//修改结构的值b.price = 60.0f;strcpy(b.name,"数据结构");  //其中b.name指向的是一个数组名 —— 首元素地址 —— 不能直接改变//需要用到strcpy库函数(拷贝字符串） —— 引用头文件<string.h>printf("%s\n", b.name);printf("%f\n", b.price);printf("%s\n", b.id);return 0;
}

10.3.2、结构体指针->成员名

#include<stdio.h>//定义一个结构体类型
struct book
{char name[20];float price;char id[10];
};  // ; 不可少void Print1(struct book* b)  //利用结构体指针接收地址
{printf("%s\n", (*b).name);printf("%f\n", (*b).price);printf("%s\n", (*b).id);printf("-----------------\n");printf("%s\n", b -> name);  //由结构体指针找到结构体中的成员 —— 需要用到 -> 操作符printf("%f\n", b -> price);printf("%s\n", b -> id);
}
//当接收到的是结构体指针时 —— 通常都使用 -> 符号来找结构体成员
//当接收到的是结构体变量时 —— 使用 . 操作符int main()
{struct book b = {"c语言", 40.0f, "OF010111"};//定义一个打印函数Print1(&b);  //传的是结构体的地址return 0;
}

详细讲解 —— 操作符（C语言初阶）(万字长文）相关推荐

1. C语言初阶_初识C语言（1）

   凡是过往,皆为序章 期末考试结束了,真是感慨良多啊...... C语言编程题大家都做对了多少呢? 不管怎么样,都已经过去了.不管你学得怎么样,都可以在接下来的时间里,我们一起重新回顾一遍C语言初阶的知 ...

2. 五十分钟带你看遍C语言初阶语法（总纲）

   C语言初阶语法(总纲) 此篇博客包含了前面C语言所有的基础语法,写这一期的博客不仅是为了记录自己的学习成果也是为了让更多的朋友能学到对自己有用的知识,如果总有一个知识点帮助到了你,给卑微博主点点关注加 ...

3. C语言初阶(18) | 数组详解

   目录 1.数组的定义 2.一维数组 2.1一维数组的格式 2.2一维数组的初始化 2.3一维数组的使用 2.4一维数组再内存中的存储 3.二维数组 3.1二维数组的创建和初始化 3.2二维数组的使用 ...

4. C语言初阶——6.进制

   C语言初阶--6.进制 1. 进制 百度百科: 进制也就是进位计数制,是人为定义的带进位的计数方法,对于任何一种进制-X进制,就表示每一位置上的数运算时都是逢X进一位. 十进制是逢十进一,十六进制是逢 ...

5. C语言初阶作业题-数组

   C语言初阶作业题-数组 一.选择题 1.关于一维数组初始化,下面哪个定义是错误的?( ) A.int arr[10] = {1,2,3,4,5,6}; B.int arr[] = {1,2,3,4,5 ...

6. C语言初阶——5.字符串

   C语言初阶--5.字符串 1. 字符串操作 1.1 字符串遍历 可以通过数组方式遍历字符串. char* str="Hello World"; for(int i = 0;'\0' ...

7. C语言初阶总结 v1

   目录 C 基础1⭐ 数据类型 计算机中的单位 常量与变量 字符串/转意字符/ 注释 C 基础2⭐ 判断语句 函数与数组 C语言操作符 C语言关键字 C语言定义宏与关键字 初始指针 ⭐⭐ 指针基础 拓展 ...

8. C语言初阶第三篇：换我心，为你心，始知C语言 从C语言选择语句到循环语句保姆教学来喽

   换我心,为你心,始知C语言 老铁们,咱们上一篇文章把字符串的知识点给过了一遍,今天就要开始真正的程序语句的学习了,也就是选择语句和循环语句,今天的内容比较简单,所以写的也不多,废话不多说,咱们开始吧! ...

9. 【台大郭彦甫】Matlab入门教程超详细学习笔记五：初阶绘图（附PPT链接）

   初阶绘图 前言 一.基础绘图 1.plot() 绘制二维线图 2.legend()添加图例 3.title()和*label()添加标题与坐标轴 4.text()和annotation()增加注解 二 ...

最新文章

1. JavaScript文档
2. 简述linux中动态库和静态库的制作调用流程
3. python对图像二值化_python如何二值化图像
4. 面试官、女朋友都满意系列 - 决策树
5. mysql 安装和修改编码（utf8mb4）
6. 2017.02.19学习C#的第二天，今天我学到了什么？
7. java 项目启动后页面乱码_idea java项目启动后访问html页面乱码
8. android 日记 app推荐,用这些 APP 来记录生活，再也不用担心无法坚持写日记
9. 嗯，我是一个偏执狂。
10. 四级网络工程师笔记-操作系统（中）
11. 奈奎斯特定理和香农定理
12. 幼儿园作业（毕业季）
13. leaflet绘制具有虚线框的多边形（125）
14. PyTorch1.12 亮点一览 | DataPipe + TorchArrow 新的数据加载与处理范式
15. liunx oracle 12505,ORA-12505 错误解决
16. 摘自＿sina_海派与京派画作＿吴昌硕＿徐渭_齐白石
17. Facebook购买匿名操作系统漏洞，协助FBI抓捕犯罪者
18. 图论500题 慢慢写
19. IT女性的职业困惑 （1）
20. keras自定义simm作为损失函数，并且实现Tensor和数组之间的转换

热门文章

1. js设计模式之观察者模式和订阅发布模式
2. 计算机网络从结构上可以划分为 接入网,《接入网技术》复习章节题型,含答案...
3. 钢绞线弹性模量怎么计算_预应力钢绞线的弹性模量概念及计算方法 - 新闻中心 - 湖南汇赢钢铁科技公司...
4. 编号或者编码自动生成
5. 深度学习之候选框的选取
6. 挑灯夜读——Java（二）：面向对象
7. 远程服务器如何创建分支,Git 创建分支提交远程分支详解
8. 面试时如何回答为何离开老东家
9. 如何做成牛x，简历吸引人，月薪3万，程序员的品牌
10. 支付渠道被攻击了有什么好的办法吗？