开发者社区> ws6evexzuh2vq> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

【C初阶】操作符详解

简介: 操作符详解
+关注继续查看

目录:

1. 操作符分类:

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2. 算术操作符

+   -   *    /   %

下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10,变量 B 的值为 20,则:

image

  1. 除了 % 操作符之外,其他的几个操作符可以作用于整数和浮点数。
  2. 对于 / 操作符如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。
  3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
    image
    image
    image

3. 移位操作符

左移操作符 <<

右移操作符 >>

注:移位操作符的操作数只能是整数。

位移操作符移动的是二进制

为了跟好地进行位移操作符的讲解,这里我们需要对进制有初步的了解

image

关于移位操作符,需要认识源码,反码,补码,从而对移位操作进行深度理解:

image

3.1 左移操作符

移位规则:

左边抛弃、右边补0

image

3.2 右移操作符

移位规则:

首先右移运算分两种:

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

具体采用哪种移位,取决于编译器,一般编译器采用算数移位

image

image

警告⚠ :

对于移位运算符,不要移动负数位,这个是标准未定义的。

例如

int num = 10;
num>>-1;//error

4. 位操作符

注:1.为操作符的操作数必须是整数。

2.位操作符作用于二进制数列

位操作符名称作用
&按位与有0则0,同1则1
|按位或有1则1
^按位异或相同为0,相异为1

按位与示例:

image

按位或示例:

image

按位异或示例:

image

  • 一道变态的面试题:

不能创建临时变量(第三个变量),实现两个数的交换

一种巧妙的算法

image

如上算法存在缺陷,a+b若太大会溢出,下面让我们使用异或操作符来实现:

需要用到:

1.相同为0,0与任何数异或结果都为这个数

2.异或支持交换律

//3^3 = 0
//5^5=0
//3^5=6
//3^5^5=3
//3^5^3=5
//
//000
//011
//011 
//011
//101
//110
//a^a=0
//0^a=a
//异或是支持交换律
//3^5^3
//3^3^5
//
int main()
{
    int a = 3;
    int b = 5;
    a = a ^ b;
    b = a ^ b;//b=a ^ b ^ b
    a = a ^ b;//a^b^a
    //a = a + b;
    //b = a - b;
    //a = a - b;
    printf("a=%d b=%d\n", a, b);
    return 0;
}

练习:

编写代码实现:求一个整数存储在内存中的二进制中1的个数。

参考代码:

//方法1

#include <stdio.h>
int count_bit( int m)
{
    int count = 0;
    while (m)
    {
        if (m % 2 == 1)
            count++;
        m /= 2;
    }
    return count;
}
int main() {
    int n = 0;
    scanf("%d", &n);
    int num = count_bit(n);
    printf("%d\n", num);
    return 0;
}

这种方法明显是有错误的,如果输入的是负数,无法输出正确的值,因此我们可以联想到无符号

int count_bit(unsigned int m)

若将上述函数的自定义声明改为这个,则可以避免上述问题的出现。

接下来我们运用操作符实现这个程序:

//方法2:
#include <stdio.h>
int count_bit(n) 
{
    int i = 0;
    int count = 0;
    for (i = 0; i < 32; i++)
    {
        if (1 == ((n >> i) & 1))
            count++;
    }
    return count;
}
int main() 
{
    int n = 0;
    scanf("%d", &n);
    int num = count_bit(n);
    printf("%d\n", num);
    return 0;
}

还能不能更加优化,上述两种方式都必须循环32次。

//方法3:

int count_bit(int m)
{
    int count = 0;
    while (m)
    {
        m = m & (m - 1);
        count++;
    }
    return count;
}
int main() {
    int n = 0;
    scanf("%d", &n);
    int num = count_bit(n);
    printf("%d\n", num);
    return 0;
}
//n=11
//n = n&(n-1)
//1011 - n
//1010 - n-1
//1010 - n
//1001 - n-1
//1000 - n
//0111 - n-1
//0000 - n
//根据上述规律可知,有几个n&(n-1)就有多少个1

这种方式很好,达到了优化的效果,但是难以想到。

5. 赋值操作符

赋值操作符是一个很棒的操作符,他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

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;

这样的写法更加清晰爽朗而且易于调试。

复合赋值符

image

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

比如:

int x = 10; 
x = x+10; 
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

6. 单目操作符

6.1 单目操作符介绍

! 逻辑反操作

- 负值

+ 正值

& 取地址

sizeof 操作数的类型长度(以字节为单位)

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

– 前置、后置–

++ 前置、后置++

