逻辑操作符

&& 逻辑与（左边为0右边就不算了）

|| 逻辑或（左边为1右边就不算了）

#include <stdio.h>
int main（）{
int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;//a为0右边不计算了
//i = a++||++b||d++;
printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);//1,2,3,4
return 0;
}

条件操作符

三目运算符

exp1表达式为真整个表达式为exp2

exp1表达式为假整个表达式为exp3

代码实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main() {
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int max = a > b ? a : b;//如果a>b,max=a,反之则为max=b;
  printf("%d", max);
}

上面的代码还可以表示为

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main() {
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  int max = 0;
  if (a > b) {
    max = a;
  }else{
    max = b;
  }
  printf("%d",max);
}

逗号表达式

逗号表达式，就是用逗号隔开的多个表达式。

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

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少
答案是13（从左往右依次计算，c就是最后一个表达式的值）；

下标引用，函数调用，结构成员

下标引用

1.[ ] 下标引用操作符

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

说白了就是数组中下标

int arr[10]={1,2,3,4,5,6,7,8,9,10};
printf("%d",arr[0]);

arr[0]就能找到数组中下标为0的值1

函数调用

函数名加（）括号里是参数

特殊的是printf（）；他的参数是可变参数列表

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

结构成员

访问一个结构的成员

. 结构体.成员名

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

第一种方式

struct yinyue {
  char arr[10];
  char sum[100];
};
int main() {
  struct yinyue p = { "周杰伦","我落泪情绪零碎" };
  printf("%s的作者是%s", p.sum, p.arr);
  system("pause");
}

第二种方式（不同的是结构体地址访问成员变量）

struct yinyue {
  char arr[10];
  char sum[100];
};
print(struct yinyue* p) {
  printf("%s的作者是%s", p->sum, p->arr);
}
int main() {
  struct yinyue p = { "周杰伦","我落泪情绪零碎" };
  print(&p);
  system("pause");
}

表达式求值

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

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

上代码

int main() {
  int a = 1;
  int b = 2;
  int c = 1 + a * b;//*优先级较高
}

隐式类型转换

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

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

提升。（整型提升是按照数据类型符号位来提升的）

1.cpu运算时都是标准长度，都要提供四字节空间

2.cpu运算很难用8比特位进行计算所以要转为int或unsigned int才好运算

3.并且char相加进位有可能会丢位

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

int main() {
  char a = 5;
  //二进制00000000000000000000000000000101
  //截断后为00000101
  char b = 127;
  //二进制00000000000000000000000001111111
  //截断后为01111111
  char c = a + b;
  //a整形提升00000000000000000000000000000101
  //b整形提升00000000000000000000000001111111
  //c为      00000000000000000000000010000100
  //截断后为10000100
  printf("%d",c);
  //c整形提升11111111111111111111111110000100
  //反码为   11111111111111111111111110000011
  //补码为   10000000000000000000000001111100
}

//实例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整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表

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

所程序输出的结果是:

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

//%u打印10进制无符号位（二进制是否看成符号）

实例2中的,

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

节.

算数转化

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

型，否则操作就无法进行。下面的层次体系称为寻常算术转换。（转换规则如下图箭头从低到高）

int a=0;
float b=1.0f;
float c=a+b

操作符的属性

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

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

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(); 中我们只能通过操作符的优先级得知：先算乘法，
再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。

#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环境下都执行，看结果。

linux运行

vs运行

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

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

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

和结合性是无法决定第一个 + 和第

三个前置 ++ 的先后顺序。

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

操作符详解（二）