逻辑与和或的特点：

我们来看下面的代码：

#include <stdio.h>
int main()
{
  int i = 0, a = 0, b = 2, c = 3, d = 4;
  i = a++ && ++b && d++;
  printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
  printf("\n");
  i = 0, a = 0, b = 2, c = 3, d = 4;
  i = a++ || ++b || d++;
  printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
  return 0;
}
//程序输出的结果是什么？

代码运行结果如下：

逻辑与：

如果有一个条件未达成，整个条件就是假，也就是说:

a++ && ++b这个表达式为假，那么后面的表达式也一定为假。

所以也就导致了只有a++，其他的表达式并没有进行。

逻辑或：

如果一个条件达成后面的条件就不会在进行了，因为只要有一个成功，整个表达式就为真，但是这里第一个条件为假，第二个为真，整个表达式为真，那么后面的表达式也一定为真。

结果就是只有a++和++b执行。

8. 条件操作符

这个也被称为三目操作符。

exp1 ? exp2 : exp3

这个的意思是，先判断exp1，如果exp1表达式为真，那么结果就是exp2，如果为假结果就是exp3.

我们做一个练习：

#include <stdio.h>
int main()
{
  int a;
  int b;
  scanf("%d", &a);
  if (a > 5)
    b = 3;
  else
    b = -3;
  printf("%d", b);
  return 0;
}

上面这段代码转换成条件表达式，是什么样？

#include <stdio.h>
int main()
{
  int a;
  scanf("%d", &a);
  printf("%d", (a > 5) ? (3) : (-3));
  return 0;
}

这就是条件操作符的使用方法。

9. 逗号表达式

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

代码1：第一个表达式为a>b，当然这个式子是不成立的，但是我们并不用管它，因为它并不影响后面的结果，第二个表达式是a=12，第三个表达式是a=12，第四个表达式是b=13。所以c就是13。

代码2：最后一个表达式才是具有意义的。

代码3：这个循环可以改成下面那段代码。

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

10.1 [ ] 下标引用操作符

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

这个之前我们用过好多次了：

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

10.2 ( ) 函数调用操作符

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

这个操作符我们也是非常的熟悉了：

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

代码运行如下：

10.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;//结构成员访问
  printf("%d\n", stu.age);
  set_age1(stu);
  printf("%d\n", stu.age);
  pStu->age = 20;//结构成员访问
  printf("%d\n", pStu->age);
  set_age2(pStu);
  printf("%d\n", pStu->age);
  return 0;
}

代码的运行结果：

至于为什么第二个结果为什么是20不是18，因为我们之前说过，set_age1这个函数里面的参数只是一份临时拷贝（如果不懂可以去看看我的函数栈帧的创建与销毁）。

当然这里的结构体指针的访问也可以这么表达：

printf(“%d\n”, (*pStu).age);

11. 表达式求值

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

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

11.1 隐式类型转换

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

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

整型提升的意义：

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

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

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

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

举个例子：

#include <stdio.h>
int main()
{
  char a = 2;
  char b = 127;
  char c = a + b;
  printf("%d", c);
  return 0;
}

我们都清楚，其实字符类型也属于整形，因为储存的是ASCII码值。

但是数据类型char只有个8个比特位，所以我们的结果有点 ‘ 异常 ’ ：

我们来分析一下这是为什么：

我们都知道，一个整型是4个字节，一个字节是8个比特位，字符类型是1个字节，8个比特位。

这是我们初始化的时候的内部储存空间。

但是我们计算的时候需要整型提升，关于整型提升是这样的：

负数的整形提升

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位：

1111111

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为1

提升之后的结果是：

11111111111111111111111111111111

正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位：

00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为0

提升之后的结果是：

00000000000000000000000000000001

无符号整形提升，高位补0

所以我们的提升是这样的过程：

c变成这样之后，我们又要存入char类型的变量c，所以又会变成8个比特位的内存。也就是说char c里面是这样的：

8个比特位只能容纳这些，最后用%d打印，又要整型提升：

11111111111111111111111110000001 补码

11111111111111111111111110000000 反码

10000000000000000000000001111111 原码

很明显，打印的结果是用原码来算的。

c = -127

整型提升的例子

//实例1
#include <stdio.h>
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整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真。

所程序输出的结果是:

c

//实例2
#include <stdio.h>
int main()
{
  char c = 1;
  printf("%u\n", sizeof(c));
  printf("%u\n", sizeof(+c));
  printf("%u\n", sizeof(-c));
  return 0;
}

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

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

11.2 算术转换

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

long double

double

float

unsigned long int

long int

unsigned int

int

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

比如说如果一个int类型和double进行运算，那么int一定会转换成double类型，然后再进行运算。

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

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

如果打印整型变量num，结果就是3。

11.3 操作符的属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
   两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
   操作符优先级
   N/A是不讨论结合性。
   L-R是从左到右
   R-L是从右到左

最上面的优先度最高，越往下越低。

一些问题表达式

这些问题表达式就和先有鸡还是先有蛋一样坑人！

//表达式的求值部分由操作符的优先级决定。
//表达式1 
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; 
 }

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

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

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

ab
cd

ab + cd

ef
ab + cd + ef

或者：

ab
cd

ef
ab + cd
ab + cd + ef

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

代码3：表达式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编译器，VS2013环境下都执行，看结果。

VS2022：

linux：

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

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

这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

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

结束语

家人们请点个赞，路过的大佬指点错误和不足！！！