* 间接访问操作符(解引用操作符) (类型) 强制类型转换

  • !举例
int main()
{
    int flag = 0;
    //if (!flag)
    if(flag == 0)
    {
        printf("hehe\n");
    }
    return 0;
}
  • &和解引用操作符的举例
int main()
{
    int a = 10;
    char c = 0;
//  printf("%p\n", &a);//取出地是二进制数列
//  printf("%p\n", &c);
    int* pa = &a;//& - 取地址操作符  pa是指针变量  int*是类型
    //*pa = 20;//* - 解引用操作符    把a拿出来进行赋值
    *pa = 20;
    return 0;
}
  • sizeof操作符举例
int main()
{
    short s = 10;
    int a = 2;
    s = a + 5;
    printf("%zu\n", sizeof(s = a + 5));//输出结果为2,sizeof()内部放的表达式不会计算
    printf("%d\n", s);//,输出结果为10
    int a = 10;
    int* p;
    int arr[10];
    printf("%zu\n", sizeof(a));//int  4
    printf("%zu\n", sizeof a);//int  4
    printf("%zu\n", sizeof(int));//int  4
    //printf("%zu\n", sizeof int);//err
    printf("%zu\n", sizeof(p));//int* 4
    printf("%zu\n", sizeof(arr));//int [10] 40
    printf("%zu\n", sizeof(arr[10]));//int 4
    return 0;
}

⭐️ 这里需要注意的是sizeof(数组名)是指数组整体的类型长度,而不是数组首元素的类型长度,sizeof()内部放的表达式不会计算。

  • 原理:
    在文件转向可执行程序的时候在编译阶段,编译器就进行了判断,进行了截断把后面括号中两个字节的内容给了short类型
    image

image

  • ~按位取反操作符
  • 代码与原理展示:
int main()
{
    int a = 0;
    /*00000000000000000000000000000000 - ~按位取反
    11111111111111111111111111111111 - 内存中-补码
    11111111111111111111111111111110 -反码(补码减1)
    10000000000000000000000000000001 -源码(反码符号位不变其他位按位取反)
    
    -1*/
    printf("%d\n", ~a);
    return 0;
}

image

image

上面的内容仅仅是铺垫,相信看完下面的内容你会对~(按位取反操作符)有更加深入的了解

int main()
{
    int a = 10;
    int n = 0;
    scanf("%d", &n);
    //把a的第n位置为1
    a = a | (1 << (n-1));
    printf("a=%d\n", a);
    //把a的第n位置为0
    a = a & ~(1 << (n - 1));
    printf("a=%d\n", a);
    //00000000000000000000000000001010
    //00000000000000000000000000010000
    //1<<2;
    //00000000000000000000000000011010
    //11111111111111111111111111101111
    //00000000000000000000000000010000
    //00000000000000000000000000001010
    return 0;
}

image

6.2 sizeof 和 数组

#include <stdio.h>
void test1(int arr[]) {
    printf("%d\n", sizeof(arr));//(结果4)
}
void test2(char ch[]) {
    printf("%d\n", sizeof(ch));//(结果4)
}
int main() {
    int arr[10] = { 0 };
    char ch[10] = { 0 };
    printf("%d\n", sizeof(arr));//(结果40)
    printf("%d\n", sizeof(ch));//(结果10)
    test1(arr);
    test2(ch);
    return 0;
}

参阅了如上代码是否有所疑惑,且看详解:

image

image

  • ++ - -运算符
    关于++和–运算符,前面的文章中提到过,但下面的图片也是一目了然
    若图片看不太懂,还有代码供参考😏

image

//++和--运算符
//前置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = ++a;
 //先对a进行自增,然后对使用a,也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减,然后对使用a,也就是表达式的值是a自减之后的值。y为10;
    return 0; }
//后置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用,再增加,这样x的值是10;之后a变成11;
    int y = a--;
    //先对a先使用,再自减,这样y的值是11;之后a变成10;
    return 0; }
  • 强制类型转换
    如图,当我们将一个小数想要赋值给int型的变量时,编译器会报错,这里就需要用到强制类型转换,下面的代码中我们就运用了强制类型转换,只要认真观察区别,就可以学会
    image
int main()
{
    int a = (int)3.14;
    printf("%d\n", a);
    return 0;
}

这里输出的值自然为整数3

7. 关系操作符

关系操作符

>

>=

<

<=

!= 用于测试“不相等”

== 用于测试“相等”

这些关系运算符比较简单,没什么可讲的,但是我们要注意一些运算符使用时候的陷阱。

