C语言初阶--操作符

1.操作符分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2.算术操作符

+  -  *  /  %

/ 整型的除法       1/2 ——>0浮点型的除法     1.0/2 ——> 0.51/2.0 ——> 0.51.0/2.0 ——> 0.5
% 计算的是整除后的余数

#include <stdio.h>int main()
{int a = 7 % 2; // 7除以2的余数为1int b = 7 / 2;printf("%d\n", a); //1printf("%d\n", b); //3
}
//取模操作符%的两端必须是整数

3.移位操作符（涉及二进制）

>>右移操作符   
<<左移操作符
注：移位操作符的操作数只能是整数。   

16进制 0-9，a-f

10进制 0-9

8进制 0-7

2进制 0-1

整数的二进制表示有3种：原码、反码、补码。

正的整数的原码、反码、补码相同；负的整数的原码、反码、补码需要计算。

eg：

整数7

00000000 00000000 00000000 00000111 - 原码

00000000 00000000 00000000 00000111 - 反码

00000000 00000000 00000000 00000111 - 补码

整数-7

10000000 00000000 00000000 00000111 - 原码（负数高位为1，整数高位为0）

11111111 11111111 11111111 11111000 - 反码（原码的符号位不变，其他位按位取反）

11111111 11111111 11111111 11111001 - 补码（反码+1）

结论：整数在内存中存储的是补码。

3.1左移操作符

左移操作符的计算规则：左边丢弃，右边补0

//移位操作符，移动的是二进制 #include <stdio.h>
int main()
{int a = 7;int b = a << 1; //左移操作符，移动的是二进制位printf("a=%d\n", a); //a=7printf("b=%d\n", b); //b=14return 0;
}

#include <stdio.h>
int main()
{int a = -7;int b = a << 1; //左移操作符，移动的是二进制位printf("a=%d\n", a); //a=-7printf("b=%d\n", b); //b=-14return 0;
}

int main()
{float f = 3.14f;float f2 = f << 1; //不支持，errorreturn 0;
}

移位操作符的操作数只能是整数

3.2右移操作符

算术移位：右边丢弃，左边补原符号位

逻辑移位：右边丢弃，左边补0

#include <stdio.h>
int main()
{int a = 7;int b = a >> 1; printf("a=%d\n", a); //a=7printf("b=%d\n", b); //b=3return 0;
}

#include <stdio.h>
int main()
{int a = -7;int b = a >> 1; printf("a=%d\n", a); //a=-7printf("b=%d\n", b); //b=-4return 0;
}

此例：说明vs编译器采用的是算术移位。

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

int main()
{int a = -7;int b = a >> -2; //errorreturn 0;
}

4.位操作符

& 按（2进制）位与
| 按（2进制）位或
^ 按（2进制）位异或    
注：位操作符的操作数只能是整数。   

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

3

00000000 00000000 00000000 00000011 - 原码、反码、补码

-5

10000000 00000000 00000000 00000101 - 原码

11111111 11111111 11111111 11111010 - 反码

11111111 11111111 11111111 11111011 - 补码

按位与：全为1则为1，否则为000000000 00000000 00000000 00000011     //3的补码11111111 11111111 11111111 11111011     //-5的补码00000000 00000000 00000000 00000011     //按位与的结果（补码），因为高位为0，为正数，所以原码、反码、补码相同%d打印一个有符号的整数（原码）

#include <stdio.h>
int main()
{int a = 3;int b = -5;int c = a | b;printf("c=%d\n", c); //c=-5return 0;
}

按位或：只要有1则为100000000 00000000 00000000 00000011     //3的补码11111111 11111111 11111111 11111011     //-5的补码11111111 11111111 11111111 11111011     //按位或的结果（补码）11111111 11111111 11111111 11111010     //按位或的结果（反码）10000000 00000000 00000000 00000101    //按位或的结果（原码） -5

#include <stdio.h>
int main()
{int a = 3;int b = -5;int c = a ^ b;printf("c=%d\n", c); //c=-8return 0;
}

按位异或：相同为0，相异为100000000 00000000 00000000 00000011     //3的补码11111111 11111111 11111111 11111011     //-5的补码11111111 11111111 11111111 11111000     //按位异或的结果（补码）11111111 11111111 11111111 11110111     //按位异或的结果（反码）10000000 00000000 00000000 00001000  //按位异或的结果（原码） -8

4.1案例：实现两个数的交换

