首页 > 其他分享 >操作符

操作符

时间：2023-01-05 10:34:29浏览次数：24  
标签：return int ++ 操作符 printf main

本文是对【初识C语言】中操作符部分的详细解读。自学b站”鹏哥C语言“笔记。

操作符分类：

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

算数操作符

加+   减-   乘*   除/   取余%

  1. 加+  减-  乘*  除/  可以用于整数和浮点数，取余% 只能作用于整数。
  2. 除/ 如果两个操作符都是整数，则执行整数除法；只要有浮点数，则执行浮点数除法。
  3. 除/ 得到的结果是商。

例1：除/ 示例

#include <stdio.h>
int main()
{
    int a = 5 / 2;//两个操作符都是整数，执行整数除法，即商2余1
    printf("a = %d\n", a);//a = 2
    
    int a = 5 / 2.0;//有一个操作符是浮点数，执行浮点数除法，即商2.5，默认6位小数
    printf("a = %d\n", a);//a = 2.500000
    return 0;
}

移位操作符

左移<<   右移>>

  1. 只能作用于整数。
  2. 移动的是二进制位。
  3. 右移一位有除以2的效果，右移一位有乘2的效果。
  4. 不要移动负数位，如​​a>>-1​​是错误的。

右移操作符

  • 算数右移（一般情况下都是这种）：整体右移，右边丢弃，左边补原符号位（正0负1）
  • 逻辑右移：整体右移，右边丢弃，左边补0

左移操作符

  • 整体左移，左边丢弃，右边补0

原码、反码、补码

结论：

① 有符号的整型，第一位数是符号位（正0负1）

② 只要是整型，内存中存储的都是二进制补码

③ 正整数：原码、反码、补码 相同

    负整数：原码 → 符号位不变，其它位取反 → 反码 → +1 → 补码

                 补码 → -1 → 反码 → 符号位不变，其它位取反 → 原码

例1：正整数右移1位

#include <stdio.h>
int main()
{
    int a = 16;
    int b = a >> 1;
    printf("%d\n", b);//输出结果是原码，是8
    return 0;
    //a的原码=反码=补码：00000000000000000000000000010000
    //b的补码，a右移1位:00000000000000000000000000001000
    //b的反码，-1：1111111111111111111111111110111
    //b的原码，符号位不变其它位取反：1000000000000000000000000001000，即8
    
    //实际上，正整数可以直接由a原码右移1位得到b原码
}

例2：负整数右移1位

#include <stdio.h>
int main()
{
    int a = -1；
    int b = a >> 1;
    printf("%d\n",b);//输出结果是原码，是-1
    return 0;
    //a的原码，即-1的原码：10000000000000000000000000000001
    //a的反码，符号位不变其它位取反：11111111111111111111111111111110
    //a的补码，+1：11111111111111111111111111111110
    //b的补码，a右移1位:11111111111111111111111111111111
    //b的反码，-1：1111111111111111111111111111110
    //b的原码，符号位不变其它位取反：1000000000000000000000000000001，即-1
}

位操作符

按位与&   按位或|   按位异或^


  1. 三者的操作数都必须是整数。
  2. “按位”按照的是二进制位补码。
  3. 真1假0。

按位与&

同位都为1（真）才为1

#include <stdio.h>
int main()
{
    a = 3;
    b = 5;
    int c=a&b;
    //a是00000000000000000000000000000011
    //b是00000000000000000000000000000101
    //同位都为1（真）才为1，c=00000000000000000000000000000001
    printf("%d\n", c);//输出为1
    return 0;
}

按位或|

同位只要有1（真）就为1

#include <stdio.h>
int main()
{
    a = 3;
    b = 5;
    int c=a|b;
    //a是00000000000000000000000000000011
    //b是00000000000000000000000000000101
    //同位只要有1（真）就为1，c=00000000000000000000000000000111
    printf("%d\n", c);//输出为7
    return 0;
}

按位异或^

同位相同为0，相异为1

