C语言教程——操作符详解(1)

前言

今天从开始讲解每个操作符的介绍，这里我有一个建议，关于操作符，我们可以不用硬背，我们可以通过敲代码，敲几次就自然而然就记住了。

1.操作符的分类：

算术操作符

移位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

这些操作符的分类和介绍有一些在文章前面的几篇介绍有所了解，但是但是并没有进行详细了解。

2.算数操作符

+ - * / %

算数操作符就是加减乘除还有一个取模，加减乘就不用说了，与数学中的大差不差，我们直接从除法和取模讲起：

2.1除法

#include <stdio.h>
int main()
{
	int a = 5/2;
	double b = 5.0 / 2;
	printf("%d\n", a);
	printf("%lf\n", b);
	return 0;
}

这是一个简单的除法运算，其中除号也叫做操作符（运算符），对于除法操作符来说，两边的操作数都是整数（这里5和2就是操作数），执行的是整数除法，如果想要计算出小数，那么除号两边至少有一个操作数是浮点数。上面就是如此，小数除以一个整数，之后还是等于小数，结果为2.500000，float和double类型用%f和%lf来打印的时候，默认是打印小数点后六位，如果想要打印1位那么就可以写成%.1lf，这样就是打印小数点后一位。

2.2取模

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

这里就是一个简单的取模（取余），计算的是整除之后的余数，但对于取余来说两边的操作数只能是整形类型，不能为其它类型，用其它类型就会报错。

1. 除了%操作符之外，其它的几个操作符都可以用于整数和浮点数

2. 对于/操作符如果两个操作数都为整数，执行整数除法，而只要有浮点数就执行浮点数除法。

3. %操作符的两个操作数必须为整数，返回的是整除之后的余数。

3.移位操作符

移位操作符，这里的位是二进制，移的其实是二进制，这里有两个操作符：

<< 左操作符 >>右操作符

这里要注意，移位操作符的操作数只能是整数。

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

上面就是移位操作符的使用方法，结果输出的一个为40，一个为2。因为这里是移位的是二进制，所以这里再讲解一下二进制的有关内容。

3.1二进制相关知识

整数的二进制形式有三种：

原码反码补码

假如这里有一个数是12：

二进制：1100 2^0+0*2^1+1*2^2+1*2^3=4+8=12

八进制：14 4*8^0+1*8^1=4+8=12

十六进制：c 十六进制里面a=10 b=11 c=12

正数的反码、原码、补码都是相同的。这里给出一个正整数10，用二进制写出来就是32位，因为一个整形类型就是占4个字节，一个字节占8个比特。由于是正数，所以第一位是0，反之，如果为1的话，这个数就是负数。

相对而言我们这里给出一个负数，它的原码就是第一位为1，剩下的按照二进制来实现，反码就是除了第一位符号位以外，都相对于原码按位取反，补码就是反码加1，得2进1。

相反也可以从补码得到原码，第一种方法就是按原来的再走回去，补码先变成反码，反码再变成原码，第二种方法就是直接补码取反，加一，这样也可以直接从补码得到原码。

内存中存储的起始是：补码的二进制

所以在参与移位的时候，移动的都是补码。

3.2左移操作符

3.2.1正数

#include <stdio.h>
int main()
{
	int a = 10;
	int b = a << 1;   //左移一位
	printf("%d\n", b);
	return 0;
}

这里给出一个整数10，我们希望它可以往左移动一位：

这里我们知道正数的补码原码反码都一样，所以写出它的原码就相当于写出来了它的补码，接下来让补码左移一位，最左边的移出去了，最右面由于缺了一位，所以填一个0，这样就移完了，我们可以算出最后等于20，程序编译运行后也是输出20,但这个过程里a的值是不变的，而是a<<1这个表达式的结果是一位之后的效果。

所以是左边丢弃，右面补个0

3.2.2负数

#include <stdio.h>
int main()
{
	int a = -10;
	int b = a << 1;   //左移一位
	printf("%d\n", b);
	return 0;
}

这里给出一个负整数10，我们希望它可以往左移动一位：

首先得到负数10的原码，之后写出它的反码和补码，因为移位是移的是补码，向左移动一位，左侧的一位不要了，右侧补上一个0，现在就是得到了向左移动完一位的补码，接下来我们还需要将补码转化为原码，才能得到最后的数。

