操作符：
- 1、算术操作符
- 除法操作符 —— " / "
- 取余操作符 —— %
- 2、移位操作符
- 整型在内存中的储存：
- 左移操作符和右移操作符：
- 左移操作符
- 右移操作符
- 警告：
- 3、位操作符
- 按位与 —— &
- 按位或 —— |
- 按位异或 —— ^
- 一道变态的面试题：
- 4、赋值操作符
- 复合赋值符
- 5、单目操作符
- 逻辑反操作 —— ！
- 正负值号 —— + -
- 取地址和解引用操作符 —— & 和 *
- sizeof 操作符
- 取反操作符 —— ~
- ++ 和 - - 操作符
- (类型) —— 强制类型转换
- 6、关系操作符
- 7、逻辑操作符
- 一道360的笔试题
- 8、 条件操作符
- 9、逗号表达式
- 10. 下标引用、函数调用和结构成员
- 10.1、[ ] 下标引用操作符
- 10.2、( ) 函数调用操作符
- 10.3、访问结构成员的操作符
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;
}
右移操作符
—— 移位规则 ——
- 逻辑移位 —— 左边用0填充，右边丢弃
- 算术移位 —— 左边用原该值的符号位填充，右边丢弃
大多数的的编译器都是算术右移 —— 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;
}
注：
- a >> 1 等价于 a / 2 ———— a << 1 等价于 a * 2
- a >> 2 等价于 a / 2 / 2 ———— a << 2 等价于 a * 2 * 2 —— 依次类推
- 对于左移，右移操作符，操作数的左边和右边都必须是整数 —— 不适用浮点型
警告：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：
int num = 10;
num >> -1; //error
3、位操作符
&（按位与） |（按位或） ^（按位异或）
注：他们的操作数必须是整数。
按位与 —— &
按位与是按照二进制位与 —— 两数都为1则为1，两数不都为1则为0。
#include<stdio.h>
int main()
{
int a = 3;
//00000000000000000000000000000011
int 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;
//00000000000000000000000000000011
int b = -2;
//10000000000000000000000000000010 —— 原码
//11111111111111111111111111111101 —— 反码
//11111111111111111111111111111110 —— 补码
int c = a | b;
//00000000000000000000000000000011 —— 3的补码
//11111111111111111111111111111110 —— -2的补码
//11111111111111111111111111111111 —— c的补码 —— c为负数
//11111111111111111111111111111110 —— c的反码
//10000000000000000000000000000001 —— c的原码
printf("%d", c); //打印值为-1
return 0;
}
按位异或 —— ^
按异或是按照二进制位异或 —— 两数相同为0，不相同为1
#include<stdio.h>
int main()
{
int a = 3;
//00000000000000000000000000000011
int b = -2;
//10000000000000000000000000000010 —— 原码
//11111111111111111111111111111101 —— 反码
//11111111111111111111111111111110 —— 补码
int c = a ^ b;
//00000000000000000000000000000011 —— 3的补码
//11111111111111111111111111111110 —— -2的补码
//11111111111111111111111111111101 —— c的补码 —— c为负数
//11111111111111111111111111111100 —— c的反码
//10000000000000000000000000000011 —— c的原码
printf("%d", c); //打印值为-3
return 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); //打印值为10
printf("%d\n", d1); //打印值为20
c2 = c2 + 10;
d2 = d2 << 1;
printf("%d\n", c2); //打印值为10
printf("%d\n", d2); //打印值为20
return 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); //打印值为0
if (a) //表示：a为真的时候打印hehe
printf("hehe\n");
if (!a) //表示：a为假的时候打印haha
printf("haha\n");
return 0;
}
//注释：
//当a为非零数的时候 —— !a的值为0
//当a为零的时候 —— !a的值为1
正负值号 —— + -
#include<studio.h>
int main()
{
int a = 10;
a = -a;
printf("%d\n", a); //打印值为-10
a = -a;
printf("%d\n", a); //打印值为 10
return 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是操作符，不是函数
—— 计算数据类型或者是变量在内存中所占的空间大小，单位是字节，和变量中所存的值的大小无关
- 数组名如果单独放在 sizeof（） 中，数组名表示的是整个数组 —— 计算整个数组的大小
- &数组名 —— 也表示的是整个数组
- 除了上面两种情况数组名表示的是整个数组，其他的数组名都表示的是首元素地址。
#include<stdio.h>
int main()
{
char ch[10] = "abcd";
int a = 10;
printf("%d\n", sizeof(ch)); //打印值为10
printf("%d\n", strlen(ch)); //打印值为4 —— strlen是计算字符串的大小，遇见\0停止
printf("%d\n", sizeof(int)); //打印值为4
printf("%d\n", sizeof(a)); //打印值为4
printf("%d\n", sizeof a); //打印值为4 —— 从这个就可以说明sizeof是操作符，不是函数
//如果是函数就必须有函数引用操作符 —— ()
printf("%d\n", sizeof int); //这种写法是错误的
return 0;
}
例题：
- 第一题
#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 内部的表达式不参与运算
- 第二题
#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); //打印值为11
printf("%d\n", num2); //打印值为10
printf("%d\n", num); //打印值为10
printf("%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，否则打印b
printf("%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;
}
