[C语言]操作符详解

  1. 各种操作符的介绍。
  1. 表达式求值

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

  1. 除了 % 操作符之外,其他的几个操作符可以作用于整数和浮点数。
  2. 对于 / 操作符如果两个操作数都为整数,执行整数除法。而只要有浮点数执行的就是浮点数除法。
  3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
    3. 移位操作符
    3.1 左移操作符
    移位规则:
    左边抛弃、右边补 0
    • * / %
      << 左移操作符
      >> 右移操作符
      注:移位操作符的操作数只能是整数。
      比特就业课-专注IT大学生就业的精品课程
      比特主页:https://m.cctalk.com/inst/s9yewhfr
      比特就业课 3.2 右移操作符
      移位规则:
      首先右移运算分两种:
  1. 逻辑移位
    左边用 0 填充,右边丢弃
  2. 算术移位
    左边用原该值的符号位填充,右边丢弃
    警告 ⚠ :
    对于移位运算符,不要移动负数位,这个是标准未定义的。
    例如:
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 4. 位操作符
    位操作符有:
    练习一下:
    一道变态的面试题:
    不能创建临时变量(第三个变量),实现两个数的交换。
    练习:
    编写代码实现:求一个整数存储在内存中的二进制中 1 的个数。
    int num = 10 ;
    num >>- 1 ; //error
    & // 按位与
    | // 按位或
    ^ // 按位异或
    注:他们的操作数必须是整数。
    #include <stdio.h>
    int main ()
    {
    int num1 = 1 ;
    int num2 = 2 ;
    num1 & num2 ;
    num1 | num2 ;
    num1 ^ num2 ;
    return 0 ;
    }
    #include <stdio.h>
    int main ()
    {
    int a = 10 ;
    int b = 20 ;
    a = a^b ;
    b = a^b ;
    a = a^b ;
    printf ( "a = %d b = %d\n" , a , b );
    return 0 ;
    }
    参考代码:
    // 方法 1
    #include <stdio.h>
    int main ()
    {
    int num = 10 ;
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 5. 赋值操作符
    赋值操作符是一个很棒的操作符,他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋
    值。
    int count = 0 ; // 计数
    while ( num )
    {
    if ( num % 2 == 1 )
    count ++ ;
    num = num / 2 ;
    }
    printf ( " 二进制中 1 的个数 = %d\n" , count );
    return 0 ;
    }
    // 思考这样的实现方式有没有问题?
    // 方法 2 :
    #include <stdio.h>
    int main ()
    {
    int num = - 1 ;
    int i = 0 ;
    int count = 0 ; // 计数
    for ( i = 0 ; i < 32 ; i ++ )
    {
    if ( num & ( 1 << i ) )
    count ++ ;
    }
    printf ( " 二进制中 1 的个数 = %d\n" , count );
    return 0 ;
    }
    // 思考还能不能更加优化,这里必须循环 32 次的。
    // 方法 3 :
    #include <stdio.h>
    int main ()
    {
    int num = - 1 ;
    int i = 0 ;
    int count = 0 ; // 计数
    while ( num )
    {
    count ++ ;
    num = num & ( num - 1 );
    }
    printf ( " 二进制中 1 的个数 = %d\n" , count );
    return 0 ;
    }
    // 这种方式是不是很好?达到了优化的效果,但是难以想到。
    int weight = 120 ; // 体重
    weight = 89 ; // 不满意就赋值
    double salary = 10000.0 ;
    salary = 20000.0 ; // 使用赋值操作符赋值。
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 复合赋值符
    +=
    -=
    *=
    /=
    %=
    >>=
    <<=
    &=
    |=
    ^=
    这些运算符都可以写成复合的效果。
    比如:
    6. 单目操作符
    6.1 单目操作符介绍
    赋值操作符可以连续使用,比如:
    int a = 10 ;
    int x = 0 ;
    int y = 20 ;
    a = x = y + 1 ; // 连续赋值
    这样的代码感觉怎么样?
    那同样的语义,你看看:
    x = y + 1 ;
    a = x ;
    这样的写法是不是更加清晰爽朗而且易于调试。
    int x = 10 ;
    x = x + 10 ;
    x += 10 ; // 复合赋值
    // 其他运算符一样的道理。这样写更加简洁。
    ! 逻辑反操作
  • 负值
  • 正值
    & 取地址
    sizeof 操作数的类型长度(以字节为单位)
    ~ 对一个数的二进制按位取反
    -- 前置、后置 --
    ++ 前置、后置 ++
    * 间接访问操作符 ( 解引用操作符 )
    ( 类型 ) 强制类型转换
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 演示代码:
    关于 sizeof 其实我们之前已经见过了,可以求变量(类型)所占空间的大小。
    6.2 sizeof 和 数组
    #include <stdio.h>
    int main ()
    {
    int a = - 10 ;
    int * p = NULL ;
    printf ( "%d\n" , ! 2 );
    printf ( "%d\n" , ! 0 );
    a = - a ;
    p = & a ;
    printf ( "%d\n" , sizeof ( a ));
    printf ( "%d\n" , sizeof ( int ));
    printf ( "%d\n" , sizeof a ); // 这样写行不行?
    printf ( "%d\n" , sizeof int ); // 这样写行不行?
    return 0 ;
    }
    #include <stdio.h>
    void test1 ( int arr [])
    {
    printf ( "%d\n" , sizeof ( arr )); //(2)
    }
    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 )); //(1)
    printf ( "%d\n" , sizeof ( ch )); //(3)
    test1 ( arr );
    test2 ( ch );
    return 0 ;
    }
    问:
    ( 1 )、( 2 )两个地方分别输出多少?
    ( 3 )、( 4 )两个地方分别输出多少?
    //++ 和 -- 运算符
    // 前置 ++ 和 --
    #include <stdio.h>
    int main ()
    {
    int a = 10 ;
    int x = ++ a ;
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 7. 关系操作符
    关系操作符
    这些关系运算符比较简单,没什么可讲的,但是我们要注意一些运算符使用时候的陷阱。
    警告:
    在编程的过程中 == 和 = 不小心写错,导致的错误。
    8. 逻辑操作符
    逻辑操作符有哪些:
    区分 逻辑与按位与
    区分 逻辑或按位或
    逻辑与和或的特点:
    // 先对 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 ;
    }
    >
    >=
    <
    <=
    != 用于测试 " 不相等 "
    == 用于测试 " 相等 "
    && 逻辑与
    || 逻辑或
    1 & 2 -----> 0
    1 && 2 ----> 1
    1 | 2 -----> 3
    1 || 2 ----> 1
    比特就业课-专注IT大学生就业的精品课程
    比特主页:https://m.cctalk.com/inst/s9yewhfr
    比特就业课 360 笔试题
    9. 条件操作符
    练习:
    10. 逗号表达式
    逗号表达式,就是用逗号隔开的多个表达式。
    逗号表达式,从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
    #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 ;
    }
    // 程序输出的结果是什么?
    exp1 ? exp2 : exp3

