正文

7.关系操作符

>

>=

<

<=

!=                   用于测试“不相等”

==                  用于测试“相等”

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

警告：

在编程的过程中 == 和 = 不小心写错，导致的错误。

8.逻辑操作符

&&       逻辑与（我们经常口头所说的“并且”）

||          逻辑或（“或者”）

简单做代码演示：

#include <stdio.h>
int main()
{
  int a = -10;
  int b = 10;
  if (a >= 0 && b >= 0)
    printf("yes\n");
  else
    printf("no\n");
  if (a >= 0 || b >= 0)
    printf("yes\n");
  else
    printf("no\n");
}

逻辑操作符的结果无非是真（1）或假（0）两种。所以我们经常在做判断语句的时候使用。

这是一道笔试题：

#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++先使用后++，其在表达式中的值为0，0为假。所以不管&&后面的表达式是否真假，语句整体的结果都为假。因为“假”&&“任意”都等于“假”。

同理，“真”或者“任意”都等于“真”。

所以计算机为了效率，根本没必要管“任意”的结果，也就不会执行“任意”里的表达式。

9.条件操作符

exp1 ? exp2 : exp3

条件操作符的执行逻辑是，如果表达式1的结果为真，就执行表达式2，否则就执行表达式3。

那么我们用一道小练习来体会：

1.
if (a > 5)
       b = 3;
else
       b = -3;
转换成条件表达式，是什么样？
2.使用条件表达式实现找两个数中较大值。

答案如下：

//1.
#include <stdio.h>
int main()
{
  int a = 10;
  int b = 0;
  b = a > 5 ? 3 : -3;
  return 0;
}
//2.
#include <stdio.h>
int MAX(int a, int b)
{
  return a > b ? a : b;
}
int main()
{
  int a = 10;
  int b = 0;
  int max=MAX(a,b);
  printf("%d", max);
  return 0;
}

10.逗号表达式

exp1, exp2, exp3, …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", c);//结果是13
  return 0;
}

逗号表达式使用场景并不是很多，但是我们依旧要会使用。

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

1. [ ] 下标引用操作符

操作数：一个数组名+ 一个索引值

int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[] 的两个操作数是arr和9。

2. ( ) 函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include <stdio.h>
void test1()
{
  printf("hehe\n");
}
void test2(const char* str)
{
  printf("%s\n", str);
}
int main()
{
  test();         //实用（）作为函数调用操作符。
  test2("hello world.");//实用（）作为函数调用操作符。
  return 0;
}

3. 访问一个结构的成员

.结构体.成员名

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

#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;
}

于这里还没有学习结构体与指针，我们简单介绍即可。

12.表达式求值

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

12.1隐式类型转换

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

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

整型提升的意义：

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

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

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

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

//实例1
char a,b,c;
...
a = b + c;

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

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

如何进行整型提升呢？

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

//负数的整形提升
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;
}

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

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

升 , 则表达式 c==0xb6000000 的结果是真 . 所程序输出的结果是: c

实例 1 中的 a,b 要进行整形提升 , 但是 c 不需要整形提升
a,b 整形提升之后 , 变成了负数 , 所以表达式 a==0xb6 , b==0xb600 的结果是假 , 但是 c 不发生整形提
升 , 则表达式 c==0xb6000000 的结果是真 . 所程序输出的结果是: c
————————————————
版权声明：本文为CSDN博主「花想云(西安第一深情)」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gllll_yu/article/details/127420897

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

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

12.2算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的

类型，否则操作就无法进行。下面的层次体系称为寻常算术转换 。

long double

double

float

unsigned long int

long int

unsigned int

int

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

警告：

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

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

12.3操作符的属性

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

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

一些 问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码 1 在计算的时候，由于 * 比 + 的优先级高，只能保证， * 的计算是比 + 早，但是优先级并不

能决定第三个 * 比第一个 + 早执行。

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

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;

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

//代码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() ; 中我们只能通过操作符的优先级得知：先算乘法， 再算减法。

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

//代码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编译器，VS2022环境下都执行，看结果。

Linux环境结果：10，4

VS2022环境结果：12，4

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

简单看一下汇编代码 . 就可以分析清楚 .

这段代码中的第一个 + 在执行的时候，第三个 ++ 是否执行，这个是不确定的，因为依靠操作符的

优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

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

本章完！