C语言中的操作符、常见关键字和指针三者之间有何关联？

本文共计2516个文字，预计阅读时间需要11分钟。

1、'0' + 0 + '\0' 的区别：'\0' 是字符串 'abcd\0' 的结束标志，是转义字符，数值为0；'0' 是数字0，数值为0；仅与 '\0' 的数值相同：'\0' 属于字符，ACSII的值为48，不是相对而言的数字字符，其他：'a' + 'c' + 'q' 是字母字符。

1、'\0' 0 '0' 的区别

'\0'：是字符串'abcd\0'的结束标志，是转义字符，数值为0

0：只与'\0'的数值相同

'0'：属于字符，ACSII的值为48，不过相对而言是数字字符，其他：'a' 'c' 'q' 是字母字符

EOF——end of file—文件结束标志，值为-1

eg：使用自定义函数Min，求最小值

#include <stdio.h> #include <string.h> int Min(int x,int y) { if(x>y) return y; else return x; } int main() { int num1=10; int num2=20; int min=0; min=Min(num1,num2); printf("min=%d\n",min); return 0; }

sizeof介绍：

int a=10; int arr[]={1,2,3,4,5,6}; //数组大小=4*6， //最前面的int指的是数组中元素的数据类型 相当于int[6] printf("%d\n",sizeof(a)); //结果4 printf("%d\n",sizeof a);//结果4 //前两行结果相等，括号是可以省略的，是由于sizeof是操作符 不受影响； 如果是函数a两边括号不能省略的 //(a)也可以写为(int),但是int两边的括号不能省略 语法-类型错误 printf("%d\n",sizeof(arr)/sizeof(arr[0]));\\求所在数组含有的元素个数

——————————————————————

一、操作符

总结：

单目操作符：

-：负值

+：正值

&：取地址

*：间接访问操作符（解引用操作符）

sizeof：操作数的类型长度（以字节为单位）

~：对一个数的二进制按位取反

--：前置、后置-- || ++：前置、后置++

（类型）：强制类型转换

——————————————————————

介绍：

1、~：按（二进制）位取反

eg：00110101

~： 11001010

//原码、反码、补码（原码 按位取反得 反码，反码加一得补码）

正数——原码、反码、补码 都相同

最高位是符号位

负数在内存中存储的时候，存储的是二进制的补码；

所以需要把补码 转换为 反码，再转换为 原码

#include <stdio.h> int main() { int a=0;//4个字节bub，最高位是符号位(最高位为1为负，为0为正） //00000000 00000000 00000000 00000000 //11111111 11111111 11111111 11111111 //原码、反码、补码（原码按位取反得 反码，反码加一得补码） //负数在内存中存储的时候，存储的是二进制的补码 ？？（负数对应补码？） 把补码 转换为 反码，再转换为 原码 补码：//11111111 11111111 11111111 11111111 反码：//11111111 11111111 11111111 11111110 原码：//10000000 00000000 00000000 00000001——得到-1 printf("%d\n",b);//打印的是数的原码

//11111111111111111111111111111111 加一得到下面一行结果 //10000000000000000000000000000000 减一得上面一行结果 整型是32位，规定最左边的32位是体现正负的，0为正 1为负

2、++/--：前置、后置++/--（--与++同理）