注意:
在编程的过程中== 和=不小心写错,导致的错误。

image

如图,如果因为少写了等号=,如果常量放在后面,编译器会认为是赋值语句而不报错,但常量放在前面,少写了等号,编译器必然会报错。
因此,在判断变量和常量是否相等时建议使用 if(10==a);这种写法。

int main()

{

char arr[] = “abcdef”;

==不能比较2个字符串的内容,实际上比较的是2个字符串的首字符的地址,所以这样写是错误的

if (arr == “abcdef”)

{

printf(“==\n”);

}

return 0;

}

8. 逻辑操作符

逻辑操作符有哪些:

&& 逻辑与

|| 逻辑或

区分逻辑与和按位与

区分逻辑或和按位或

1&2----->0

1&&2---->1

1|2----->3

1||2---->1

逻辑与和或的特点:

若逻辑或运算符左边操作数的值为1,则就不继续执行其右边的操作数。

“&&” 同理,若左边的操作数为0,则就不继续执行其右边的操作数

int main()
{
int a = 3;
int b = 0;
    if (a && b)  //这里的&&仅仅判断真假,如果两边都是真,则继续执行,非0即为真
    //if (a || b) //同样的,有真则为真
    {
    printf("呵呵\n");
    }
    return 0 ;
}
int main()
{
    int age = 20;
    18~36 青年
    if (age >= 18 && age <= 36)
    {
        printf("青年\n");
    }
int main()
{
    int year = 2000;
    if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
    printf("闰年");//这里的&&是并且的意思  ||是或的意思
    return 0;
}

360笔试题

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
   }

//程序输出的结果是什么?

因为a++先使用a的值,a==0,&&只要有a就为假,所以后面不会运行,自然值也不变,而a最后还要++,所以运行结果如下

image

这里有几个变式,如果可以都计算正确,说明该知识点已经掌握,如果没有,则需要认真思考

image输出结果为2335;

image

运行结果为2234,因为a是1,||后面不管是几都为真,所以后面不计算直接跳过,而a还要++

image

结果为1334

9. 条件操作符

exp1 ? exp2 : exp3

int main()
{
    int a = 3;
    int b = 0;
    if (a > 5)
        b = 3;
    else
        b = -3;
    return 0;
}

转换成条件表达式,是什么样?

b = ((a > 5) ? 3 : -3);

2.使用条件表达式实现找两个数中较大值。

int m = (a > b ? a : b);

10. 逗号表达式

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)
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
a = get_val();
count_val(a);
}
如果使用逗号表达式,改写:
while (a = get_val(), count_val(a), a>0)
{
//业务处理
}

通过如上代码,我们可以看出,代码3中,相对于用while循环写出的代码,用逗号表达式写出来的代码更加简洁。

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

  • 1. [ ] 下标引用操作符
    注意:[ ]不是定义数组时的操作符,而是在要访问数组的第某个元素时所使用的操作符
    arr[4];访问数组的第5个元素,
    这里的[ ]就交下标引用操作符,
    操作数是arr和4
    操作数:一个数组名 + 一个索引值
  • 2. ( ) 函数调用操作符
    接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数。
void test(int x, int y)
{
}
void test2()
{}
int main()
{
    test2();
    //操作数:test2
    test(3, 4);//()函数调用操作符
    //操作数:test,3,4
    return 0;
}
  • 3. 访问一个结构的成员

. 结构体.成员名

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

//结构体成员

//书:书名 + 定价

代码演示:

struct Book
{
    char name[20];
    int price;
};
int main() {
    struct Book sb = { "C语言", 55 };
    printf("%s %d\n", sb.name, sb.price);//结构体变量.结构体成员名
    struct Book* ps = &sb;
    printf("%s %d\n", (*ps).name, (*ps).price);//ps指向sb,*ps找到sb
    printf("%s %d\n", ps->name, ps->price);//结构体指针->结构体成员名
//->name找到了ps所指向的对象sb的name
    return 0;
}

运行结果:

image

12. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样,有些表达式的操作数在求值的过程中可能需要转换为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为整型提升。

整型提升的意义:

表达式的整型运算要在CPU的相应运算器件内执行,CPU内整型运算器(ALU)的操作数的字节长度

一般就是int的字节长度,同时也是CPU的通用寄存器的长度。

因此,即使两个char类型的相加,在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。

通用CPU(general-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令中可能有这种字节相加指令)。所以,表达式中各种长度可能小于int长度的整型值,都必须先转 换为int或unsigned int,然后才能送入CPU去执行运算。

