「C」关键字、标识符、注释、内存分析、数据、常量、变量

 

一、关键字

　　C语言提供的有特殊含义的符号，共32个。

　　一般在Xcode中关键字全部显示紫褐色，关键字全部都为小写。如int、return等。

二、标识符

　　标识符是程序员在程序中自定义的一些符号和名称。关键字是C语言默认提供的，标识符是程序员自定义的。如函数的名称等，用来区分各种事务。

　　命名规则：

•  只能由26个小写字母，0-9的数字以及下划线_组成。
•  严格区分大小写。
•  不能以数字开头。
•  不可以使用关键字作为标识符。

　　命名规范：

　　（1）尽量起有意义的名称。

　　（2）多个单词可以使用驼峰标识（第二个单词开始的首字母大写）或者使用下划线连接。

三、注释

　　（1）注释用以解释代码的含义，提高程序的可读性，注释掉的代码不会参与编译,在开发工具中注释一般是豆沙绿色。

　　（2）注释的符号

　　　　单行注释   //

　　　　多行注释   /*     */

　　（3）注释的作用：检查代码；排错。

　　（4）注释的嵌套

　　　　①. 单行注释可以嵌套单行注释，多行注释

　　　　②. 多行注释可以嵌套单行注释

　　　　③. 多行注释不可以嵌套多行注释

　　（5）注意：printf("//abc");这里的//在双引号内是字符串的一部分而非注释。

四、内存分析

（一）进制

　　概念：进制是一种计数方式，是数值的表现形式

　　4种主要的进制：

　　　　①. 十进制：0 ~ 9 

　　　　②. 二进制：0和1

　　　　③. 八进制：0 ~ 7

　　　　④. 十六进制：0 ~ 9 + a b c d e f

　　C语言在默认的情况下为十进制。

　　int num=1010; // 十进制

　　int num=0b1100; // 二进制，以0b或者是0B开头

　　int num=014; // 八进制，以0开头

　　int num=0x4; // 十六进制，以0x开头

　　占位符：

　　　　%d和%i ：一十进制整数的形式输出一个值

　　　　%o ：以不带符号的八进制输出

　　　　%x ：以不带符号的十六进制输出

　　　　%u ：以不带符号的十进制输出

　　　　%c : 输出字符

　　　　%p : 输出地址

　　　　%f : 输出小数

　　　　%s : 输出字符串

　　n位二进制的取值范围：

　　　　2位……0 ~ 3   0 ~ 2的2次方-1

　　　　3位……0 ~ 7   0 ~ 2的3次方-1

　　　　n位……0 ~ 2的n次方-1

　　判断以下数据是否正确：

　　0x7h4 0986 .089 0b325 10e8.7 96f -.003 

 

　　类型的取值：

　　在64位编译器下，int类型 占4个字节 共4x8=32bit char类型 占1个字节 共1x8=8bit ，在内存中以字节为单位进行存储。

（二）类型说明符

　　short== short int %d 2

　　long ==long int %ld 8

　　long long ==long long int  %lld 8

　　signed ==signed int==int %d 4（有符号）

　　unsigned ==unsigned int %u 4（无符号）

　　signed和unsigned的区别:

　　　　①.最高位要不要拿来作为符号位，显然后者的取值范围更大。

　　　　②.这两个说明符可和long等说明符组合使用，但不会改变字节数。

　　　　③.unsigned代表int类型的最高位，不必用来作为符号位。

（三）位运算

　　（1）按位与 &

　　　　功能：只有对应的两个二进制位均为1时，结果才为1，否则为0。

　　　　示例：9 & 5 的结果为1 

　　　　说明：如果位与上1则保留原值，与上0则为0。

　　　　应用：查询0101 0111 0000的倒数第六位是0还是1，则可以与上数值以判断，得出的结果是什么，那么它的原值就是什么。

　　　　　　0101 0111 0000

　　　　　　0000 0010 0000

　　　　　　0000 0010 0000

