前言

今天小羊又来为铁汁们更新C语言初阶的操作符详解，我们在平时写代码时总会写到一些算术操作符和赋值操作符，可是当铁汁们遇到其他的操作符时，就会望而却步，甚至写出一些bug，所以这期我给铁汁们带来新鲜出炉的操作符详解~

操作符分类

• 算术操作符
• 移位操作符
• 位操作符
• 赋值操作符
• 单目操作符
• 关系操作符
• 逻辑操作符
• 条件操作符
• 逗号表达式
• 下标引用、函数调用和结构成员

算术操作符

算术操作符是最常见的：

注意：

1. 除%操作符之外，其他的算术操作符都可以作用于整数和浮点数
2. 使用/操作符时，如果两个操作符都为整数，则执行整数除法，结果为整数。若其中有一个为浮点数，则执行浮点数除法，结果为浮点数。
3. %操作符的两个操作数必须为整数

分析示例1

#include<stdio.h>
int main()
{
	int a = 4, b = 0;
	int c = a / b;
	printf("%d", c);
	return 0;
}

分析：/操作符的除数不能为0，否则编译器会报错，就跟数学中分数中的分母不能0是一个道理。

分析示例2

#include<stdio.h>
int main()
{
	int a = 8, b = 3;
	int c = a / b;
	int d = a % b;
	printf("c=%dn", c);
	printf("d=%dn", d);
	return 0;
}

分析：C语言中的/操作符结果只保留整数部分(8/3=2……3)，而%操作符是保留余数部分。

移位操作符

注：移位操作符的操作数只能是整数
移位操作符的作用是什么呢？这里的“位”是指二进制位，故移位操作符是指移动一个数的二进制位。并且我们得清楚一个概念：整数在内存中存储的是二进制的补码，所以移动的是这个数的补码的二进制位。
二进制的三种形式:

• 原码：二进制展开
• 反码：原码的符号位不变，其他位按位取反（最高位是符号位：正数的符号位为0，负数的符号位为1）
• 补码：反码加1

注：正整数的原码、反码、补码相同

左移操作符

定义：即操作数的二进制位向左移动
移位规则：
左边抛弃、右边补0

图法示例：

总结：左移有翻倍的效果，左移一位的结果是原来的两倍，左移两位是原来的四倍。
注：num左移后，num本身的值并没有改变，因为移位操作符并不具有重新赋值的功能，若是移位之后再赋值给自己，num的值才会发生改变。

右移操作符

定义：即操作数的二进制位向右移动
移位规则：

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

图法示例

总结：右移一位会减少到原来的二分之一，右移两位会减少到原来的四分之一。
注：

1. 对于移位运算符，不能移动负数位，这个是标准未定义的。
2. 无论左移还是右移，移动的位数不要太多，比如总共32位，若是移动33位，无法得知

位操作符

注：在二进制中1为真，0为假，他们的操作数必须是整数，使用对象为内存中二进制的补码

用法示例

#include <stdio.h>
int main()
{
	int x = 66, y = 34;
	int a = x & y;
	int b = x | y;
	int c = x ^ y;
	printf("a=%dnb=%dnc=%d", a, b, c);
	return 0;
}

运行结果：

小试牛刀

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

#include <stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    printf("交换前：a = %d b = %dn", a, b);
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    printf("交换后：a = %d b = %dn", a, b);
    return 0;
}

这里采用的思想就是0 ^ a = a、a ^ a = 0
a = a ^ b ,将a带入b = a ^ b中，就得到了b = a ^ b ^ b=a,将b带入a = a^b中，就得到了a=a ^ a ^ b= b,因此就可以将两个数实现交换。

赋值操作符

赋值操作符是最最常用的操作符，它可以让你得到你想得到的任意的值。

int a=10;
double b=9.0;
char c='a';
a =4;
b=9.7;
c='t';

复合赋值符

单目操作符

(类型)强制类型转换：

int n=10;
float m=2.0f;
m=(float)n;

sizeof和数组

sizrof()是一个操作符，用于计算操作数占空间大小，单位是字节。
可以以类型、指针和函数等作为参数。

分析示例