//实现两个数的交换
//原始思路
#include <stdio.h>
int main()
{int a = 3;int b = 5;int c = 0; // 空瓶printf("交换前：a=%d b=%d\n", a, b);c = a;a = b;b = c;printf("交换后：a=%d b=%d\n", a, b);return 0;
}

//不能创建临时变量（第三个变量），实现两个数的交换
//这种方法存在溢出的问题
#include <stdio.h>
int main()
{int a = 3;int b = 5;printf("交换前：a=%d b=%d\n", a, b);a = a + b;b = a - b;a = a - b;printf("交换后：a=%d b=%d\n", a, b);return 0;
}

分析：

//不能创建临时变量（第三个变量），实现两个数的交换
//有局限性，可读性低，实际开发中运用第一种创建临时变量来进行交换效率更高
#include <stdio.h>
int main()
{int a = 3;int b = 5;printf("交换前：a=%d b=%d\n", a, b);/a = a ^ b; //a=3^5b = a ^ b; //3^5^5  ——> b=3a = a ^ b; //3^5^3  ——> a=5printf("交换后：a=%d b=%d\n", a, b);return 0;
}

5.赋值操作符

赋值操作符是一个很棒的操作符，它可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

int main()
{int a = 0; //初始化int b = 0;b = 20; //赋值return 0;
}

int main()
{int a = 10;int x = 0;int y = 20;//a = x = y+1; //连续赋值，不推荐这种写法，垃圾代码x = y+1;a = x; //更加清晰爽朗，且更易于调试return 0;
}

5.1复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

int main()
{int a = 3;a = a + 5;a += 5;a = a >> 1;a >>= 1;return 0;
}

6.单目操作符

！           逻辑反操作
-            负值
+            正值
&            取地址    
sizeof       操作数的类型长度（以字节为单位）
~            对一个数的二进制按位取反    
--           前置、后置--
++           前置、后置++
*            间接访问操作符（解引用操作符） 
(类型)        强制类型转换

单目操作符，只有一个操作数。

双目操作符（eg：a+b），+操作符有两个操作数。

int main()
{int flag = 3;if (flag)  //flag为真，进入if{}if (!flag)  //flag为假，!flag为真，进入if{}return 0;
}//C语言中，0表示假，非0表示真

#include <stdio.h>
int main()
{int a = -10;int b = +a;printf("%d\n", a); //-10printf("%d\n", b); //-10return 0;
}

#include <stdio.h>
int main()
{int a = -10;int b = -a;printf("%d\n", a); //-10printf("%d\n", b); //10return 0;
}

#include <stdio.h>
int main()
{int a = 10;printf("%p\n", &a); //每次运行都会在内存中重新开辟空间，所以每个运行后的地址不同//&a：取地址a，取出的是变量a在内存中的起始地址int* p = &a; //p就是指针变量return 0;
}

#include <stdio.h>
int main()
{int a = 10;//int n = sizeof(a); //计算a所占内存空间的大小，单位是字节int n = sizeof(int); //sizeof是一个操作符（运算符）//计算变量所占内存空间的大小,单位是字节//计算类型所创建的变量所占内存空间的大小,单位是字节printf("n=%d\n", n); //n=4return 0;
}

#include <stdio.h>
int main()
{int arr[5] = {0};printf("%d\n", sizeof(arr)); //40return 0;
}

6.1 ~ 按（2进制）位取反

~ 是按（2进制）位取反，将0变为1，1变为0

#include <stdio.h>
int main()
{int a = 0;printf("%d\n", ~a); //-1return 0;
}

00000000 00000000 00000000 00000000 - 原码、反码、补码11111111 11111111 11111111 11111111 - （~a的补码）11111111 11111111 11111111 11111110 - （~a的反码）10000000 00000000 00000000 00000001 - （~a的原码）  =-1

~ 用途：修改其中的某一（2进制）位

#include <stdio.h>
int main()
{int a = 13;a |= (1 << 1);printf("%d\n", a); //15a &= (~(1 << 1)); printf("%d\n", a); //13return 0;
}

00000000 00000000 00000000 00001101 - 原码、反码、补码（13）现在将其第二位0变为100000000 00000000 00000000 00000010 - 补码（想得到目标的结果，相当于将1的补码左移1位）00000000 00000000 00000000 00001111 - 补码、反码、原码（与13进行或的结果）将第二位变回000000000 00000000 00000000 00001111 - 原码、反码、补码（15）11111111 11111111 11111111 11111101 - 补码（下面是和这个数&按位与的结果：目标结果）思考怎样变成这个结果呢？？00000000 00000000 00000000 00001101 - 补码（13，原来的数，目标结果）11111111 11111111 11111111 11111101 - 补码（发现~按位取反可以接近目标结果）00000000 00000000 00000000 00000010 - 补码（上面是~按位取反的结果）