　　（2）按位或 |

　　　　功能：只要对应的两个二进制位有一个为1则结果为1，否则为0。

　　　　举例：9 | 5的结果为13

　　（3）按位异或 ^

　　功能：当对应的两个二进制位不相等时，结果为1，否则为0。

　　举例：9^5的结果为：12

　　规律：

　　　　①. 相同整数异或的结果为0，如5^5=0

　　　　②. 顺序可以交换。如9^5^9=9^9^5=0^5=5

　　　　③. 任何数值跟0进行异或，结果还是原来的数值。9^0=9

　　　　④. a^b^a==b

　　（4）按位取反 ~

　　　　举例：~ 9的结果为 -10

　　　　0000 0000  0000  0000 0000  0000  0000  1001

　　　　1111 1111 1111  1111  1111  1111 1111 0110

　　（5）左移 <<

　　　　如a<<n

　　　　把整数a的二进制位全部左移n位，高位丢弃，低位补零。左移n位的结果其实是乘以2的n次方，由于符号位会被丢弃，所以结果可能会改变正负性。

　　　　举例：9 << 1的结果为18

　　　　0000 1001

　　　　0010 0010

　　　　应用：如果某个数需要乘以2的n次方，那么使用位运算效率更高。

　　（6）右移 >>

　　　　如a>>n

　　　　把整数a的二进制位全部右移n位，低位丢弃，符号位不变，一般情况下高位用符号位补齐。右移的结果实际上是除以2的n次方。

　　（7）练习

　　　　①.使用位运算交换两个变量的值　

 

 1 #include<stdio.h>
 2 
 3 int main()
 4 
 5 {
 6 
 7     int a=10;
 8 
 9     int b=11;
10 
11     printf("a=%d,b=%d\n",a,b);
12 
13     a=a^b;
14 
15     b=a^b;
16 
17     a=a^b;
18 
19     printf("a=%d,b=%d\n",a,b);
20 
21     return 0;
22 
23 }

 

　　　　②.使用位&运算符判断变量的奇偶性

 

 1 #include<stdio.h>
 2 
 3 int main()
 4 
 5 {
 6 
 7    printf("请输入需要判断的整数:\n");
 8 
 9     int n;
10 
11     scanf("%d",&n);
12 
13 /*
14 
15    if(n%2==0)
16 
17    printf("这个数是偶数\n");
18 
19    else
20 
21    printf("这个数是奇数\n");
22 
23 */
24 
25     if((n&1)==1)
26  
27      printf("这个数是奇数\n");
28 
29     else if((n&1)==0)
30 
31     printf("这个数是偶数\n");
32 
33     return 0;
34 
35 }

 

　　　　③.编写一个函数，输出整数的二进制格式

 

1 #include<stdio.h>
 2 
 3 void putbinary(int number);
 4 
 5 int main()
 6 
 7 {
 8 
 9    printf("这个程序的作用是把你输入的整数以二进制的格式输出\n");
10 
11    printf("请输入一个整数：\n");
12 
13    int n;
14 
15    scanf("%d",&n);
16 
17    putbinary(n);
18 
19    return 0;
20 
21 }
22 
23  
24 
25 void putbinary(int number)
26 
27 {
28 
29      //int count=sizeof(number)*8-1;
30 
31       int count=(sizeof(number)<<3)-1;//注意这里需要注明优先级
32 
33      printf("%d\n",count);
34 
35  
36 
37 　　while(count>=0)
38 
39 　　{
40 
41     　　int value=(number>>count)&1;
42 
43     　　printf("%d",value);
44 
45 　　　　//每四个数字，打印一个空格
46 
47     　　if(count%4==0)
48 
49      　　printf(" ");
50 
51      　　count--;
52 
53 　　}
54 
55  }

 

（四）char类型

　　（1）基础

　　　　char c=‘A’;

　　　　字符在内存中也是也二进制的格式存储的。

　　　　int num=6; // 在内存中以00……0110存储

