c语言符号深度理解和再认识

文章目录 二、条件编译二、斜杠符号（续航符） 三、单引号和双引号 四、为什么计算机需要ASCII 五、逻辑运算符 六、位运算符号 （六）、整型提升问题（七）、左移和右移 2.深入理解 七、++和--操作符 八、取模/取余运算问题 （二）、取模问题 九、运算符优先级问题

一、注释符号

初步了解一下；/* */这个是c语言风格，//是c++风格。

（一）、注释的本质

首先run代码引入主题：

int main()
{int /*   */ i;//okchar* s = "abcdefgh     //hijklmn";//ok//Is it a\valid comment? //okint /* */t j;//errreturn 0;
}

我们发现int /* */t j;是错误的。用Linux看预处理：

那么就是编译出错了。

结论：注释被替换，本质是替换成空格。

有了这个总结，下面我们再来看一个例子：

这样就足以看出我们的注释是替换成了空格。

（二）、c语言注释风格嵌套问题

#include 
int main()
{/*printf("hello world!");printf("hello world!");*/ //不报错printf("hello world!");printf("hello world!");*/   //报错
}

说明/* 总是与离它最近的 */ 匹配。

（三）、/和*的连用问题

#include 
int main()
{int x = 10;int y = 0;int z = 5;int* p = &z;y = x/*p;  //err 具有二义性return 0;
}

这里的x/*p，本以为是对x和 *p除法运算，实际上编译器把/ *当作了注释。最好对 *p加上()，这样就可以解决问题了。

（四）、注释的基本要求 注释应该准确、易懂，防止有二义性。注释是对代码的“提示”，并不是文档。对于全局数据（全局变量、常量定义）都必须加上注释。注释的位置应与被描述代码相邻，必须在上方。注释的缩进要与代码的缩进一致。代码注释段时应注重why而不是how.数值的单位一定要注释。对于函数的入口/出口数据、条件语句、分支语句给注释。在复杂的函数中，在分支、循环语句结束之后需要给注释。

例如：

#include 
int main()
{while(1){if(){}else if{}else{}//end of else(对其进行注释)//........//非常多的判断代码}//end of while(对其进行注释)return 0;
}

对变量的范围进行注释，尤其是数。

具体就是这么多的推荐，主要是了解，后期可以做项目了，自然就会了。

二、条件编译

通过两个图可以直观了解条件编译是什么？

两个图进行对比，很容易知道条件编译的用途。

其实，在我们手机中，我们手机对应的设置中有个语言选项，有很多语言选项，在设置的时候，其原理就是条件编译实现的，代码并没有变化，而是类似于条件编译这种思维完成的。

二、斜杠符号（续航符） （一）、介绍

#include 
int main()
{int a = 1;int b = 2;int c = 3;if(1 == a &&\2 == b &&\3 == c){printf("hello human");}return 0;
}

那么我们可不可以在\之前带空格？

这个是可以的。

可不可以在\之后带空格？

这个是不行的，在续航符之后最好任何符号都不要带上。

（二）、续航符和换行符是有区别的

续航符号顾名思义就是对这一行后面补充，而换行符则是换行。

（三）、转义

转义有两种转法：

字面转特殊特殊转字面

#include 
int main()
{printf("\"");// "转义就是特殊转字面printf("hello \n human");// \n就是字面转特殊return 0;
}

（四）、有趣的换行：\n和回车：\r

首先理解回车和换行两个概念：

回车和换行并不是一回事，回车就是光标回到当前行的开始，换行就是光标换到下一行。

了解了这，我们就知道我们按下键盘enter键的时候其实是回车换行或者说换行回车。

1.旋转符号例子

#include 
int main()
{int i = 0;const char *c = "|/-\\";while (1){i %= 4; printf("[%c]\r", c[i]);//\r是回车i++;Sleep(200);}return 0;
}

2.倒计时例子

#include 
int main()
{int i = 10;for (; i >= 0; i--){printf("[%2d]\r", i);Sleep(500);}return 0;
}

三、单引号和双引号 （一）、介绍

单引号是字符，双引号是字符串。

"abcd";//ok
"a";//ok
"";//ok
'abcd';//ok
'a';//ok
'';//err 报错原因是单引号中必须要有至少一个字符

上面我们对’abcd’这个语法看上去肯定很陌生，不应该单引号中只能有一个字符吗，为什么有四个字符并没有报错呢，还有一个有意思的，看代码：

#include 
int main()
{char c = 'a';//okchar a = 'ab';//okchar v = 'abc';//okchar x = 'abcd';//okchar y = 'abcde';//errreturn 0;
}

超出了四个字符就会报错，提示常量中字符太多。

下面我们用关键字来理解单引号和双引号。

第一个中是1这个整型；第二个是字符串（含有\0）；第三个按常理来说应该是字符1，打印出四个空间的大小，不可思议；第四个是字符打印出一个空间，没问题。

原因在于，c99的标准规定，'a’叫做整型字符常量，别看成是int类型。

这样们再来看第三个就很简单了，来看第四个，©为什么是1个空间，原因就是本来是int类型的，但是c是char类型，当int类型转化为char类型时，存储会发生截断。所以是1个空间的大小。

（二）、补充

#include 
int main()
{char c = 'abcd';printf("%d\n",c);return 0;
}

输出结果是d，这里’a’是int类型，为什么输出d？就和大小端有关系，暂且不做研究。

四、为什么计算机需要ASCII （一）、初步认识

计算机中只认识二进制，为了解决人的问题，人不擅长二进制，只认识语言文字，所以在数据传在显示器上也不可能是二进制，对应的是我们认识的文字，所以每个二进制对应的就有大众认识的文字，这就是映射关系，ASCII码表对应的就是映射关系。（映射是由显卡完成的）

（二）、ASCII表

注意：A-a=32,空格十进制数对应的是32。

五、逻辑运算符

前提非零为真，零为假。

（一）、 逻辑与符号 （&&）

&逻辑与就是两个或者多个表达式必须同时为真的时候，结果才为真。

用一个实例说明：

#include 
int main()
{int i = 0;int j = 0;if ((++i > 0) && (++j > 0)){printf("yes!\n");}printf("%d,%d", i, j);return 0;
}//输出结果是yes! 1,1

（二）、逻辑或符号 （||）

逻辑或就是两个或多个表达式，必须至少一个为真，结果才为真。

int main()
{int i = 0;int j = 0;if ((++i > 0) || (++j > 0)){printf("yes!\n");}printf("%d,%d", i, j);return 0;
}//输出结果是yes! 1,0

这段代码，我们发现表达式中只执行了前面的（++i>0）并没有执行后面是（++j>0），这种情况我们叫短路。

（三）、短路问题

#include 
int show()
{printf("yes!\n");return 1;
}
int main()
{int flag = 0;scanf("%d", &flag); flag || show();
}输入0后打印出yes!

短路问题依据就是表达式从左依次执行。

六、位运算符号 （一）、基本了解

按位与（&），按位或（|）、按位异或（^）、按位取反(~)。都是二进制进行运算的。

int main()
{printf("%d\n", 2 | 3);printf("%d\n", 2 & 3);printf("%d\n", 2 ^ 3);printf("%d\n", ~0);return 0;
}//输出结果是3 2 1 -1.

说明：

2|3就是2和3的按位或，2（10）|3（11） = 3（11），二进制中两个对应的值都为0，则为0，否则为1。

2&3就是2和3的按位与，2（10）|3（11） = 2（10），二进制中两个对应的值都为1，则为1，否则为0。

2^3就是2和3的按位异或，2（10） ^3（11） = 2（01），二进制中两个对应的值不相同时，则为1，否则为0。

~0就是按位取反，0（0 0 0000 0000），~0（1 1 1111 1111（补码）=1 0 0000 0001（原码） =-1 ）

（二）、逻辑运算符和按位运算符区别

逻辑运算符对应的逻辑表达式，需要的是真假。而按位运算符是逐个比特位进行计算

（三）、按位异或（^）

任何数和0的按位异或都是这个数本身。

两个相同的数的异或是0。

按位异或支持交换律和结合律。

（四）、实例：交换两个数 第一种方法；创建临时变量

#include 
int main()
{int temp = 0;int a = 10;int b = 20;temp = a;a = b;b = temp;printf("%d,%d\n", a, b);return 0;
}

第二种方法：加法运算

#include 
int main()
{int a = 10;int b = 20;a = a + b;b = a - b;a = a - b;printf("%d,%d", a, b);return 0;
}

注意：加饭运算中二进制有进位现象，如果两个足够大的数相加，那么返回时就会出现溢出问题。

3.第三种方法：按位异或方法

#include 
int main()
{int a = 10;int b = 20;a = a ^ b;b = a ^ b;a = a ^ b;printf("%d,%d\n", a, b);return 0;
}

注意：异或运算只是对比特位进行比较判断，并不会出现二进制进位溢出问题。

（五）、建议

位操作需要用宏定义好后再使用。

实例 1.实现一个宏，对任意一个比特位设置为1

#include 
#define SetBit(x,n)  (x |= (1<<(n-1)))//1<
extern void ShowBit(int x);
//函数
void ShowBit(int x)
{int num = sizeof(x) * 8-1;//控制循环次数while (num>=0){if (x & 1<<num)//先从最高位检验{printf("1");}else{printf("0");}num--;}printf("\n");
}
//主体
int main()
{int x = 0;//设置指定比特位为1，这里使用按位或//x表示那个数据设置比特位，n表示设置第几个比特位（从右往左）SetBit(x, 5);//SetBit(x,6);//SetBit(x,1);//等等....//显示32位比特位ShowBit(x);return 0;
}//输出结果是00000000000000000000000000010000，移动五位，第五位变为1

也可以对多个比特位设置，这里有宏定义，可以直接多次设置宏。

2.实现一个宏，对任意一个比特位设置为0

#include 
#define ClrBit(x,n) (x &= ~(1<<(n-1)))
extern void ShowBit(int x);//ShowBit函数输出比特位
void ShowBit(int x)
{int num = sizeof(x) * 8-1;//控制循环次数while (num>=0){if (x & 1<<num)//先从最高位检验{printf("1");}else{printf("0");}num--;}printf("\n");
}//主体
int main()
{int x = 0xFFFFFFFF;//设置比特位为0ClrBit(x, 2);ClrBit(x, 3);ClrBit(x, 4);ClrBit(x, 5);//显示比特位ShowBit(x);return 0;
}//输出结果是11111111111111111111111111100001

（六）、整型提升问题

先run代码：

#include 
int main()
{char c = 0;printf("%d\n", sizeof(c));printf("%d\n", sizeof(~c));printf("%d\n", sizeof(c<<1));printf("%d\n", sizeof(c>>1));return 0;
}//输出结果是1 4 4 4 

这里发生了整型提升，这里整形提升就不细讲了，后期我们再深入讲解整型提升。

这里我们只需要知道计算机计算是在CPU中的寄存器进行的，一般情况下，在32位下，寄存器的位数也是32位，char类型只有八个比特位，只能填补低8位，那么高24位呢？就需要进行整型提升。

（七）、左移和右移 1.基本了解

左移：最高位丢弃，最低为补零

右移：1. 无符号数：最低位丢弃，最高位补零（逻辑右移） 2.有符号数：最低为丢弃，最高位补符号位（算术右移）

//左移
#include 
void ShowBit(int x)
{int num = sizeof(x) * 8 - 1;//控制循环次数while (num >= 0){if (x & 1 << num)//先从最高位检验{printf("1");}else{printf("0");}num--;}printf("\n");
}
int main()
{unsigned int x = 0xFFFFFFFF;x <<= 1;ShowBit(x);return 0;
}//输出结果：11111111111111111111111111111110，有符号数也是此结果，左移没有符号位差别

//右移
#include 
void ShowBit(int x)
{int num = sizeof(x) * 8 - 1;//控制循环次数while (num >= 0){if (x & 1 << num)//先从最高位检验{printf("1");}else{printf("0");}num--;}printf("\n");
}
int main()
{signed int x = 0xFFFFFFFE;//1111 1111 1111 1111 1111 1111 1111 1110(原本的x）x >>= 1;ShowBit(x);return 0;
}//输出结果：11111111111111111111111111111111

丢弃问题

左移和右移都是在CPU中进行，参与移动的变量是在内存中的，所以需要把数据移动到CPU寄存器中，在进行移动。在大小固定的单元内，一定会有位置到“外边”的情况。（外边的理解就是超出了寄存器储存单元大小）

2.深入理解

//左移
#include 
int main()
{unsigned int a = 1;printf("%u\n", a << 1);printf("%u\n", a << 2);printf("%u\n", a << 3);return 0;
}//输出结果：2 4 8

//右移
#include 
int main()
{unsigned int b = 100;printf("%u\n", b >> 1);printf("%u\n", b >> 2);printf("%u\n", b >> 3);return 0;
}//输出结果：50 25 12

//算术右移
#include 
int main()
{int c = -1;//1111 1111 1111 1111 1111 1111 1111 1111(补码)printf("%d\n", c >> 1);printf("%d\n", c >> 2);printf("%d\n", c >> 3);return 0;
}//输出结果：-1 -1 -1 

//算术右移
#include 
int main()
{unsigned int d = -1;printf("%d\n", d >> 1);printf("%d\n", d >> 2);printf("%d\n", d >> 3);return 0;
}//不会报错，最高位补0

七、++和–操作符 （一）、初步了解

让代码run起来！

//前置++（先对a自增再使用）
#include 
int main()
{int a = 10;int b = ++a;printf("%d,%d\n", a, b);return 0;
}//输出结果：11 11 

#include 
//后置++（先使用再对a自增）
int main()
{int a = 10;int b = a++;printf("%d,%d\n", a, b);return 0;
}//输出结果：11 10

（二）、深入理解后置++

还是用代码看现象

#include 
int main()
{int a = 8;int b = a++;return 0;
}

来看这段代码的反汇编：

这样就能很好的理解为什么是先使用再自增了。

#include 
int main(0
{int a = 8;a++;//并没有使用return 0;
}

再来看这段代码的反汇编：

（三）、复杂表达式

#include 
int main()
{int i =1;int j = (++i)+(++i)+(++i);printf("%d\n",j);return 0;
}

这段代码在 2022中输出结果是12，在gcc中输出结果是10。不同的编译器有不同的计算规则。

贪心算法（表达式匹配问题）

编译器依据符号自动匹配表达式。

在 2022中，我们每输完一条语句时，当我们打上分号，按下回车换行（enter）键时，编译器会自动匹配表达式。

八、取模/取余运算问题 （一）、取整问题

通过代码看现象。run起来！

1.向0取整

#include 
int main()
{int i = -2.9;int j = 2.9;printf("%d\n", i);//输出结果是-2printf("%d\n", j);//输出结果是2return 0;
}

看图：

c语言中默认是向0取整。

c语言中有一个trunc取整函数：

通过代码了解：

可见trunc函数是一个向0取整函数。

2.向负无穷取整

floor函数就是一个向负无穷取整的函数。

初步了解：

通过代码进一步了解：

也可以这么理解：

3.向正无穷取整

ceil函数就是一个向正无穷取整函数。

先对ceil函数进行初步认识：

通过代码来看：

可以这么理解ceil函数：

4.四舍五入

round函数就是一个四舍五入函数。

初步了解：

通过代码来理解：

5.综合

源代码：

#include 
#include 
int main()
{const char* format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";printf("value\tround\tfloor\tceil\ttrunc\n");printf("-----\t-----\t-----\t----\t-----\n");printf(format, 2.3, round(2.3), floor(2.3), ceil(2.3), trunc(2.3));printf(format, 3.8, round(3.8), floor(3.8), ceil(3.8), trunc(3.8));printf(format, 5.5, round(5.5), floor(5.5), ceil(5.5), trunc(5.5));printf(format, -2.3, round(-2.3), floor(-2.3), ceil(-2.3), trunc(-2.3));printf(format, -3.8, round(-3.8), floor(-3.8), ceil(-3.8), trunc(-3.8));printf(format, -5.5, round(-5.5), floor(-5.5), ceil(-5.5), trunc(-5.5));return 0;
}

（二）、取模问题 1.取模概念

如果a和d两个自然数，d非零，可以证明存在两个唯一的整数q和r，满足a=q*d+r且0