[C++知识库]C语言操作符

前言

本篇文章带着大家一起来了解C语言的操作符，本篇文章详细的介绍了C语言中的操作符的用法和优先级，以及在使用的时候可能出现的误操作。

1.算数操作符

除了%操作符之外，其他的几个操作均可用于整数和浮点数运算
% 操作符的两个操作数必须为整数，返回的是整除之后的余数
/操作符如果两个操作数都为整数，执行整数除法。但是只要有一个浮点数，就执行浮点数除法

效果图：

2.位移操作符

示意图：

位移结果：

整数左移一位，被位移的数放大2倍（移动的位数是以2为底数的指数，位移n位，放大 2^n 倍）
无符号整数 右移 一位，被位移的数缩小2倍（移动的位数是以2为底数的指数，位移n位，缩小 2^n 倍）

注：位移操作符仅适用于整数，且移动的数都是无符号整数，不要移动负数位，这个是标准未定义的。
图例：

位移操作符可以用来求一个数的二进制中有多少位1，详情请看计算一位整数二进制中，1的位数

3.位操作符

示意图：

注：位操作符的操作数必须是整数。

这里顺带给大家说一个曾经的非常厉害的一个面试题：如何在不创建临时变量的情况下，完成两个变量之间的数值交换。

//常规做法：
#include<stdio.h>
int main()
{
	int a=10;
	int b=20;
	int tmp=0;
	printf("交换前：a=%d,b=%d\n",a,b);
	tmp=a;
	a=b;
	b=tmp;
	printf("交换后：a=%d,b=%d\n",a,b);
	return 0;
}

//不用临时变量（方案一）
#include<stdio.h>
int main()
{
	int a=10;
	int b=20;
	printf("交换前：a=%d,b=%d\n",a,b);
	a=a+b;//将a和b的和存放在a中
	b=a-b;//用他们的和减去b，即可得到a
	a=a-b;//上面发生变化的是b，b中存放的是a原来的值，现在只需要用他们的和减去现在的b即可得到原来的b
	printf("交换后：a=%d,b=%d\n",a,b);
	return 0;
}//这个方法的缺点在于它有可能会数据溢出，单独的a和b可能没事，但是一相加就有可能会溢出

//用异或方法处理：
#include<stdio.h>
int main()
{
	int a=10;
	int b=20;
	printf("交换前：a=%d,b=%d\n",a,b);
	a=a^b;
	b=a^b;
	a=a^b;
	printf("交换后：a=%d,b=%d\n",a,b);
	return 0;
}//这个方法的缺点在于它只对整形适用，并且可读性不强

这里给大家用图解释以下上面异或的代码

他们的异或得到的值，随便和他们其中一个再次异或就可以得到另一个的值。

4.赋值操作符

赋值操作符算是所有操作符里面最简单的一个，也是最棒的一个操作符，它可以让你把你自己想要的值赋值给变量。

#include<stdio.h>
int main()
{
	float wealth=2000.0;//比如你自己手机里的钱
	wealth=4000.0;
	//觉得少了，我们就给他翻个倍，放进去一个自己想要的数字
	int a=10;
	int b=20;
	int c=0;
	c=a=b+a;//这么写代码，从语法上来说是允许的，但是不建议这样写
	//这样写代码不利于调试，可读性也不高，建议分开写
	
	a=a+b;
	c=a;
	return 0;
}

复合赋值符

这些符号都是其他符号写成的符号效果，例如：

#include<stdio.h>
int main()
{
	int a=10;
	a=a+10;
	//等价于
	a+=10;
	return 0;
}

5.单目操作符

