深入理解符号

1.注释

注释应当准确、易懂,防止有二义性。错误的注释不但无益反而有害。

当代码比较长,特别是有多重嵌套时,应当在一些段落的结束处加注释,便于阅读

数值的单位一定要注释。

对一系列的数字编号给出注释,尤其在编写底层驱动程序的时候(比如管脚 编号)

#include 
#include 
int main()
{
int /* */ i; //正确
char *s = "abcdefgh //hijklmn"; //正确
//Is it a\
valid comment? //正确
in/* */t j; //报错
system("pause");
return 0;
}

//C风格注释无法嵌套

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

2.接续符和转义符

转义的本质含义是:字面转特殊,或者特殊转字面

#include 
#include 
int main()
{
int a = 1;
int b = 2;
int c = 3;
//试试在\之后带上空格,行不行?
//试试在\之前带上空格,行不行?
//建议:不要带

if (a == 1 &&\
b == 2 &&\
c == 3){
printf("hello world!\n");
}
#include 
#include 
int main()
{
//printf("\""); //特殊转字面
printf("h\tello b\nit!\n"); //字面转特殊
system("pause");
return 0;
}
/r回到首行第一个位置
int main()
{
int i = 10;
while (i >= 0){
Sleep(1000);
printf("%2d\r", i--);
}
printf("\n倒计时结束!\n");
system("pause");
return 0;

3.单引号和双引号

//单引号是字符,双引号是字符

//C99标准的规定,'a'叫做整型字符常量(integer character constant),被看成是int型

printf("%d\n", sizeof('1'));  //结果为4,不同编译器下结果不同

char c = '1';                          //发生了截断

printf("%d\n", sizeof(c));       //结果为1

int main()
{char a='sdfg';//最多放4个字符
printf("%c",a);//结果为g,
return 0;
}

4.

//先看现象
#include 
#include 
int main()
{
char c = 0;
printf("sizeof(c): %d\n", sizeof(c)); //1
printf("sizeof(c): %d\n", sizeof(~c)); //4
printf("sizeof(c): %d\n", sizeof(c << 1)); //4
printf("sizeof(c): %d\n", sizeof(c >> 1)); //4
system("pause");
return 0;
}



//是算术右移,还是逻辑右移?最高位补0,为何?
unsigned int d = -1;
printf("%d\n", d >> 1);
printf("%d\n", d >> 2);
printf("%d\n", d >> 3);
system("pause");


结论:
左移,无脑补0
右移,先判定是算术右移还是逻辑右移,判定依据:看自身类型,和变量的内容无关。

无论任何位运算符,目标都是要计算机进行计算的,而计算机中只有CPU具有运算能力(先这样简单理解),但计算的数据, 都在内存中。故,计算之前(无论任何运算),都必须将数据从内存拿到CPU中,拿到CPU哪里呢?毫无疑问,在CPU 寄存器 中。 而寄存器本身,随着计算机位数的不同,寄存器的位数也不同。一般,在32位下,寄存器的位数是32位。 可是,你的char类型数据,只有8比特位。读到寄存器中,只能填补低8位,那么高24位呢? 就需要进行“整形提升”。

<<(左移): 最高位丢弃,最低位补零

>(右移): 1. 无符号数:最低位丢弃,最高位补零[逻辑右移]

                 2. 有符号数:最低位丢弃,最高位补符号位[算术右移]

丢弃的理解:基本理解链: > 都是计算,都要在CPU中进行,可是参与移动的变量,是在内存中的。 所以需要先把数据移动到CPU内寄存器中,在进行移动。 那么,在实际移动的过程中,是在寄存器中进行的,即大小固定的单位内。那么,左移右移一定会有位置跑到"外边"的情况

a << 1; //没有影响a本身的值,未对a进行赋值

逻辑运算符

&&:级联两个(多个)逻辑表达式,必须同时为真,结果才为真 ,与&(按位与)是不同的概念

||:级联两个(多个)逻辑表达式,必须至少一个为真,结果才为真 ,与|(按位或)是不同的概念

位运算

#define SETBIT(x, n) ((x) |= (1<<(n-1))) //指定比特位置为1
void ShowBits(int x)
{
int num = sizeof(x)* 8 - 1;
while (num >= 0){
if (x & (1<
#include 
#define CLRBIT(x, n) ((x) &= (~(1<<(n-1)))) //将指定比特位置零
void ShowBits(int x)
{
int num = sizeof(x)* 8 - 1;
while (num >= 0){
if (x & (1<

printf("%d\n", 0x01 << 2 + 3);//+的优先级更高

#include 
#include 
#define SETBIT(x, n) ((x) |= (1<<(n-1))) //指定比特位置为1
void ShowBits(int x)
{
int num = sizeof(x)* 8 - 1;
while (num >= 0){
if (x & (1<
#include 
#define CLRBIT(x, n) ((x) &= (~(1<<(n-1)))) //将指定比特位置零
void ShowBits(int x)
{
int num = sizeof(x)* 8 - 1;
while (num >= 0){
if (x & (1<

5.符号

1.关于取整

深入理解符号_第1张图片

#include 
#include 
int main()
{
//本质是向0取整
int i = -2.9;
int j = 2.9;
printf("%d\n", i); //结果是:-2
printf("%d\n", j); //结果是:2
system("pause");
return 0;
}

floor函数:本质是向负无穷大取整

ceil函数:本质是向正无穷大取整

round:本质是四舍五入

结论:浮点数(整数/整数),是有很多的取整方式的。

2.取模

取模概念: 如果a和d是两个自然数,d非零,可以证明存在两个唯一的整数 q 和 r,满足 a = q*d + r 且0 ≤ r < d。其中,q 被称为商,r 被称为余数。

#include 
#include 
int main()
{
int a = -10;
int d = 3;
//printf("%d\n", a/d); //C语言中是-3,很好理解
printf("%d\n", a%d);   //c语言中是-1
system("pause");
return 0;
}


[whb@VM-0-3-centos code]$ gcc test.c
[whb@VM-0-3-centos code]$ ./a.out
-1
C:\Users\whb>python --version
Python 3.7.3
C:\Users\whb>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print(-10%3)
2
>>>

在不同语言,同一个计算表达式,负数“取模”结果是不同的。我们可以称之为分别叫做正余数 和 负余数。

结论:具体余数r的大小,本质是取决于商q的。 而商,又取决谁呢?取决于除法计算的时候,取整规则。

本质 1 取整:

取余:尽可能让商,进行向0取整。

取模:尽可能让商,向-∞方向取整。

故: C中%,本质其实是取余。 Python中%,本质其实是取模

对任何一个大于0的数,对其进行0向取整和-∞取整,取整方向是一致的。故取模等价于取余 对任何一个小于0的数,对其进行0向取整和-∞取整,取整方向是相反的。故取模不等价于取余 同符号数据相除,得到的商,一定是正数(正数vs正整数),即大于0! 故,在对其商进行取整的时候,取模等价于取余。 本质 2 符号: 参与取余的两个数据,如果同符号,取模等价于取余

如果参与运算的数据,不同符号呢?

int main()
{
printf("%d\n", -10 / 3); //结果:-3
printf("%d\n\n", -10 % 3); //结果:-1 为什么? -10=(-3)*3+(-1)
printf("%d\n", 10 / -3); //结果:-3
printf("%d\n\n", 10 % -3); //结果:1 为什么?10=(-3)*(-3)+1
system("pause");
return 0;
}


>>> print(-10//3)
-4
>>> print(10//-3)
-4
>>> print(-10%3)
2
>>> print(10%-3)
-2

结论:要看取整规则,如果参与取余的两个数据符号不同,在C语言中(或者其他采用向0取整的语言如:C++,Java),余数符号,与被除数 相同。

你可能感兴趣的:(C语言学习,蓝桥杯,职场和发展)