#include <stdio.h>
int main()
{int a = 3;int b = ++a; //前置++，先++，后使用。类似于a=a+1,b=aprintf("%d\n", a); //4printf("%d\n", b); //4return 0;
}

#include <stdio.h>
int main()
{int a = 3;int b = a++; //后置++，先使用，后++。类似于b=a,a=a+1printf("%d\n", a); //4printf("%d\n", b); //3return 0;
}

#include <stdio.h>
int main()
{int a = 10;printf("%d\n", a--); //10printf("%d\n", a); //9return 0;
}

void test(int a)
{}
int main()
{int a = 10;test(a--); //传过去的a是10,理解return 0;
}

int main()
{int i = 0;for (i = 0; i < 10; i++)  //在内置类型i++和++i，区别不大{}for (i = 0; i < 10; ++i)  //在内置类型i++和++i，区别不大{}    return 0;
}

自定义类型中前置++效率更高。（自己了解）

#include <stdio.h>
int main()
{int a = 10;int* p = &a;*p = 20; //a=20printf("%d\n", a); //20return 0;
}

#include <stdio.h>
int main()
{int a = (int)3.14;printf("%d\n", a); //3return 0;
}

sizeof操作符补充

#include <stdio.h>
int main()
{int a = 0;printf("%d\n", sizeof(a));printf("%d\n", sizeof(int));printf("%d\n", sizeof a); //ok,由此证明sizeof是操作符，非函数printf("%d\n", sizeof int); //errorreturn 0;
}
//strlen是库函数，求字符串长度

7.关系操作符

>
>=
<
<=
!=       用于测试“不相等”
==       用于测试“相等”

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

不是所有东西都可以用等号比较。

#include <stdio.h>
int main()
{if (3 == 5){}if ("abc" == "abcdef")  //error,这样写比较的是2个字符串首字符的地址{}//两个字符串比较相等，使用strcmpreturn 0;
}

8.逻辑操作符

&&  逻辑与，并且（两个都为真才为真，一个为假则为假）
||  逻辑或，或者（两个都为假才为假，一个为真则为真）

注意：

区分逻辑与&& 按位与&

区分逻辑或|| 按位或|

#include <stdio.h>
int main()
{int a = 3;int b = 5;int c = a && b; //而且，只计算真假，真&&真为真printf("%d\n", c); //return 0;
}

#include <stdio.h>
int main()
{int a = 3;int b = 0;int c = a && b; //而且，真&&假为假printf("%d\n", c); //0return 0;
}

#include <stdio.h>
int main()
{int a = 3;int b = 0;int c = a || b; //或者printf("%d\n", c); //1return 0;
}

#include <stdio.h>
int main()
{int i = 0, a = 0, b = 2, c = 3, d = 4;i = a++ && ++b && d++; //0 &&···   ，&&后面部分不用再计算了，最终结果都为0（假）printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d); return 0;
}

#include <stdio.h>
int main()
{int i = 0, a = 1, b = 2, c = 3, d = 4;i = a++ && ++b && d++; printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d); //2 3 3 5return 0;
}

不再举例——总结：

&& 左边为假，右边就不计算了；

|| 左边为真，右边就不计算了；

9.条件操作符（三目操作符）

exp1 ? exp2 : exp3
真      √       ×
假      ×       √

int main()
{int a = 3;int b = 0;if (a > 5)b = 3;elseb = -3;//修改效果如下(a>5) ? (b=3) : (b=-3);//再次美化b = (a>5 ? 3 : -3);return 0;
}

//使用条件表达式求两个数的最大值
int main()
{int a = 3;int b = 0;int max = (a > b ? a : b);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("c=%d\n", c); //c=13return 0;
}

11.下标引用[]、函数调用()和结构成员. ->

int main()
{int arr[10] = {0};arr[7] = 8; //[]:下标引用操作符，它的两个操作数是arr和7，将下标为7的元素改为87[arr] = 9; //类似3+5——>5+3，符合交换律，[]下标引用操作符访问元素时适用return 0;
}
//arr[7] 等价于 *(arr+7)，分析如下：
//arr是数组首元素的地址
//arr+7就是跳过7个元素，指向了第8个元素
//*(arr+7)就是第8个元素
//所以：arr[7] 等价于 *(arr+7) 等价于 *(7+arr) 等价于 7[arr]