前置++(eg：++a），先++ 再使用/赋值

后置++(eg：a++），先使用/赋值 再++

#include <stdio.h> #include <string.h> int main() { int a=10; int b=a++;//后置++ 得到a：11，b：10 int b=++a;//前置++ 得到a：11，b：11 printf("a=%d b=%d\n",a,b); return 0; }

3、（类型）：强制类型转换

类型指的是数据类型（eg：char、short、int、long、long long、float、double）

eg：

#include <stdio.h> #include <string.h> int main() { int a=（int）3.14;//（int）指把小数3.14强制转化为整型 double——>int return 0; }

---

关系操作符

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

逻辑操作符

&& 逻辑与 （全真才为真）

|| 逻辑或 （一真就为真，全假才为假）

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

————————————

0为正，1为负

0为假，非0为真

————————————

条件操作符-某种程度可以替换if语句

exp1 ? exp2 : exp3 （eg:a>b？a：b）

#include <stdio.h> #include <string.h> int main() { int a=10; int b=8; int max=(a>b?a:b);//判断a是否大于b，后输出两数的最大值，可以替换if语句 printf("%d\n",max); return 0; }

逗号表达式

exp1,exp2,exp3,...expN

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

[] () . ->

#include <stdio.h> #include <string.h> int main() { int arr[10]={0}; arr[4];//[]:下标引用操作符 return 0; }

int Add(int x,int y) { int z=0; z=x+y; return 0; } int main() { int a=1; int bF=4; int sum=0； sum=Add(a,b);//():函数调用操作符

二、常见关键字

变量不能与关键字冲突

auto break（停止循环） case char const（常量，常变量） continue（继续，使用于循环语句） default（默认） do（do..while循环） double else（if...else） enum（枚举）extern（引入外部符号） float for goto（语句） if int long register（寄存器） return short signed sizeof static（静态） struct（结构体关键字） switch（语句） typedef（类型定义-类型重定义） union（联合体/共用体） unsigned void volatile while

//auto-自动 auto int a=10;//局部变量-a是自动创建也是自动销毁的， 所以也称为：自动变量（局部变量前都有auto，所以就都省略了） 局部变量都是自动变量

计算机存储数据：

寄存器（相对访问速度最快）register

高速缓存

内存

硬盘

int main() { register int a=10;//建议把a定义为寄存器变量 return 0； }

signed：有符号的

int a=10; a=-2; //int 定义的变量是有符号的，为signed int;unsigned是无符号的，所有数都会被 认为是正数 unsigned int num=-1;

typedef：类型重定义

int main（） { typedef unsigned int u_int;//给unsigned int起了一个别名为u_int unsiged int num=20; u_int num2=20; return 0; }

static：

修饰局部变量，使局部变量的生命周期延长

修饰全局变量，改变了变量的作用于，让静态的全局变量只能在自己所在的源文件内部使用，出了源文件就无法使用

修饰函数，改变了函数的链接属性；

函数一般是有外部链接属性的，使用了static后就变成了内部链接属性

1、修饰局部变量

#include <stdio.h> #include <string.h> void test() { static int a=1;//当没有static时输出为五个2，由于a是局部变量， a++是就会给a加一 //当加上static输出为2、3、4、5、6 a++; printf("a=%d\n",a); } int main() //运行函数都是先从main函数开始 { int i=0; while(i<5) { test(); i++; } return 0; }

快捷键：Fn+F10调试 +调试——监视窗口

2、修饰全局变量

写两个源文件，一个用于供另一调用

#include <stdio.h> int main() { //extern:声明外部符号 extern int g_val; printf("g_val=%d\n",g_val); return 0; }

static int g_val=2020;//当在前面加入static就无法调用g_val

3、修饰函数

创建两个源文件，一个定义函数，一个引用

static int Add(int x,int y) //在前面加入了static， 也会使另一个源文件无法调用该函数 { int z=x+y; return z; }

//声明外部函数 extern int Add(int,int); int main() { int a=10; int b=20; int sum=Add(a,b); printf("sum=%d\n",sum); return 0; }

#define ：定义标识符常量，定义宏——带参数

#include <stdio.h> #define MAX 100 int main() { int a=MAX;//输出a为100 return 0; }

#define MAX(X,Y) (X>Y?X:Y) //求最大值

#include <stdio.h> int Max(int x,int y) { if(x>y) return x; else return y; } //宏的定义 #define MAX(X,Y) (X>Y?X:Y) int main() { int a=20; int b=10; //函数的实现 int max=Max(a,b); printf("max=%d\n",max); //宏的方式 max=MAX(a,b);//相当于 max=(a>b?a:b) printf("max=%d\n",max); return 0; }

三、指针

每个内存单元的大小是1个字节

为了有效的访问到内存的每个单元，给内存单元进行了编号，这些编号称为该内存单元的地址

地址对应空间，编号从0开始，编号对应地址

如何产生地址？

答：32位电脑——对应有32根地址线/数据线，电分为正电1 负电0

以字节为单位划分

#include <stdio.h> int main() { int a=10; //分配4个字节 int* p=&a;//取地址 //有一种变量是用来存放地址的变量——称为 指针变量 printf("%p\n",&a); printf("%p\n",p); *p=20;//*：解引用操作符，把之前定义的a的地址中的数据 更改为20 printf("a=%d\n",a);//输出a=20 return 0; }

#include <stdio.h> int main() { char ch='w'; char* pc=&ch; *pc='a'; printf("%c\n",ch);//输出为 return 0; }

结论：指针大小在32位平台是（32比特/8=4）4个字节，64位平台是8个字节

#include <stdio.h> int main() { char ch='w'; char* pc=&ch; printf("%ld\n",sizeof(pc));//计算指针大小 return 0; }