　　　　char num=‘6’; // 对应的ascii码值是54=32+16+4+2，在内存中为11 0110

　　　　两者之间有着本质的区别，一个是具体的整数值，一个是字符，以ASCII格式存储。

　　（2）使用注意

　　　　单引号只能括住单字节的字符，ASCII中的所有字符都是单字节的。

　　　　char c=’男’； // 错误，因为一个汉字占据3个字节的存储空间

　　　　char c=”A”; // 错误，这是字符串，为‘A’+‘\0’。

　　　　char c=65; // 正确，另一种形式而已

　　　　char类型占据一个字节，所以它的取值范围为-128~127。

　　帮助：输出一个\，使用\\,输出一个单引号使用\’，输出一个双引号，使用\"。

　　练习：编写一个函数，将小写字母转换为大写。

 

 1 #include<stdio.h>
 2 
 3 char upper(char c)
 4 
 5 {
 6 
 7     if(c>='a'&&c<='z')
 8 
 9         return c-('a'-'A');
10 
11     else
12 
13         return c;
14 
15 }
16 
17 int main()
18 
19 {
20 
21     char a=upper('b');
22 
23     printf("%c\n",a);
24 
25     return 0;
26 
27 }  

 

五、数据

　　图片文字等都是数据，在计算机中以0和1存储。

　　（一）分类

　　　　数据分为静态数据和动态数据。

　　　　①. 静态数据：一些永久性的数据，一般存储在硬盘中，一般以文件的形式存储在硬盘上，计算机重启后依然存在。只要不主动删除或者硬盘没坏数据永远都在。

　　　　②. 动态数据：程序运行过程中，动态产生的的临时数据，一般存储在内存中，内存的存储空间一般较小，计算机关闭后这些数据就会被清除。软件或者计算机关闭则这些临时数据会被清除。

　　　　③. 静态数据和动态数据可以转换。

　　　　④. 注意：为什么不把动态数据存放到硬盘？因为内存的访问速度比硬盘快N倍。软件安装在硬盘，运行时加载到内存中。程序员应该更加关心内存数据。

　　（二）数据大小

　　　　①. 所有的数据都是由0和1组成的。

　　　　②. 数据都有大小，静态数据占硬盘空间，动态数据占内存空间。

　　　　③. 数据越大，包含的0和1就越多，

　　　　④. 存储数据的单位是比特位和字节。一个1或者0就是一个比特位，即1bit。

　　　　⑤. 计算机中，以字节为单位存储数据。1字节=8比特位（1Byte=8bit）。

　　　　⑥.  1 KB = 1024 B，1 MB = 1024 KB，1 GB = 1024 MB，1 TB = 1024 GB

　　（三）C语言中的数据类型

　　　　1.基本数据类型

　　　　　　1) 整型 （int   %d）

　　　　　　2) 字符型 （char  %c）

　　　　　　3) 浮点型 %d

　　　　　　　　①. 单精度浮点型（float）

　　　　　　　　②. 双精度浮点型（double）

　　　　2.指针类型 void *

　　　　3.空类型   void

 

　　　　4.构造类型

　　　　　　1) 数组  a[]

　　　　　　2) 结构体 struct

　　　　　　3) 枚举   enum

　　　　　　4) 共用体 union

　　　　注意：C语言中没有布尔类型，一般使用0和1表示。

六、常量

　　（一）定义

　　　　常量，表示一些固定的数据

　　（二）分类　

　　　　①. 整型常量    如6、27、109、256、-10、0、-289

　　　　  ②. 浮点型常量  如5.43、-2.3、0.0、5.43f、-2.3f、0.0f

　　　　③. 字符常量    如'6'、'a'、'F'、'+'、'$'（不能是中文如‘男’）

　　　　④. 字符串常量  如"6"、"男"、"哇哈哈"、"abcd"、"my_car4"

七、变量

　　（一）定义　　　

　　　　如果一个数据的值是不确定的，或者经常需要改变，则用变量来表示。