我们用第二种方法，补码取反加1后就是得到了最后的原码，所以读出来就是-20。（记住取反的时候符号位是不发生改变的）

3.2.3结论

我们可以发现，往左移一位有×2的效果。

3.3右移操作符

右移其实分为两种：

1.算数右移（平时见到）

2.逻辑右移

到底是算数右移还是逻辑右移是取决于编辑器的，绝大部分右移都是算数右移。

#include <stdio.h>
int main()
{
	int a = -1;
	int b = a >> 1;   //右移一位
	printf("%d\n", b);
	return 0;
}

这里给出一个-1，它的原码反码和补码如下所示：

我们让它的补码向右移动一位，这时候就发现了一个问题，当向右移动一位的时候，最左侧就不知道补上什么了，这里给出定义：

算数右移：右边丢弃，左边补上原来的符号位

逻辑右移：右边丢弃，左边直接补0

这个程序编译运行之后，还是-1，所以是用的算数右移，因为如果是逻辑右移，它将会变成整数，所以当前机器是按照算数右移来移动的。

这里注意：

应该在有效的范围内进行移动，不能太大，太大就一下子移没了，如果移动的位数是负数也不可以，因为这个标准是未定义的。

4.位操作符

位操作符有：

& //按位与

| //按位或

^ //按位异或

它们的操作数必须是整数，同时也是针对二进制位进行计算的

4.1 按位与

& - 按2进制位与

对应的二进制有0，则为0，两个同时为1，才为1

#include <stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a & b;
	//内存中补码进行计算
	printf("%d\n", c);
	return 0;
}

这里给出一个正数和一个负数进行按位与计算，我们知道这些数的计算是放在内存中进行计算的，而计算机内存中存放的都是补码，所以还是要找出它们两个的补码，之后再进行按位与的计算。

3的反码原码补码都一样，因为它是正数，即可得到3的补码。

这里通过运算也同样的得到了-5的补码。

按位与的计算规则是有0则为0，两个1才为1。

所以上面的两个数的补码进行按位与计算之后得到的补码就是上面的，因为符号位为0，所以是正数，正数的反码补码原码都相同，所以直接读出来就是3。通过编译获得的结果也为3，这就是按位与计算。

4.2按位或

| - 按2进制位或

对应的二进制有1，则为1，两个同时为0，才为0

按位或跟按位与恰恰相反。

#include <stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a | b;
	//内存中补码进行计算
	printf("%d\n", c);
	return 0;
}

所以还是针对上述的两个数进行按位或，因为我们知道了它们两个的补码，所以只需要进行按位或运算就可以的处境结果

这时候就出现了运算后的补码，这是个负数，所以取反加1即为最后的结果，我们发现这个补码和-5的补码一样，所以最后的结果就是-5，这就是按位或。

4.3按位异或

^ - 按2进制位异或

对应的二进制位：相同为0，相异为1

#include <stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a ^ b;
	//内存中补码进行计算
	printf("%d\n", c);
	return 0;
}

这里还是用之前的两个数：

因为这里得到的的符号位为1，所以就是负数，负数则需要将补码变回到原码，然后再进行读数，这里我们不用第二种方法了，用第一种方法，先变成反码，之后再变成原码，也就是原路返回。

也就是如上所示，先将补码减去1，之后再按位取反，最后就得到了最后的原码，读出原码就是按位异或的最后的值。

5.赋值操作符

赋值操作符可以让之前的一个值重新被赋值。

例如：

int a=10;
a=20;
double salary=1000;
salary=2000;

这里就是先定义一个变量的值，之后再进行重新赋值。

赋值操作符还可以连续使用，并且连续进行赋值：

int a=10;
int x=0;
int y=20;
a=x=y+1;//连续赋值

这里先定义了a,x,y的变量，之后先运算y+1,将这个的值赋给x，然后再将x赋给a。但这样的写法有一些不好，不能直观的体现出到底怎么执行的。所以可以拆开写：

x=y+1;
a=x;

这样更加的容易调试。

6.复合赋值符

+= -= *= /= %=

>>= <<= &= |= ^=

这些运算符都可以写成复合的效果。

例如：

int main( )
{
    int a=3;
    a=a+2;
    a+=2;

    int b=10;
    b=b<<1;
    b<<=1;

    return 0;
}