if ( a > 5 )
b = 3 ;
else
b = - 3 ;
转换成条件表达式,是什么样?
2. 使用条件表达式实现找两个数中较大值。
exp1 , exp2 , exp3 , ...expN
// 代码 1
int a = 1 ;
int b = 2 ;
int c = ( a > b , a = b + 10 , a , b = a + 1 ); // 逗号表达式
c 是多少?
// 代码 2
if ( a = b + 1 , c = a / 2 , d > 0 )
// 代码 3
a = get_val ();
count_val ( a );
while ( a > 0 )
{
比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课 11. 下标引用、函数调用和结构成员

  1. \] 下标引用操作符

  2. ( ) 函数调用操作符
    接受一个或者多个操作数:第一个操作数是函数名,剩余的操作数就是传递给函数的参数。
  3. 访问一个结构的成员
    . 结构体 . 成员名
    -> 结构体指针 -> 成员名
    // 业务处理
    a = get_val ();
    count_val ( a );
    }
    如果使用逗号表达式,改写:
    while ( a = get_val (), count_val ( a ), a > 0 )
    {
    // 业务处理
    }
    int arr [ 10 ]; // 创建数组
    arr [ 9 ] = 10 ; // 实用下标引用操作符。

\] 的两个操作数是 arr 和 9 。 #include \ void test1 () { printf ( "hehe\\n" ); } void test2 ( const char \* str ) { printf ( "%s\\n" , str ); } int main () { test1 (); // 实用()作为函数调用操作符。 test2 ( "hello bit." ); // 实用()作为函数调用操作符。 return 0 ; } #include \ struct Stu { char name \[ 10 \]; int age ; char sex \[ 5 \]; double score ; 比特就业课-专注IT大学生就业的精品课程 比特主页:https://m.cctalk.com/inst/s9yewhfr 比特就业课 **12.** **表达式求值** 表达式求值的顺序一部分是由操作符的优先级和结合性决定。 同样,有些表达式的操作数在求值的过程中可能需要转换为其他类型。 **12.1** **隐式类型转换** C 的整型算术运算总是至少以缺省整型类型的精度来进行的。 为了获得这个精度,表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为 **整型** **提升** 。 **整型提升的意义** : 表达式的整型运算要在 CPU 的相应运算器件内执行, CPU 内整型运算器 (ALU) 的操作数的字节长度 一般就是 int 的字节长度,同时也是 CPU 的通用寄存器的长度。 因此,即使两个 char 类型的相加,在 CPU 执行时实际上也要先转换为 CPU 内整型操作数的标准长 度。 通用 CPU ( general-purpose CPU )是难以直接实现两个 8 比特字节直接相加运算(虽然机器指令 中可能有这种字节相加指令)。所以,表达式中各种长度可能小于 int 长度的整型值,都必须先转 换为 int 或 unsigned int ,然后才能送入 CPU 去执行运算。 b 和 c 的值被提升为普通整型,然后再执行加法运算。 } ; 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 ; } // 实例 1 char a , b , c ; ... a = b + c ; 比特就业课-专注IT大学生就业的精品课程 比特主页:https://m.cctalk.com/inst/s9yewhfr 比特就业课 加法运算完成之后,结果将被截断,然后再存储于 a 中。 **如何进行整体提升呢?** 整形提升是按照变量的数据类型的符号位来提升的 整形提升的例子 : 实例 1 中的 a,b 要进行整形提升 , 但是 c 不需要整形提升 a,b 整形提升之后 , 变成了负数 , 所以表达式 a==0xb6 , b==0xb600 的结果是假 , 但是 c 不发生整形提升 , 则表 达式 c==0xb6000000 的结果是真 . 所程序输出的结果是 : c // 负数的整形提升 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 = 0xb6 ; short b = 0xb600 ; int c = 0xb6000000 ; if ( a == 0xb6 ) printf ( "a" ); if ( b == 0xb600 ) printf ( "b" ); if ( c == 0xb6000000 ) printf ( "c" ); return 0 ; } 比特就业课-专注IT大学生就业的精品课程 比特主页:https://m.cctalk.com/inst/s9yewhfr 比特就业课 实例 2 中的 ,c 只要参与表达式运算 , 就会发生整形提升 , 表达式 +c , 就会发生提升 , 所以 sizeof(+c) 是 4 个字 节 . 表达式 - c 也会发生整形提升 , 所以 sizeof( - c) 是 4 个字节 , 但是 sizeof(c) , 就是 1 个字节 . **12.2** **算术转换** 如果某个操作符的各个操作数属于不同的类型,那么除非其中一个操作数的转换为另一个操作数的类 型,否则操作就无法进行。下面的层次体系称为 **寻常算术转换** 。 如果某个操作数的类型在上面这个列表中排名较低,那么首先要转换为另外一个操作数的类型后执行运 算。 警告: 但是算术转换要合理,要不然会有一些潜在的问题。 **12.3** **操作符的属性** 复杂表达式的求值有三个影响的因素。 1. 操作符的优先级 2. 操作符的结合性 3. 是否控制求值顺序。 两个相邻的操作符先执行哪个?取决于他们的优先级。如果两者的优先级相同,取决于他们的结合性。 操作符优先级 // 实例 2 int main () { char c = 1 ; printf ( "%u\\n" , sizeof ( c )); printf ( "%u\\n" , sizeof ( + c )); printf ( "%u\\n" , sizeof ( - c )); return 0 ; } long double double float unsigned long int long int unsigned int int float f = 3.14 ; int num = f ; // 隐式转换,会有精度丢失 比特就业课-专注IT大学生就业的精品课程 比特主页:https://m.cctalk.com/inst/s9yewhfr 比特就业课 **操作** **符** **描述** **用法示例** **结果类** **型** **结合** **性** **是否控制求值** **顺序** () 聚组 (表达式) 与表达 式同 N/A 否 () 函数调用 rexp ( rexp , ...,rexp ) rexp L-R 否 \[