#include<stdio.h>
int main()
{
	int a=0;
	int b=!a;
	//逻辑反操作符让原来为真的值变成假
	if(b)
	{
		printf("hehe\n");
	}
	else
		printf("haha\n");
		
	//下面是负值
	int a=-10;
	
	//接下来是取地址和解引用操作符
	int a=10;
	int* p=&a;
	*p=20;
	printf("%p\n",p);//这里得到的是a的空间的地址
	printf("%d\n",a);//这里也可以将a写成*p
	//解引用操作符和存放地址的变量组合后会直接指向那个地址的空间

	//下面介绍sizeof和强制类型转换
	char arr[10]="abc";
    printf("%d\n",sizeof(arr));//10个字节
    //计算的是整个空间的大小
    printf("%d\n",strlen(arr));//字符串的长度，关注的内存中是否有\0，计算的是\0之前出现的字符个数
    int x=0x11223344;
    printf("%d\n",(short)x);
    //将x强制转换为short型
    
    int a=10;
    printf("%d\n",sizeof(a));// 4
    printf("%d\n",sizeof a);//4
    printf("%d\n",sizeof(int));// 4

    int a=5;
    short s=10;
    printf("%d\n,sizeof(s=a+2));//  2     sizeof内部的表达式不参与运算
    printf("%d\n",s);//  10
    
    //下面介绍的是~
    int a=0;
    int b=~a;
    printf("%d\n",b);// -1
    //原码
    //00000000000000000000000000000000 -0
    //反码
    //00000000000000000000000000000000 -0
    //补码
    //00000000000000000000000000000000 -0
    //取反(0的补码取反)
    //11111111111111111111111111111111 - -1

	//下面介绍的是前置(后置)++和--
	int a =10;
	int x=++a;
	printf("%d\n",x);
	int y=--a;
	printf("%d\n",y);
	x=a++;
	printf("%d\n",x);
	y=a--;
	printf("%d\n",y);
	return 0;
}

6.关系操作符

关系运算符较为简单，这里不做过多介绍
不过要注意写代码的时候不要将 == 写成 =；

7.逻辑操作符

使用逻辑操作符的时候注意和位操作符的区分

if(a&b)和if(a&&b)这两个的结果是不一样的

#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);
//因为是后置++ 所以他是先运算然后a再+1，但是逻辑与是一假全假，a的初始化的值是0，再计算机里面，0就是假，非0是代表真
//所以结果是a=1,b=2,c=3,d=3

    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);
//逻辑或是全假才为假，所以当a为0的时候，它可以继续运算后面的算式，一直到它遇到一个为真的表达式，停止运算
//结果是 a=1,b=3,c=3,d=4

    return 0; 
}

8.条件操作符

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 0;
	c = a > b ? a : b;
	printf("%d\n",c);
	return 0;
}

9.逗号表达式

exp1,exp2,exp3,exp4…expn

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

#include<stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = (a>b, a=b+10, a, b=a+1);
	printf("%d\n",c);//c=13
	return 0;
}

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

下标引用操作符 [ ]

#include<stdio.h>
int main()
{
	int arr[10]=0;//创建数组并初始化
	arr[9]=19;//使用下标引用操作符
	return 0;
}

此时的 [ ] 的两个操作数分别是 arr 和 9

函数调用操作符（）

#include<stdio.h>
void test1()
{
	test2();//函数里面可以嵌套调用另一个函数,但是不能嵌套创建函数
	/*void test3()
	{
		printf("haha\n");//这里的这个写法是不可以的，不允许函数内再创建一个函数
	}*/
}
void test2()
{
	printf("hehe\n");
}
int main()
{
	test1();
	test2();
	return 0;
}

接受一个操作数或者多个操作数，第一个操作数接收函数名，剩下的操作数给函数传参

访问一个结构的成员
. 结构体 . 成员名
-> 结构体指针 -> 成员名

#include <stdio.h>
struct Stu
{
    char name[10];
    int age;
    char sex[5];
    double score; 
}；
void set_age1(struct Stu stu)
{
    stu.age = 18;
}
void set_age2(struct Stu* pStu)
{
    pStu->age = 18;//结构成员访问
}
int main()
{
    struct Stu stu;
    struct Stu* pStu = &stu;//结构成员访问
    
    stu.age = 20;//结构成员访问
    set_age1(stu);
    
    pStu->age = 20;//结构成员访问
    set_age2(pStu);
    return 0;
}

#include<string.h>
#include<stdio.h>
struct Book
{
	char name[20];
	int num;
	double price;
};
int main()
{
	struct Book book1 = { "C语言程序设计" ,12234334 ,34.2 };
	//book1.name="Java语言设计"   //这样写是错误的格式，在Book这个类中，name 是 char 型变量的 数组 ，数组不能够直接这样赋值
//想要改变就要用到strcpy 函数
	strcpy(book1.name ,"Java语言设计");
	return 0;
}

11.算数转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题。

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

12.优先级

基本的优先级需要记住：
指针最优，单目运算优于双目运算。如正负号。
先算术运算，后移位运算，最后位运算。
逻辑运算最后结合。

因为优先级的图文太长，博主就不在这里给大家放了，下面给了大家优先级的度娘网站，可以去看一下。
优先级