#include <stdio.h>
int main()
{
    a = 3;
    b = 5;
    int c=a^b;
    //a是00000000000000000000000000000011
    //b是00000000000000000000000000000101
    //同位相同为0，相异为1，c=00000000000000000000000000000110
    printf("%d\n", c);//输出为6
    return 0;
}

例1（灵活题）：在不创建临时变量的条件下，实现两个数的交换

#include <stdio.h>
int main()
{
    int a = 3;
    int b = 5;
    printf("before: a = %d b = %d\n", a, b);
    a = a + b;//a=8,b=5
    b = a - b;//a=8,b=3
    a = a - b;//a=5,b=3
    printf("after: a = %d b = %d\n", a, b);
    return 0;
}

实际上，上述代码是存在缺陷的，一旦a和b的值都很大，a+b有可能会溢出，导致部分值缺失。接下来我们转变思路，用位操作符进行优化。

优化代码：异或的方法

#include <stdio.h>
int main()
{
    int a = 3;
    int b = 5;
    printf("before: a = %d b = %d\n", a, b);
    a = a ^ b;//a011,b101 → a110,b101
    b = a ^ b;//→ a110,b011 
    a = a ^ b;//→ a101,b011
    printf("after: a = %d b = %d\n", a, b);
    return 0;
}

例2：求一个整数存储在内存中的二进制中1的个数

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

上述代码可以正确处理正整数，但在处理负整数上是错误的。下面用位操作符进行改进。

改进代码：

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

赋值操作符

=    +=    -=    *=    /=    %=    >>=    <<=    &=    |=    ^=   

  1. 赋值操作符的作用是给变量重新赋值。
  2. 赋值操作符可以连续使用，如​​a = x = y+1​​，但不建议这样写。

单目操作符

！

逻辑反操作

-

负值

+

正值

&

取地址

*

解引用

sizeof

操作数的类型长度（单位：字节）

~

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

++

前置、后置++

--

前置、后置--

（类型）

强制类型转换

逻辑反操作！

真1假0

!真 = 0，!假 = 1

例1：

#include <stdio.h>
int main()
{
    //c语言中0表示假，所有非0表示真
    int a = 10;
    int b = 0;
    printf("%d\n", !a);//输出0
    printf("%d\n", !b);//固定输出1
    return 0;
}

例2：常见用法 放在if的判断语句中

#include <stdio.h>
int main()
{
    int a = 0;
    if(a)//如果a为真，则执行
    {
        ……
    }
    if(!a)//如果a为假，则执行
    {
        ……
    }
    return 0;
}

取地址&，解引用*

例1：

int main()
{
    int a = 10;
    int* p = &a;//指针变量p：用来存放地址
    *p = 20;//*：解引用操作符
    return 0;
}

操作数的类型长度sizeof

sizeof 计算的是变量/类型所占空间的大小，单位是字节。

例1：

#include <stdio.h>
int main()
{
    int a = 10;
    char c = 'r';
    char* p = &c;
    int arr[10] = {0};

    printf("%d\n", sizeof(a));//输出4
    printf("%d\n", sizeof(int));//输出4
    printf("%d\n", sizeof a);//输出4，说明可省略括号
    printf("%d\n", sizeof int);//报错！说明不可省略括号
    
    printf("%d\n", sizeof(c));//输出1
    printf("%d\n", sizeof(char));//输出1
    
    printf("%d\n", sizeof(p));//输出4
    printf("%d\n", sizeof(char*));//输出4
    
    printf("%d\n", sizeof(arr));//输出40
    printf("%d\n", sizeof(int [10]));//输出40

    return 0;
}

例2（易错）：

#include <stdio.h>
int main()
{
    short s = a + 5;
    int a = 10;
    printf("%d\n", sizeof(s = a + 5));
    printf("%d\n", s);
}

输出结果是 2 0

解析：

  1. 赋值给哪个变量，最终就是哪个变量的类型，故​​s = a + 5​​的类型是short。short类型存储空间是2字节。
  2. sizeof( )中的表达式是不进行真实运算的，所以s的值没有被改变，仍然是0。

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

“按位”按照的是二进制位补码

例1：