其它的运算都可以这样写，这样更加的方便和简洁。

7.单目操作符

7.1单目操作符介绍

！逻辑反操作

-                                                                负值

+                                                               正值

& 取地址

sizeof                                                        操作数的类型长度（以字节为单位）

~                                                               对一个数的二进制按位取反

-- 前置、后置--

++ 前置、后置++

*                                                                间接访问操作符（解引用操作符）

(类型)                                                        强制类型转换

例如：

a+1；

这个有两个操作数，所以是双目操作符。

7.2单目操作符！

而单目操作符只有一个操作数，例如下面：

int main( )
{
    int flag=5;
    if(flag)
    {
        printf("ok\n");
    }
    return 0;
}

C语言中0为假，非零为真，上述代码就是如果flag为真，就打印ok，也就是执行if语句里面的内容。

但如果我们想要把这个条件改成如果flag为假才执行就可以这么写：

int main( )
{
    int flag=5;
    if(!flag)
    {
        printf("ok\n");
    }
    return 0;
}

这样的话就不输出内容，但如果把flag赋值为0,0为假，那么就输出ok。

补充：布尔类型，布尔类型就是来表示真假的类型。例如下面：

#include <stdbool.h>

int main( )
{
    _Bool flag=true;
    if(flag)
    {
        printf("ok\n");
    }
    return 0;
}

布尔类型要用到stdbool头文件。它是专门来写真假的。

7.3负号

就是把正数变成负数，负数可以变成正数。

7.4正号

正号一般都省略掉了，基本上没有什么要用到的地方。

7.5&取地址

int main( )
{
   int a=10;
    pritnf("%p\n",&a);
    int*pa=&a;
    return 0;   
}

上述代码就用了取地址的符号，取地址其实是取出来的一个对象，内存里的地址，我们可以把a这个地址打印出来，同时还可以放到一个整形的oa中。不仅可以取出来变量的地址，数组的地址，还可以取出来元素的地址。如果是常量字符串，那么取出来的地址就是字符串里第一个字符的地址。

只要是地址，就可以进行解引用*。但有一些是非法的，有一些地址还没分配，但解引用相当于强行访问。

7.6sizeof关键字（操作符）

它可以计算变量大小，数组大小或者类型大小等等。

int main( )
{
    int a=10;
    printf("%d\n",sizeof(a));
    printf("%d\n",sizeof a);
    printf("%d\n",sizeof(int));
    return 0;
}

上述代码都可以正常运行，并且都输出4。其中sizeof后面不加括号都可以，所以说明sizeof不是函数，sizeof后面是变量名的时候可以省略，如果是类型的话是不可以进行省略的。

sizeof在计算的时候有一个特点：

int a=10;
short s=5;
printf("%d\n",sizeof(s=a+3));
printf("%d\n",s);

因为sizeof内部的表达式是不参与计算的，不用进行真实的计算，这里面a+3赋给s这个动作是不发生的，因为s是短整型，但是a是整形，当一个整形放进一个短整型里面的时候，就会发生截断，所以sizeof算的是s类型的值，所以就是2，这时候s的值还是5，不会发生变化。

7.7按位取反~

对于二进制来说所有的按位取反。

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

上述代码最后的运行结果就是-1，因为它的最后算出来的补码全是1，补码全是1的话那么原码就是-1。

7.8前置（后置）++ --

int a=10;
int b=a++;

printf("%d\n",a);
printf("%d\n",b);

后置++，就是先使用，之后再++。上述代码结果就是a输出是11，b输出是10，而前置++，则是先++，之后再使用。

前置--和后置--也与这一样，可以类比。

7.9*解引用操作符

这个是和那个取地址操作符是一对的，可以通过地址来进行访问数据，后期遇到可以再讲。

7.0强制类型转换

int a=(int)3.14;

这就是把小数强制类型转化成了整形，这里就是把整数部分取出来了，小数部分就不要了。

之前有一个：

srand((unsigned int)time(NULL));

这里就用到了一个强制类型转换，因为time（）返回类型是time_t，而srand接收类型是整形，所以就可以强制类型转化成整形，这样srand就可以接受。

总结

今天介绍了关于单目操作符的使用和方法，以及一些要注意的地方，后续将会继续讲解其中的一些需要注意的地方。