如何进行整体提升呢?

整形提升是按照变量的数据类型的符号位来提升的
//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位:
1111111
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为1
提升之后的结果是:
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位:
00000001
因为 char 为有符号的 char
所以整形提升的时候,高位补充符号位,即为0
提升之后的结果是:
00000000000000000000000000000001
//无符号整形提升,高位补0

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

b和c的值被提升为普通整型,然后再执行加法运算。

加法运算完成之后,结果将被截断,然后再存储于a中。

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

那么上面代码的结果是不是131呢?接下来让我们来细细分析一番:

⭐️例1:

int main()
{
    char a = 5;//截断
    char b = 126;//截断
    char c = a + b;//截断
    //00000000000000000000000000000101
    //00000101 - a
    //00000000000000000000000001111110
    //01111110 - b
    //整型提升
    //00000000000000000000000000000101-a
    //00000000000000000000000001111110-b
    //00000000000000000000000010000011
    //10000011 - c
    printf("%d\n", c);
    //%d 十进制的方式打印有符号整数
    //11111111111111111111111110000011
    //11111111111111111111111110000010
    //10000000000000000000000001111101
    //-125
    //
    return 0;
}

配图解

image

⭐️例2:

int main()
{
    char a = 0xb6;
    //10110110
    //
    short b = 0xb600;
    int c = 0xb6000000;
    if (a == 0xb6)
        printf("a");
    if (b == 0xb600)
        printf("b");
    if (c == 0xb6000000)
        printf("c");
    return 0;
}

image

实例1中的a,b要进行整形提升,但是c不需要整形提升

a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表

达式 c==0xb6000000 的结果是真.

需要注意的是无符号整型提升,高位直接补0

⭐️例3:

int main()
{
char c = 1;
printf("%u\n", sizeof(c));
printf("%u\n", sizeof(+c));
printf("%u\n", sizeof(-c));
return 0;
}

实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字

节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节

12.2 算术转换

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

image

如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运

算。

警告:

但是算术转换要合理,要不然会有一些潜在的问题

float f = 3.14;

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

12.3 操作符的属性

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

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

一些问题表达式

//表达式的求值部分由操作符的优先级决定。

//表达式1

ab + cd + e*f

注释:代码1在计算的时候,由于*比+的优先级高,只能保证,的计算是比+早,但是优先级并不
能决定第三个
比第一个+早执行。

所以表达式的计算机顺序就可能是:

ab
c
d

ab + cd

ef
a
b + cd + ef

或者:

ab
c
d

ef
a
b + cd
a
b + cd + ef

image

//表达式2

c + --c;

注释:同上,操作符的优先级只能决定自减–的运算在+的运算的前面,但是我们并没有办法得知,+操作符的左操作数的获取在右操作数之前还是之后求值,所以结果是不可预测的,是有歧义的。

//代码3-非法表达式

int main()

{

int i = 10;

i = i-- - --i * ( i = -3 ) * i++ + ++i;

printf(“i = %d\n”, i);

return 0;

}

表达式3在不同编译器中测试结果不同

//代码4
int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少?
     return 0;
}

这个代码有没有实际的问题?

有问题!

虽然在大多数的编译器上求得结果都是相同的。

但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知:先算乘法,再算减法。

函数fun()的调用先后顺序无法通过操作符的优先级确定。

//代码5
#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

Linux环境的结果:

image

VS2013环境的结果:

image

看看同样的代码产生了不同的结果,这是为什么?

简单看一下汇编代码.就可以分析清楚.这段代码中的第一个 + 在执行的时候,第三个++是否执行,这个是不确定的,因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

总结:

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

希望以上内容对大家有所帮助👀,如有不足望指出🙏

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
0基础C语言保姆教程——第六节 操作符、表达式和语句
加法或者减法都是双目操作符,就是必须要求有两个操作对象才能够用它,这也很好理解,加法、减法要两个数才能加减对吧。
0 0
算数运算符细节讨论|学习笔记
本节课来看算术运算符的细节。
0 0
C语言第二章 数据类型,运算符和表达式总结【完美补充文字版】(超级详细)
C语言第二章 数据类型,运算符和表达式总结【完美补充文字版】(超级详细)
0 0
【C语言】 操作符的困惑都在这里解决! (操作符详细解析)
本文是C语言操作符详解篇,可以帮助新手小白,快速了解c语言操作符的使用方法,每一个操作符都有列子和解释,做以参考学习
0 0
【重温基础】5.表达式和运算符
【重温基础】5.表达式和运算符
0 0
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载