#include<stdio.h>
void test1(int arr1[])
{
	printf("n%dn", sizeof(arr1));
}
void test2(char arr2[])
{
	printf("%dn", sizeof(arr2));
}
void test3(float arr3[])
{
	printf("%dn", sizeof(arr3));
}
void test4(double arr4[])
{
	printf("%dn", sizeof(arr4));
}
int main()
{
	int a = 0;
	float b = 0.0f;
	double c = 0.00f;
	long long d = 12345;
	int arr1[10] = { 0 };
	char arr2[10] = { 0 };
	float arr3[10] = { 0 };
	double arr4[10] = { 0 };
	//计算变量大小
	printf("%dn", sizeof(a));
	printf("%dn", sizeof(b));
	printf("%dn", sizeof(c));
	printf("%dn", sizeof(d));
	//计算类型大小
	printf("n%dn", sizeof(int));
	printf("%dn", sizeof(float));
	printf("%dn", sizeof(double));
	printf("%dn", sizeof(long long));
	//计算数组大小
	printf("n%dn", sizeof(arr1));
	printf("%dn", sizeof(arr2));
	printf("%dn", sizeof(arr3));
	printf("%dn", sizeof(arr4));
	//计算地址大小
	test1(arr1);
	test2(arr2);
	test3(arr3);
	test4(arr4);
	return 0;
}

分析：

• 在数组传参时，传递的是数组的首地址，从而计算的是地址的大小
• 计算地址大小有两种结果：在32位机器上是4字节，在64位机器上是8字节

前置++与后置++

前置++：操作数先自增1，后再被使用（先++再使用）
后置++：操作数先被使用，后再自增1（先使用再++）

#include <stdio.h>
int main()
{
	int a = 5, c = 0;
	//前置++
	c = ++a;//先a自增1使得a的值变为6,然后再被赋值到c.
	printf("%dn", c);//6
	printf("%dn", a);//6


	//后置++
	a = 5, c = 0;
	c = a++;//先使a被赋值到c,此时a=5,赋值完成后,a再自增1,变为6.
	printf("%dn", c);//5
	printf("%dn", a);//6
	return 0;
}

前置- -与后置- -效果相同

关系操作符

关系操作符的返回结果只有真或假
常见错误：
在实际编程中，关系运算符= =不能和=搞混，导致错误

逻辑操作符

用法示例

#include <stdio.h>
int main()
{
    int i = 0, m = 0, a = 0, b = 2, c = 3, d = 4;
    i = a++ && ++b && d++;
    printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
    m = a++||++b||d++;
    printf("na = %dnb = %dnc = %dnd = %dn", a, b, c, d);
    return 0;
}

分析：
&&和||有一个重要的特点：当第一个表达式已经能确定整条语句的结果时，后面剩余的表达式将不会执行。
上例中：

1. a++ && ++b && d++，咱们先看a++，先使用a再++，而a为0，0为假，所以无论后面的表达式是真是假，语句的整体结果都为假。所以执行完a++后，++b和d++不再执行。”假“&&”任意“为”假“
2. a++||++b||d++，咱们先看a++，先使用a再++，a=1后自增1，a=2，2为真，所以后面++b和d++也不用再执行。”真“||”任意“为”真“

条件操作符

执行逻辑：
当表达式1的结果为真，则执行表达式2，否则就执行表达式3

用法示例

当我们比较两个数的大小时，通常会想到使用if语句来解决：

#include <stdio.h>
int main()
{
	int a = 0, b = 0;
	scanf("%d%d", &a, &b);
	if (a > b)
	{
		printf("Max is %d", a);
	}
	else printf("Max is %d", b);
	return 0;
}

而现在我们可以转换为更为简单的写法：

#include <stdio.h>
int main()
{
	int a = 0, b = 0,c = 0;
	scanf("%d%d", &a, &b);
	c = a > b ? a : b;
	printf("Max is %d", c);
	return 0;
}

逗号表达式

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

用法示例

#include <stdio.h>
int main()
{
	int m = 0, a = 1, b = 2, c = 3, d = 5;
	m = (a++, b + 2, c *=2, c + d);
	printf("m=%dn", m);
	printf("a=%d,b=%d,c=%d,d=%d", a, b, c, d);
	return 0;
}

逗号表达式运用的场景不是很多，但是能灵活运用也有很多妙处。

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

下标引用操作符

使用方法：数组名[操作数]
具体见C语言之数组

函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
使用方法：
函数名(参数1，参数2......)

int sum(int x,int y);
void test1(const char* str);

结构体成员访问操作符

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

#include<stdio.h>
struct Stu
{
	char name[10];
	char sex[5];
	int age;
	double stature;
};
#include <stdio.h>
int main()
{
	struct Stu s1 = { "jonny","男","19",1.79 };
	printf("姓名:%sn", s1.name);
	struct Stu* s = &s1;
	printf("性别:%sn", s->sex);
	s->stature = 1.88;
	printf("身高:%.3lf", s->stature);
	return 0;
}

好勒，今天小羊这期C语言初阶的操作符详解大致讲解完毕，剩余一小部分会在后面的文章中见~