　　（二）定义变量

　　　　目的：使用变量前必须先进行定义。在内存中分配一块存储空间给变量，方便以后存储数据。如果定义了多个变量，则为多个变量分别分配不同的存储空间。

　　　　格式：变量类型 变量名；

　　　　举例：int a；char c；int num1,num2;

　　　　注意：变量名属于标识符，需要符合标识符的命名规范。

　　　　记住：只要是不确定的数据就应该定义变量来进行保存。在64位编译器下，int类型占4个字节，共4*8=32bit，char类型占1个字节。

　　　　问：为什么定义的变量有很多的类型？

　　　　答：不同类型的变量占用不同大小的存储空间，因为内存极其有限，分配适当的空间来存储它们可以节省空间。

　　（三）变量的使用

　　　　初始化：1.int a;a=10；2.int a=10;

　　　　修改：可以修改变量的值，多次赋值。每次赋值都会覆盖原来的值

　　　　输出：使用占位符输出变量。各种类型的占位符如下：

　　　　　　int   %d或者%i

　　　　　　float /double %f(默认情况下输出6位，可以使用.2f来控制)

　　　　　　long  %ld

　　　　　　long long  %lld

　　　　　　char  %c

　　　　　　字符串 %s

　　　　　　unsigned long  %zd

　　（四）变量的内存分析

　　　　1.字节和地址　

　　　　　　①.内存以“字节为单位”，计算机中通常以十六进制（0x）表示地址

　　　　　　　　

　　　　　　②.不同类型占用的字节不一样，数据越大，所需的字节数越多

　　　　2.变量的存储　　　

　　　　　　①.所占用字节数跟类型有关，也跟编译器环境有关

　　　　　　　　

　　　　　　②.变量实例

　　　　　　　　int b = 10;

　　　　　　　　int a = 20;

　　　　　　　　内存由大到小寻址，优先分配内存地址较大的字节给变量。b的内存地址比a大

　　　　　　　　每个变量都有地址：第一个字节的地址就是变量的地址

　　　　　　③.查看内存地址：%x和%p

　　　　　　　　int a;

　　　　　　　　printf("a的地址是：%p\n", &a);

　　　　　　④.查看整数的二进制形式　

1 void putBinary(int n)
2 {
3     int bits = sizeof(n) * 8;
4     while (bits --> 0) {
5         printf("%d", n >> bits & 1);
6         if (bits % 4 == 0) printf(" ");
7     }
8     printf("\n");　

　　　　3.负数在内存中的存储

　　　　　　①.一个字节的取值范围

　　　　　　②.负数的表示形式

　　　　　　③.原码、反码、补码

　　　　4.取值范围

　　　　

　　（五）变量使用注意

　　　　变量的作用域：从变量定义的那一行开始，直到代码块{}结束。代码块{}可以用来提高性能，即时回收不再使用的变量。

　　　　return：退出函数，清除内存中的数据。

　　　　建议使用矩形方框和excel来分析内存。

　　（六）习题

　　　　练习：交换整型变量a、b的值，用多种方式实现：

　　　　方法一：使用中间变量

 #include<stdio.h>
 //交换两个变量的值

 int main()
 
 {
 
     int a = 10;
 
     int b = 11;
 
     printf("交换前a = %d,b = %d\n",a,b);
 
     //定义一个中间变量来完成两个变量之间的交换
     int temp;
 
     temp = a;
 
     a = b;
 
     b = temp;
 
     printf("交换后a = %d,b = %d\n",a,b);
 
     return 0;
 
 }

　　　　方法二：不使用中间变量

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

　　　　方法三：使用位异或

 #include<stdio.h>
 
 int main()
 
 {
 
     int a = 10;
 
     int b = 11;
 
     printf("交换前a = %d,b = %d\n",a,b);
 
     a = b ^ a;
 
     b = a ^ b;
 
     a = a ^ b;
 
     printf("交换后a = %d,b = %d\n",a,b);
 
     return 0;

 }