C语言最详细讲解操作符

算术操作符

加法 +
减法 -
乘法 *
除法 /
取模 %

在C语言默认的是整数除法
例如：

6 / 5 = 1
如果想得正确的结果，那二个数中至少要有一位是浮点数
6.0 / 5 = 1.2
6.0 / 5.0 = 1.2

% 操作符的二个操作数必须是整数，返回的是整数除后的余数
例如：

7 % 3 = 1
10 % 4 = 2

移位操作符

关于正数和负数在二进制的表示方法

32位平台上正数的表示

整数的二进制表示形式：其实有三种：
原码：直接根据数值写出的二进制序列就是原码
反码
补码
正数原码反码补码全部都是相同的

例如：
7的二进制数是：
原码：00000000000000000000000000000111
补码：00000000000000000000000000000111
反码：00000000000000000000000000000111
正数的原码反码补码都是相同的

负数的表示
负数的整数的原码反码补码都是要计算的
二进制的第一个数字被称为符号位，0表示正数，1表示负数

原码：符号位为1，表示负数，在按二进制写出来
-7的二进制数是：
原码：10000000000000000000000000000111
补码：11111111111111111111111111111000（原码的符号位不变，其他按位取反就是反码）
反码：11111111111111111111111111111001（反码+1.得到补码）

总结：整数二进制在内存中存储的是补码

左移操作符 <<

左移操作符，向左移动 ， 移动的是二进制位

例如：
a << 1
把a的二进制位向左移一位，左边丢弃，右边补0

正数的例子：

负数的例子：

右移操作符 >>

右移操作符，向右移一位， 移动的也是二进制位
右移操作符分二种：
算术移位：右边丢弃，左边补原符号位
逻辑移位：右边丢弃，左边补0

算术移位和逻辑移位看起来差不多，但是计算负数时，数值就会相差巨大
大部分都是用的都算术右移
总结

• 右移操作符和左移操作符只针对整数，不能使用浮点数
• 左移 乘*2，右移 除 / 2

位操作符

& ----按位与
& 按（二进制）位与，二数为真则为真，当有一个数为假，则全假。

计算机在内存中存储的都是补码，所以要进行计算在打印

| ----按位或
| 按（二进制）为或，是当有一个数为真则全真，全假则为假

计算机在内存中存储的都是补码，所以要进行计算在打印

^ ----按位异或
^ 按（二进制）位异或，是只要是相同为0，相异为1

计算机在内存中存储的都是补码，所以要进行计算在打印

练习题：

不能创建临时变量（第三个变量），实现两个数的交换
思路：

假设3^3
3的二进制是：011
011 ^ 011
^ 的规则是只要是相同为0，相异为1
3 ^ 3 = 0
那 0 ^ 5 = 5
那 3 ^ 3 ^ 5 = 5
那 3 ^ 5 ^ 3 = 5
得出结论：只要二个相同的数异或的出0

#include 
int main()
{
     int a = 10;
     int b = 20;
     a = a^b;
     b = a^b;
     a = a^b;
     printf("a = %d b = %d\n", a, b);
     return 0;
}

``

赋值操作符

赋值操作符是可以给一个变量重新赋值
例如：

int weight = 120; 初始化
weight = 89; 不满意就重新赋值

double salary = 10000.0;
salary = 20000.0; 使用赋值操作符赋值

赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1; 连续赋值
这样的代码感觉怎么样？

那同样的语义，你看看：
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。

复合赋值符

复合赋值符就是加、减、乘、除等等的简写

a = a+5; 可以写成 a += 5;
a = a- 5; 可以写成 a -= 5;
其他运算符一样的道理，这样写更加简洁。

单目操作符

！ 逻辑反操作符

逻辑反操作符就是取反的意思，真变假，假变真
0为假，非0为真

int main()
{
	int a = 3;
	if (a)
	{
		printf("a为真打印\n");
	}
	
	if (!a)
	{
		printf("a为假打印\n");
	}
}

+正值 -负值

+正值没什么意义，在b还是-10
int main()
{
	int a = +10;
	int b = +a;
   负值
   int a = -10;
   int b = -a;
负负得正，a是负数时，在赋值时前面加上-, b = -a的结果是 10；
}

& 取地址操作符

& 取地址是：变量a的地址

sizeof操作符

sizeof是操作符，不是函数
sizeof操作符是计算变量a所占空间的大小，单位是字节

也可以计算整个数组的大小

int main()
{
	int arr[10] = { 0 };
	int n = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", n);
	return 0;
}

arr数组有10个空间，每个空间是 int 类型，每个空间所占大小是4个字节，有10个空间也就是40个字节，除于一个空间的大小（4）得出数组的大小

~ 操作符