#include <stdio.h>
int main()
{
    int a = 0;//4个字节，32bit位
    int b = ~a;
    printf("%d\n",b);//输出结果是原码，是-1
    return 0;
    
    //有符号的整型，第一位数是符号位（0为正，1为负）
    //只要是整数，内存中存储的都是二进制【补码】
    //正数：原码、反码、补码 相同
    //负数：原码 → 符号位不变，其它位取反 → 反码 → +1 → 补码
    //     补码 → -1 → 反码 → 符号位不变，其它位取反 → 原码
    
    //00000000000000000000000000000000
    //补码:11111111111111111111111111111111
    //→反码：1111111111111111111111111111110
    //→原码：1000000000000000000000000000001，即-1
}

例2（灵活）：①把a补码右边数起第三位改为1，②改回原来的a

#include <stdio.h>
int main()
{
    int a = 11;
    
    a = a | (1<<2);
    printf("%d\n", a);//15
    
    a = a & (~(1<<2));
    printf("%d\n", a);//11
    return 0;
}

例3：sizeof和数组

#include <stdio.h>
void test1(int arr[])
{
    printf("%d\n", sizeof(arr));
}

void test2(char ch[])
{
    printf("%d\n", sizeof(ch));
}

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

16-19行代码的输出结果：40 10 4或8 4或8

解析：

16行：arr[10]是10个int，所占空间为10个元素×4个字节=40个字节

17行：ch[10]是10个char，所占空间为10个元素×1个字节=10个字节

18行：经函数传参后的arr是arr[10]首元素的地址，一个地址所占空间是4或8（由设备决定）

19行：经函数传参后的ch是ch[10]首元素的地址，一个地址所占空间是4或8（由设备决定）

前置、后置++ --

例1：

#include <stdio.h>
int main()
{
    int a = 10;
    
    int b = a++;//后置++，先使用，自身再+1
    printf("a = %d b = %d\n",a,b);//a = 11 b = 10
    
    int b = ++a;//前置++，自身先+1，再使用
    printf("a = %d b = %d\n",a,b);//a = 11 b = 11
    
    int b = a--;//后置--，先使用，自身再-1
    printf("a = %d b = %d\n",a,b);//a = 9 b = 10
    
    int b = --a;//前置++，自身先-1，再使用
    printf("a = %d b = %d\n",a,b);//a = 9 b = 9
    
    return 0;
}

关系操作符

>  >=  <  <=  !=  == 

注意：“==”和“=”的区别，编程过程中容易出错。

逻辑操作符

逻辑与&&    逻辑或||

注意：区分逻辑与 逻辑或 和 按位与 按位或

  • 逻辑与 逻辑或 是判断值本身的真假，结果只可能是1或0
  • 按位与 按位或 是判断二进制补码的真假
1&&2 → 1
1&2  → 0
  
1||2 → 1
1|2  → 3

例1（易错）：

#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\n  d = %d\n", a, b, c, d);
    
    int i = 0, a = 1, b = 2, c = 3, d =4;
    i = a++ && ++b && d++;
    printf("a = %d\n b = %d\n c = %d\n  d = %d\n", a, b, c, d);
    
    int i = 0, a = 1, b = 2, c = 3, d =4;
    i = a++ || ++b || d++;
    printf("a = %d\n b = %d\n c = %d\n  d = %d\n", a, b, c, d);
    return 0;
}

输出结果：

6行：a = 1 b = 2 c = 3 d = 4

10行：a = 2 b = 3 c = 3 d = 5

14行：a = 2 b = 2 c = 3 d = 4

解析：

5行：a++是先使用再自身+1，a=0，遇到第一个&&就已经可以确定i=0，因此后面的​​++b && d++​​都没有执行，那么b和d的值也就没有变化。

9行：同理，因为没有出现0，&&一直执行下去，则abd都给自身+1。

13行：a=1，非零，遇到第一个||就已经可以确定i=1，因此后面的​​++b && d++​​都没有执行，那么b和d的值也就没有变化。

结论：