下标引用
rexp[rexp]
lexp L-R

.
访问结构成员
lexp.member_name lexp L-R

->
访问结构指针成员
rexp->member_name lexp L-R

++
后缀自增
lexp ++
rexp L-R

后缀自减
lexp --
rexp L-R

!
逻辑反
! rexp
rexp R-L

~
按位取反
~ rexp
rexp R-L

+
单目,表示正值

  • rexp
    rexp R-L

单目,表示负值

  • rexp
    rexp R-L

    ++
    前缀自增
    ++ lexp
    rexp R-L

    --
    前缀自减
    -- lexp
    rexp R-L

    *
    间接访问
    * rexp
    lexp R-L

    &
    取地址
    & lexp
    rexp R-L

    sizeof
    取其长度,以字节
    表示
    sizeof rexp sizeof( 类
    型 )
    rexp R-L

    ( 类
    型)
    类型转换
    ( 类型 ) rexp
    rexp R-L

    *
    乘法
    rexp * rexp
    rexp L-R

    /
    除法
    rexp / rexp
    rexp L-R

    %
    整数取余
    rexp % rexp
    rexp L-R

加法
rexp + rexp
rexp L-R

减法
rexp - rexp
rexp L-R

<<
左移位
rexp << rexp
rexp L-R

>>
右移位
rexp >> rexp
rexp L-R