~ 操作符是对一个数的二进制按位取反

++和–

++和–有分前置和后置

* 间接访问操作符

（ 类型） 强制类型转换

3.14是浮点型，前面（int）是强制把3.14转换成整型

int main()
{
   int a = (int)3.14
   printf("%d\n,a);
}

关系操作符

>      大于
>=     大于等于
<      小于
<=     小于等于
!=     用于测试“不相等”
==     用于测试“相等”

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
例如：在编程的过程中== 和=不小心写错，导致的错误

逻辑操作符

逻辑操作符有&& 逻辑与和 || 逻辑或
&& 逻辑与意思是：判断二个数是否为真，真返回1，假返回0
** || 逻辑或**意思是：判断二个数中是否有一个数是真，真返回1，二个数都是假返回0

&&逻辑与例题：

这里a、b、c、d 的值是多少？

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呢？后面结果是多少

逻辑或例题：

如果把 a 改成 0 呢？

条件操作

条件操作符又称三目操作符

exp1 ？exp2 ：exp3
exp1 条件成立，返回exp2的结果，exp1条件不成立，返回exp3的结果

例如：

int main()
 {
    if(a>5)
    b = a;
    else
    b = -3
    
    把上面写成三目操作符：
    
    int max = a > b ? a : b; 
    这里如果a > b 那把a赋值给max，否则把b赋值给max
}

逗号表达式

逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
例如：

下标引用、函数调用

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

int arr[10];   创建数组
 arr[9] = 10;  实用下标引用操作符。
 [ ]的两个操作数是arr和9。
根据加法的交换原则这里可以写成:
  9[arr] = 8 == arr[9] = 8
  arr[7] == *(arr+7)  == *(7+arr) == 7[arr]
  这些都是相等的

. 2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数
函数最少有一个操作数

void test1()
 {
 printf("hehe\n");
 }
 ---------------------------------
 void test2(const char *str)
 {
 printf("%s\n", str);
 }
 ---------------------------------
int main()
 {
 test1();              使用（）作为函数调用操作符。
 test2("hello bit.");  使用（）作为函数调用操作符。
 return 0;
 }

结构体

struct 可以定义一个新的结构体类型
strcpy 是字符串拷贝
访问一个结构的成员有二种方式

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

struct Stu
{      //结构体的成员
	char name[10];
	int age;
	double score;
};

void set_sut(struct Stu* ss)
{ // 结构体的初始化
	strcpy(( *ss).name, "张三");
	(*ss).age = 20;
	(* ss).score = 100.0;
-----------------------------------------------	
	//指针的形式
	strcpy(ss->name, "zhangsan");
	ss->age = 20;
	ss->score = 100.1;
}

void print(struct Stu s)
{ // 打印
	printf("%s %d %lf\n", s.name, s.age, s.score);
	----------------------------------------------------
  //指针的形式
  printf("%s %d %lf\n", s->name,s->age,s->score);
}

int main()
{
	struct Stu s = { 0 };
	set_sut(&s);
	print(s);//如果是指针的形式打印  print(&s);
}

s->age 等价于 （*s）. age

表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型

int a = 3;
int b = 5;
int c = a+b*7;

按照优先级是先算乘再算加
b * 7 = 35
a + 35 = 38
结果是 c = 38

隐式类型转换

隐式类型转换意思是在你不知道的时候转换了类型
C的整型算术运算至少是默认以整型类型的精度来进行的
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

什么是整形提升呢

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度
如果两个char类型的相加，执行时也要先转换为整型操作数的标准长度，为 int类型
正常在写代码中可能会遇到表达式中各种长度可能小于int长度的整型值
但都必须先转换为int或unsigned int，然后才能继续执行运算。

如何进行整体提升呢？

整形提升是发生在char类型和short类型

整形提升是按照变量的数据类型的符号位来提升的

负数的整形提升

这里截断的意思是：有10个苹果，你有一个箩筐只能放下8个苹果，剩下的2个你只能丢掉了

咱们练习一下，更方便理解
例如：

int main()
{
	char a = 5;
	char b = 126;
	char c = a + b;
	printf("%d\n", c);
	return 0;
}

这里 c 的值是多少

算术转换

如果某个操作符的各个操作数属于不同的类型
例如：int a + floar b
那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。

下面的层次体系称为寻常算术转换

long double
double
float
unsigned long int
long int
unsigned int
int

以上排名是从小往上的，从小到大
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运
算。
例如：

int a = 10;
float b = 20;
a+b就会进行算术转换，floar的精度更高，会把 a 转换成floatl类型

操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
   两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性

一些问题表达式
例题一：

例题二：

例题三：
这是来自于《C和指针》

总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

文章如有错漏，欢迎在评论区留言提醒