逻辑与和逻辑或 只要能推出结果，则终止读取代码。

  • 逻辑与&&左边只要是0，右边不管是什么都不再读取，直接得到结果为0
  • 逻辑或||左边只要是非零，右边不管是什么都不再读取，直接得到结果为1

条件操作符/三目操作符


exp1 ? exp2 : exp3

若满足exp1，则执行exp2；若不满足，则执行exp3

例1：

int main()
{
    int a = 10;
    int b = 20;
    int max = 0;
    max = (a > b ? a : b);
    //若?前表达式为真，则值为a，否则值为b
    return 0;
}

逗号表达式

exp1， exp2， exp3， …， expN

从左向右依次执行，最后一个表达式的结果就是整个表达式的结果。

例1：

#include <stdio.h>
int main()
{
    int a = 1;
    int b = 2;
    int c = (a>b, a=b+10, a, b=a+1);
    return 0;
}
//最终c值为13，其中a>b，a，都没有输出值

例2：

int main()
{
    a = get_val();
    count_val(a);
    while(a>0)
    {
        ……
        a = get_val();
        count_val(a);
    }
}

等价于

int main()
{
    while(a = get_val(), count_val(a), a>0)
    {
        ……
    }
}

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

下标引用[ ]    函数调用()    访问一个结构的成员 . 和 ->

下标引用操作符[ ]

下标引用的操作数是：一个数组名 + 一个索引值

例1：

int main()
{
    int a[10] = {0};
    a[4] = 10;//使用下标引用操作符，[ ]的两个操作数是a和4
    return 0;
}

函数调用操作符( )

函数调用的操作数是：一个函数名 + 函数的参数

例1：

#include <stdio.h>
int get_max(int x, int y)
{
    return x > y ? x : y;
}

int main()
{
    int a = 10;
    int b = 20;
    int max = get_max(a, b);//使用函数调用操作符，( )的操作数是get_max，a，b
    printf("max = %d\n", max);
    return 0;
}

访问一个结构的成员 . 和 ->

结构体 . 成员名

结构体指针 -> 成员名

例1：

//创建一个结构体类型(struct) ，类型名叫Stu
//所谓结构体类型，和int，float等是类似的
struct Stu
{
    //放学生的一些相关属性
    char name[20];
    int age;
    char id[20];
}

int main()
{
    //使用struct Stu创建了一个对象s1，并初始化
    struct Stu s1 = {"张三", 20, "20230104"};
    
    //用.来访问结构的成员
    printf("%s\n", s1.name);
    printf("%d\n", s1.age);
    printf("%s\n", s1.id);
    
    struct Stu* ps = &s1;
    printf("%s\n", (*ps).name);
    printf("%d\n", (*ps).age);
    printf("%s\n", (*ps).id);
    //等价于 用->来访问结构的成员
    printf("%s\n", ps->name);
    printf("%d\n", ps->age);
    printf("%s\n", ps->id);
 
    return 0;
}

表达式求值

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

操作符的属性

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

  1. 操作符的优先级：从高到低求值
  2. 操作符的结合性：优先级相同再考虑
  3. 是否控制求值顺序

表格：

①优先级：由高到低，第n行比第n+1行优先级高

②结合性：N/A无结合性，L-R从左到右运算，R-L从右到左运算

③是否控制求值顺序：是，则说明不一定全部参与运算

操作符

描述

结合性

是否控制求值顺序

(  )

聚组

N/A

否

( )

函数调用

L-R

否

[ ]

下标引用

L-R

否

.

访问结构成员

L-R

否

->

访问结构指针成员

L-R

否

++

后缀自增

L-R

否

--

后缀自减

L-R

否

!

逻辑反

R-L

否

~

按位取反

R-L

否

+

单目，表示正值

R-L

否

-

单目，表示负值

R-L

否

++

前缀自增

R-L

否

--

前缀自减

R-L

否

*

间接访问（解引用）

R-L

否

&

取地址

R-L

否

sizeof

存储空间大小，单位字节

R-L

否

(类型)

类型转换

R-L

否

*

乘法

L-R

否

 / 

除法

L-R

否

%

整数取余

L-R

否

+

加法

L-R

否

-

减法

L-R