>
大于
rexp > rexp
rexp L-R

>=
大于等于
rexp >= rexp
rexp L-R

<
小于
rexp < rexp
rexp L-R

<=
小于等于
rexp <= rexp
rexp L-R

比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课 操作

描述
用法示例
结果类

结合

是否控制求值
顺序

等于
rexp == rexp
rexp L-R

!=
不等于
rexp != rexp
rexp L-R

&
位与
rexp & rexp
rexp L-R

^
位异或
rexp ^ rexp
rexp L-R

|
位或
rexp | rexp
rexp L-R

&&
逻辑与
rexp && rexp
rexp L-R

||
逻辑或
rexp || rexp
rexp L-R

? :
条件操作符
rexp ? rexp : rexp
rexp N/A

赋值
lexp = rexp
rexp R-L

+=
以 ... 加
lexp += rexp
rexp R-L

-=
以 ... 减
lexp -= rexp
rexp R-L

*=
以 ... 乘
lexp *= rexp
rexp R-L

/=
以 ... 除
lexp /= rexp
rexp R-L

%=
以 ... 取模
lexp %= rexp
rexp R-L

<<=
以 ... 左移
lexp <<= rexp
rexp R-L

>>=
以 ... 右移
lexp >>= rexp
rexp R-L

&=
以 ... 与
lexp &= rexp
rexp R-L

^=
以 ... 异或
lexp ^= rexp
rexp R-L

|=
以 ... 或
lexp |= rexp
rexp R-L

, 逗号
rexp , rexp
rexp L-R