//函数定义
int Add(int x; int y)
{return x + y;
}
int main()
{int a = 10;int b = 20;//函数调用int c = Add(a, b); //():函数调用操作符，它的操作数是Add,a,b。它至少有一个操作数。return 0;
}

11.1结构成员

访问一个结构的成员：

• 结构体指针->成员
• 结构体对象.成员

//error
#include <stdio.h>
#include <string.h>struct Stu
{char name[20];int age;double score;
};void set_stu(struct Stu ss)  //形参是实参的一份临时拷贝
{strcpy(ss.name, "zhangsan");ss.age = 20;ss.score = 100.0;
}void print_stu(struct Stu ss)
{printf("%s %d %lf\n", ss.name, ss.age, ss.score);
}int main()
{struct Stu s = {0};set_stu(s);print_stu(s);return 0;
}

结构体指针->成员

结构体对象.成员

//修改#include <stdio.h>
#include <string.h>struct Stu
{char name[20];int age;double score;
};void set_stu(struct Stu* ps)
{//strcpy((*ps).name, "zhangsan");//(*ps).age = 20;  //结构体对象.成员//(*ps).score = 100.0;//上面略显啰嗦，修改strcpy(ps->name, "zhangsan");ps->age = 20; //结构体指针->成员ps->score = 100.0;
}//void print_stu(struct Stu ss)  //传值浪费空间
//{
//    printf("%s %d %lf\n", ss.name, ss.age, ss.score); //zhangsan 20 100.000000
//}
//修改如下：
void print_stu(struct Stu* ps)
{printf("%s %d %lf\n", ps->name, ps->age, ps->score); //zhangsan 20 100.000000
}int main()
{struct Stu s = { 0 };set_stu(&s);print_stu(s);return 0;
}

12.表达式求值

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

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

12.1隐式类型转换

（小于整型）

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

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

#include <stdio.h>
int main()
{char a = 5;char b = 126;char c = a + b; //表达式中的字符操作数在使用之前被转换为普通整型:整型提升printf("%d\n", c);return 0;
}

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器（ALU）的操作数的字节长度一般是int的字节长度，同时也是CPU的通用寄存器的长度。

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

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

如何进行整型提升？

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

负数的整型提升：高位补充符号位，即为1

正数的整型提升：高位补充符号位，即为0

无符号的整型提升：高位补0

int main()
{char c = -1; //-1是整数，32个比特位return 0;
}

10000000 00000000 00000000 00000001 - （-1的原码）

11111111 11111111 11111111 11111110 - （-1的反码）

11111111 11111111 11111111 11111111 - （-1的补码）

char类型的变量c，1字节，8个比特位，如下：

11111111 - （c）右往左截断，取8个比特位，剩下的丢弃

整型提升如下：（按照变量的数据类型的符号位来提升）

11111111 11111111 11111111 11111111

//char 1byte 8bit
//int  4byte 32bit
#include <stdio.h>
int main()
{char a = 5;//00000000 00000000 00000000 00000101//截断//00000101 - achar b = 126;//00000000 00000000 00000000 01111110 //截断//01111110 - bchar c = a + b; //表达式中的字符操作数在使用之前被转换为普通整型:整型提升//整型提升://00000000 00000000 00000000 00000101 - a//00000000 00000000 00000000 01111110 - b//00000000 00000000 00000000 10000011（相加结果）//截断//10000011 - c//整型提升：//11111111 11111111 11111111 10000011 - c的补码//11111111 11111111 11111111 10000010 - c的反码//10000000 00000000 00000000 01111101 - c的原码//printf("%d\n", c); //-125return 0;
}

12.2算术转换

（大于整型，向上转换）

long double
double
float
unsigned long int
long int
unsigned int
int    

12.3操作符的属性

复杂表达式的求值有3个影响的因素：

• 操作符的优先级
• 操作符的结合性
• 是否控制求值顺序（逻辑与&&；逻辑或||；条件表达式exp1？exp2：exp3；逗号表达式，）

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

N/A：无结合性；

L-R：从左向右；

R-L：从右向左。

一些问题表达式：

//问题表达式1
a*b + c*d + e*f;

//问题表达式2
c + --c;

//问题表达式3

调试过程中，鼠标右击——>转到反汇编：

ebp是寄存器，其中存放的是地址。

ebp-8它也是地址。

eax，ebx，ecx，edx都是寄存器。

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

总结

今天就暂且更新至此吧，期待下周再会。如有错误还请不吝赐教。希望对您学习有所帮助，翻页前留下你的支持，以防下次失踪了嗷。

作者更新不易，免费关注别手软。