C语言操作符及表达式

操作符

算术操作符

算数操作符

注意
1.+、-、*、/这四个运算符均可用于整数及浮点数的运算。
2.当使用/运算符时，如果两个操作数均为整型，那么执行整数除法，运算结果也为整型；如果两个操作数至少一个为浮点数，那么执行浮点数运算，运算结果为浮点型。
3.%运算符只能用于两个整数相除，返回余数。

移位操作符

左移操作符 移位规则：

左边抛弃、右边补0

右移操作符 移位规则：

首先右移运算分两种：

1. 逻辑移位 左边用0填充，右边丢弃(无符号数)
2. 算术移位 左边用原该值的符号位填充，右边丢弃(有符号数)
   补0，补1取决于该变量本身的类型和内部写入数据无关

警告⚠ ： 对于移位运算符，不要移动负数位，这个是标准未定义的。

位操作符

例题 不能创建临时变量（第三个变量），实现两个数的交换

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

赋值操作符

符号说明：

= —> 进行简单赋值操作
+=、-=、*=、/=、%=、>>=、<<=、&=、|=、^= —> 复合赋值符，进行复合赋值操作

举例说明：
（简单赋值）

int x = 10;
x = 20;    //简单赋值操作
double y = 10.0;
y = 20.0;  //简单赋值操作
 
int a = 5;
int b = 7;
int c = 9;
c = b = a+1;   //连续赋值操作
 +=、-=、*=、/=、%=、>>=、

单目操作符

举例说明
!（逻辑反操作）：

int a = 10;
if(!a)    //!：逻辑反操作   
{
    //doSomething;
}

-（负值）、+（正值）：

int a = 10;    //正值
int b = -10;   //负值

&（取地址）：

int a = 10;
int *pa = &a;    //将变量a的地址保存在变量pa中，pa指向a，此时pa是一个指针变量

sizeof（求操作数的类型长度）：

int a = 10;
printf("%d\n",sizeof(a));   //结果为4（字节）
printf("%d\n",sizeof(int)); //结果为4（字节）
printf("%d\n",sizeof a);   //结果为4（字节）  求变量的长度时可以省略括号
printf("%d\n",sizeof int); //错误，求类型的长度时不能去掉括号

//++和–运算符
//前置++和–
//前置++和–：

 #include <stdio.h>
 int main()
 {
 int a = 10;
 int x = ++a;
 //先对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;
 }

关系操作符

逻辑操作符

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; 
    }
//程序输出的结果是什么？

条件操作符

l练习

if (a > 5)
        b = 3;
else
        b = -3;
转换成条件表达式，是什么样？

逗号表达式

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

例题：

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？
13

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

1.[ ]下标引用操作符
操作数：一个数组名+一个索引值

2.（）函数调用操作符：接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

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

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

表达式的值

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

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

如何进行整体提升呢？

1.整形提升是按照变量自身的数据类型的符号位来提升的
2.在表达式运算当中，参与运算的变量类型必一致

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

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运
算。
警告： 但是算术转换要合理，要不然会有一些潜在的问题。

操作符的属性
复杂表达式的求值有三个影响的因素。

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