一些 问题表达式
注释:代码 1 在计算的时候,由于 * 比 + 的优先级高,只能保证, * 的计算是比 + 早,但是优先级并不
能决定第三个 * 比第一个 + 早执行。
所以表达式的计算机顺序就可能是:
// 表达式的求值部分由操作符的优先级决定。
// 表达式 1
a * b + c * d + e * f
a * b
c * d
a * b + c * d
e * f
a * b + c * d + e * f
比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课
编译器
---128 Tandy 6000 Xenix 3.2
---95
Think C 5.02(Macintosh)
---86
IBM PowerPC AIX 3.2.5
---85
Sun Sparc cc(K&C 编译器 )
---63
gcc , HP_UX 9.0 , Power C 2.0.0
4
Sun Sparc acc(K&C 编译器 )
21
Turbo C/C++ 4.5
22
FreeBSD 2.1 R
30
Dec Alpha OSF1 2.0
36
Dec VAX/VMS
42
Microsoft C 5.1
注释:同上,操作符的优先级只能决定自减 -- 的运算在 + 的运算的前面,但是我们并没有办法得
知, + 操作符的左操作数的获取在右操作数之前还是之后求值,所以结果是不可预测的,是有歧义
的。
表达式 3 在不同编译器中测试结果:非法表达式程序的结果
或者:
a * b
c * d
e * f
a * b + c * d
a * b + c * d + e * f
// 表达式 2
c + -- c ;
// 代码 3- 非法表达式
int main ()
{
int i = 10 ;
i = i -- - -- i * ( i = - 3 ) * i ++ + ++ i ;
printf ( "i = %d\n" , i );
return 0 ;
}
比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课 这个代码有没有实际的问题?
有问题!
虽然在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() - fun() * fun() ; 中我们只能通过操作符的优先级得知:先算乘法,
再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。
Linux 环境的结果:
VS2013 环境的结果:
// 代码 4
int fun ()
{
static int count = 1 ;
return ++ count ;
}
int main ()
{
int answer ;
answer = fun () - fun () * fun ();
printf ( "%d\n" , answer ); // 输出多少?
return 0 ;
}
// 代码 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 环境 gcc 编译器, VS2013 环境下都执行,看结果。
比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课 看看同样的代码产生了不同的结果,这是为什么?
简单看一下汇编代码 . 就可以分析清楚 .
这段代码中的第一个 + 在执行的时候,第三个 ++ 是否执行,这个是不确定的,因为依靠操作符的优先级
和结合性是无法决定第一个 + 和第
三个前置 ++ 的先后顺序。
总结 :我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径,那这个表达式就是存在问题
的。
本章完
比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课 比特就业课-专注IT大学生就业的精品课程
比特主页:https://m.cctalk.com/inst/s9yewhfr
比特就业课

相关推荐
默凉2 分钟前
C++ 虚函数(多态,多重继承,菱形继承)
开发语言·c++
我爱Jack4 分钟前
Java List 使用详解:从入门到精通
java·开发语言·数据结构
-凌凌漆-10 分钟前
【Qt】Qt QML json处理
开发语言·qt·json
手握风云-11 分钟前
JavaEE初阶第八期:解锁多线程,从 “单车道” 到 “高速公路” 的编程升级(六)
java·开发语言
秋说15 分钟前
【PTA数据结构 | C语言版】在顺序表 list 的第 i 个位置上插入元素 x
c语言·数据结构·list
楼田莉子1 小时前
数据学习之队列
c语言·开发语言·数据结构·学习·算法
写不出来就跑路1 小时前
SpringBoot静态资源与缓存配置全解析
java·开发语言·spring boot·spring·springboot
我命由我123451 小时前
Vue 开发问题:Missing required prop: “value“
开发语言·前端·javascript·vue.js·前端框架·ecmascript·js
企鹅侠客1 小时前
Bash与Zsh与Fish:在Linux中你应该使用哪个Shell
linux·开发语言·bash·zsh·fish
秋说1 小时前
【PTA数据结构 | C语言版】返回单链表 list 中第 i 个元素值
c语言·数据结构·list