否

<<

左移位

L-R

否

>>

右移位

L-R

否

>

大于

L-R

否

>=

大于等于

L-R

否

<

小于

L-R

否

<=

小于等于

L-R

否

==

等于

L-R

否

!=

不等于

L-R

否

&

按位与

L-R

否

^

按位异或

L-R

否

|

按位或

L-R

否

&&

逻辑与

L-R

是

||

逻辑或

L-R

是

？：

条件操作符

N/A

是

=

赋值

R-L

否

+=

以……加

R-L

否

-=

以……减

R-L

否

*=

以……乘

R-L

否

/=

以……除

R-L

否

%=

以……取模

R-L

否

<<=

以……左移

R-L

否

>>=

以……右移

R-L

否

&=

以……与

R-L

否

^=

以……异或

R-L

否

|=

以……或

R-L

否

,

逗号

L-R

是

一些问题表达式

例1：

a*b + c*d + e*f

该表达式的计算顺序不唯一，可能是

a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f

也可能是

a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

例子中的*和+对结果不会产生影响，但如果换成其他操作符，则可能会有两种答案。

例2：

c + --c;

该表达式无法得知+前面的c获取是在--c操作之前还是之后，存在歧义。

例3：

int main()
{
    int i = 10;
    i = i-- - --i * (i = -3) * i++ + ++i;
    printf("i = %d\n", i);
    return 0;
}

存在歧义。

例4：

int fun()
{
    static in count = 1;
    return ++count;
}

int main()
{
    int answer;
    answer = fun() - fun() * fun();
    printf("%d\n", answer);
    return 0;
}

answer中三个fun()的调用顺序无法确认，而由于fun()中的++count语句，不同的函数调用顺序会有不同的answer结果。

隐式类型转换

整型提升

  1. 非整型的类型进行算术运算时，为了提升运算的精度，往往先将操作数转换为整型，运算后再按照原类型进行截断输出。
  2. 如果是有符号数，整型提升时给高位补符号位的数，无符号数补0，补到32位为止。

负数的整型提升：

char c = -1;//char只有8个比特位
//原码10000001
//反码11111110
//补码11111111
//char是有符号位的，整型提升：11111111111111111111111111111111

正数的整型提升：

char c = 1;
//原码=反码=补码：00000001
//整型提升：00000000000000000000000000000001

例1：

#include <stdio.h>
int main()
{
    char a = 3;
    //3看作int型：00000000000000000000000000000011
    //但是char只能放一个字节，截断原则是从低位截断，故a：00000011
    char b = 127;
    //127看作int型：00000000000000000000000001111111
    //b：01111111
    char c = a + b;
    //a+b的过程中有【整型提升】：
    // 00000000000000000000000000000011
    //+00000000000000000000000001111111
    //=00000000000000000000000010000010，截断得10000010
    printf("%d\n", c);
    //printf的过程中也有【整型提升】：
    //11111111111111111111111110000010 - 补码
    //11111111111111111111111110000001 - 反码
    //10000000000000000000000001111110 - 原码，即-126
    return 0;
}

例2：

#include <stdio.h>
int main()
{
    char a = 0xb6;
    short b = 0xb600;
    int c = 0x6000000;
    if(a == 0xb6)
        printf("a");
    if(b == 0xb600)
        printf("b");
    if(c == 0xb6000000)
        printf("c");
    return 0;
}
//运行结果是c
//因为"=="也是一种算术运算，而char类型的a和short类型的b都会进行整型提升，只有本来就是整型的c不会变

例3：

#include <stdio.h>
int main()
{
    char c = 1;
    printf("%u\n", sizeof(c));
    printf("%u\n", sizeof(+c));
    printf("%u\n", sizeof(!c));
}
//输出结果是1 4 1
//"+"是一种算术运算，所以c进行了整型提升

算术转换

比整型存储空间大的类型，当超过一种类型要进行算术运算时，存储空间小的类型要先转换为大的类型。

存储空间由大到小：

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


标签：return,int,++,操作符,printf,main
From： https://blog.51cto.com/u_15883132/5989490

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99