c语言总结

1.变量示例

当定义一个变量时，系统就会为这个变量分配一定的存储空间。

1 int main()
2 {
3     char a = 'A'; 
4     
5     int b = 10;
6     
7     return 0;
8 }

1> 在64bit编译器环境下，系统为变量a、b分别分配1个字节、4个字节的存储单元。也就是说：

• 变量b中的10是用4个字节来存储的，4个字节共32位，因此变量b在内存中的存储形式应该是0000 0000 0000 0000 0000 0000 0000 1010。
• 变量a中的'A'是用1个字节来存储的，1个字节共8位，变量a在内存中的存储形式是0100 0001，至于为什么'A'的二进制是这样呢，后面再讨论。

2> 上述变量a、b在内存中的存储情况大致如下表所示：

（注："存储的内容"那一列的一个小格子就代表一个字节，"地址"那一列是指每个字节的地址）

• 从图中可以看出，变量b占用了内存地址从ffc1~ffc4的4个字节，变量a占用了内存地址为ffc5的1个字节。每个字节都有自己的地址，其实变量也有地址。变量存储单元的第一个字节的地址就是该变量的地址。变量a的地址是ffc5，变量b的地址是ffc1。
• 内存寻址是从大到小的，也就是说做什么事都会先从内存地址较大的字节开始，因此系统会优先分配地址值较大的字节给变量。由于是先定义变量a、后定义变量b，因此你会看到变量a的地址ffc5比变量b的地址ffc1大。
• 注意看表格中变量b存储的内容，变量b的二进制形式是：0000 0000 0000 0000 0000 0000 0000 1010。由于内存寻址是从大到小的，所以是从内存地址最大的字节开始存储数据，存放顺序是ffc4 -> ffc3 -> ffc2 -> ffc1，所以把前面的0000 0000都放在ffc2~ffc4中，最后面的八位0000 1010放在ffc1中。

2.printf函数

 这个函数我们已经用过很多遍了，用格式符%s表示需要输出一个字符串

char a[3] = {'m', 'j', '\0'};
printf("%s", a);

输出结果：，最后面那个\0是不可能输出的，它只是个空字符，只是字符串结束的标记。

 

* 说到这里，有人可能会想：这样看来，似乎把最后的\0去掉也没什么影响吧，输出结果应该还是一样的啊，都是"mj"。

我们可以试一下，把最后面的\0去掉，再进行输出：

char a[3] = {'m', 'j'};
printf("%s", a);

输出结果：，跟上面添加了\0的输出结果是一样的。

别高兴地太早了，我只能说你这是侥幸一样的，运气好了一点。

 

* 我们再来看一个例子

1 char a[3] = {'m', 'j', '\0'}; // 添加了结束符\0
2 
3 char b[] = {'i', 's'}; // 假设忘记添加结束符\0
4 
5 printf("字符串a：%s", a); // 输出字符串a
6 
7 printf("\n"); // 换行
8 
9 printf("字符串b：%s", b); // 输出字符串b

看清楚了，第3行的字符数组b后面没有添加结束符\0，因此b不算是个正宗的字符串。

按照你的猜想，字符串b的输出应该就是"is"，但是输出结果为：，可以看出，当我们尝试输出b的时候，把a也输出了。

要搞清楚为什么，首先要看看a和b的内存地址：

printf("a的地址：%x", a);
printf("\n");
printf("b的地址：%x", b);

输出结果：，由这个数据我们可以分析出a和b的内存存储情况如下：

可以看出来，数组b和a的内存地址是连续的。我们再回到输出b的代码：

printf("字符串b：%s", b); // 输出字符串b

%s表示期望输出一个字符串，因此printf函数会从b的首地址开始按顺序输出字符，一直到\0字符为止，因为\0是字符串的结束标记。

所以，如果想要创建一个字符串，记得加上结束符\0，不然后果很严重，会访问到一些垃圾数据。

 

3.puts函数

1 char a[] = "mj";
2 puts(a);
3 
4 puts("lmj");

看第2行代码，puts函数会从a的首地址开始输出字符，一直到\0字符为止。

输出结果：，可以看出puts函数输出一个字符串后会自动换行。

* puts函数一次只能输出一个字符串，printf函数则可以同时输出多个字符串

printf("%s - %s", "mj", "lmj");

 

回到顶部

stdio.h中有2个函数可以用来接收用户输入的字符串，分别是scanf和gets

4.scanf函数

char a[10];
scanf("%s", a);

scanf函数会从a的首地址开始存放用户输入的字符，存放完毕后，系统会自动在尾部加上一个结束标记\0

注意，不要写成scanf("%s", &a)，因为a已经代表了数组的地址，没必要再加上&这个地址运算符。

 

5.gets函数

char a[10];
gets(a);

gets跟scanf一样，会从a的首地址开始存放用户输入的字符，存放完毕后，系统会自动在尾部加上一个结束标记\0。

* gets一次只能读取一个字符串，scanf则可以同时读取多个字符串

* gets可以读入包含空格、tab的字符串，直到遇到回车为止；scanf不能用来读取空格、tab

字符处理函数

下面介绍的两个字符处理函数都是在stdio.h头文件中声明的。

1.字符输出函数putchar

putchar(65); // A

putchar('A'); // A

int a = 65;
putchar(a); // A

上面的3种用法，输出的都是大写字母A。

* putchar一次只能输出一个字符，而printf可以同时输出多个字符

printf("%c %c %c", 'A', 'B', 'a');

 

2.字符输入函数getchar

char c;
c = getchar();

getchar会将用户输入的字符赋值给变量c。

* getchar函数可以读入空格、TAB，直到遇到回车为止。scanf则不能读入空格和TAB。

* getchar一次只能读入一个字符。scanf则可以同时接收多个字符。

* getchar还能读入回车换行符，这时候你要敲2次回车键。第1次敲的回车换行符被getchar读入，第2次敲的回车键代表输入结束。

 

回到顶部

二、字符串处理函数

下面介绍的字符串处理函数都是在string.h头文件中声明的，使用前要包含这个头文件。

1.strlen函数

* 这个函数可以用来测量字符串的字符个数，不包括\0

1 int size = strlen("mj"); // 长度为2
2  
3 char s1[] = "lmj";
4 int size1 = strlen(s1); // 长度为3
5  
6 char s2[] = {'m', 'j', '\0', 'l', 'm', 'j', '\0'};
7 int size2 = strlen(s2); // 长度为2

看一下第7行，strlen函数会从s2的首地址开始计算字符个数，直到遇到空字符\0为止。因为s2的第1个\0之前只有mj这2个字符，所以长度为2。

 

2.strcpy函数

1 char s[10];
2 strcpy(s, "lmj");

strcpy函数会将右边的"lmj"字符串拷贝到字符数组s中。从s的首地址开始，逐个字符拷贝，直到拷贝到\0为止。当然，在s的尾部肯定会保留一个\0。

* 假设右边的字符串中有好几个\0，strcpy函数只会拷贝第1个\0之前的内容，后面的内容不拷贝

1 char s[10];
2 char c[] = {'m', 'j', '\0', 'l', 'm', 'j', '\0'};
3 strcpy(s, c);

最后字符串s中的内容为：mj

 

3.strcat函数

char s1[30] = "LOVE";
strcat(s1, "OC");

strcat函数会将右边的"OC"字符串拼接到s1的尾部，最后s1的内容就变成了"LOVEOC"

strcat函数会从s1的第1个\0字符开始连接字符串，s1的第1个\0字符会被右边的字符串覆盖，连接完毕后在s1的尾部保留一个\0

* 注意下面的情况

1 char s1[30] = {'L', 'm', 'j', '\0', 'L', 'o', 'v', 'e', '\0'};
2 strcat(s1, "OC");
3 printf("%s", s1);

第1行初始化的s1有2个\0，经过第2行的strcat函数后，输出结果：

 

4.strcmp函数

* 这个函数可以用来比较2个字符串的大小

* 调用形式为：strcmp(字符串1, 字符串2)

* 两个字符串从左至右逐个字符比较（按照字符的ASCII码值的大小），直到字符不相同或者遇见'\0'为止。如果全部字符都相同，则返回值为0。如果不相同，则返回两个字符串中第一个不相同的字符ASCII码值的差。即字符串1大于字符串2时函数返回值为正，否则为负。

1 char s1[] = "abc";
2 char s2[] = "abc";
3 char s3[] = "aBc";
4 char s4[] = "ccb";
5 
6 printf("%d, %d, %d", strcmp(s1, s2), strcmp(s1, s3), strcmp(s1, s4));

输出结果：

• s1和s2相同，所以返回0
• s1和s3是第2个字符不相同，b的ASCII码值是98，B的ASCII码值是66，b - B = 32，所以返回32
• s1和s4是第1个字符就不相同，a的ASCII码值是97，c的ASCII码值是99，a - c = -2，所以返回-2

六、关于指针的疑问

刚学完指针，都可能有一大堆的疑惑，这里我列出几个常见的疑惑吧。

1.一个指针变量占用多少个字节的内存空间？占用的空间是否会跟随所指向变量的类型而改变？

在同一种编译器环境下，一个指针变量所占用的内存空间是固定的。比如，在16位编译器环境下，任何一个指针变量都只占用2个字节，并不会随所指向变量的类型而改变。

 

2.既然每个指针变量所占用的内存空间是一样的，而且存储的都是地址，为何指针变量还要分类型？而且只能指向一种类型的变量？比如指向int类型的指针、指向char类型的指针。

其实，我觉得这个问题跟"数组为什么要分类型"是一样的。

* 看下面的代码，利用指针p读取变量c的值

1 int i = 2;
2 char c = 1;
3 
4 // 定义一个指向char类型的指针
5 char *p = &c;
6 
7 // 取出
8 printf("%d", *p);

这个输出结果应该难不倒大家：，是可以成功读取的。

* 如果我改一下第5行的代码，用一个本应该指向int类型变量的指针p，指向char类型的变量c

int *p = &c;

我们再来看一下输出：，c的原值是1，现在取出来却是513，怎么回事呢？这个要根据内存来分析

根据变量的定义顺序，这些变量在内存中大致如下图排布：

其中，指针变量p和int类型变量i各占2个字节，char类型的c占一个字节，p指向c，因此p值就是c的地址

1> 最初的时候，我们用char *p指向变量c。当利用*p来获取变量c的值时，由于指针p知道变量c是char类型的，所以会从ffc3这个地址开始读取1个字节的数据：0000 0001，转为10进制就是1

2> 后来，我们用int *p指向变量c。当利用*p获取变量c的值时，由于指针p认为变量c是int类型的，所以会从ffc3这个地址开始读取2个字节的数据：0000 0010 0000 0001，转为10进制就是513

可见，给指针分类是多么重要的一件事，而且一种指针最好只指向一种类型的变量，那是最安全的。

三、指针处理字符串的注意

现在想将字符串"lmj"的首字符'l'改为'L'，解决方案是多种的

1.第一种方案

1 // 定义一个字符串变量"lmj"
2 char a[] = "lmj";
3 
4 // 将字符串的首字符改为'L'
5 *a = 'L';
6 
7 printf("%s", a);

程序正常运行，输出结果：

 

2.应该有人能马上想到第二种方案

1 char *p2 = "lmj";
2 *p2 = 'L';
3 
4 printf("%s", p2);

看起来似乎是可行的，但这是错误代码，错在第2行。首先看第1行，指针变量p2指向的是一块字符串常量，正因为是常量，所以它内部的字符是不允许修改的。

有人可能搞蒙了，这里的第1行代码char *p2 ="lmj";跟第一种方案中的第2行代码char a[] ="lmj";不是一样的么？这是不一样的。

• char a[] ="lmj";定义的是一个字符串变量！
• char *p2 ="lmj";定义的是一个字符串常量！

指向函数的指针变量主要有两个用途：

• 调用函数

• 将函数作为参数在函数间传递。我这么一说，可能还不是很明白，举个例子。

 1 #include <stdio.h>
 2 
 3 // 减法运算
 4 int minus(int a, int b) {
 5     return a - b;
 6 }
 7 
 8 // 加法运算
 9 int sum(int a, int b) {
10     return a + b;
11 }
12 
13 // 这个counting函数是用来做a和b之间的计算，至于做加法还是减法运算，由函数的第1个参数决定
14 void counting( int (*p)(int, int) , int a, int b) {
15     int result = p(a, b);
16     printf("计算结果为：%d\n", result);
17 }
18 
19 int main()
20 {
21     // 进行加法运算
22     counting(sum, 6, 4);
23     
24     // 进行减法运算
25     counting(minus, 6, 4);
26     
27     return 0;
28 }

如果以后想再增加一种乘法运算，非常简单，根本不用修改counting函数的代码，只需要再增加一个乘法运算的函数

int mul(int a, int b) {
    return a * b;
}

然后counting(mul, 6, 4);就可以进行乘法运算了

extern与函数

如果一个程序中有多个源文件(.c)，编译成功会生成对应的多个目标文件(.obj)，这些目标文件还不能单独运行，因为这些目标文件之间可能会有关联，比如a.obj可能会调用c.obj中定义的一个函数。将这些相关联的目标文件链接在一起后才能生成可执行文件。

先来理解2个概念：

• 外部函数：如果在当前文件中定义的函数允许其他文件访问、调用，就称为外部函数。C语言规定，不允许有同名的外部函数。
• 内部函数：如果在当前文件中定义的函数不允许其他文件访问、调用，只能在内部使用，就称为内部函数。C语言规定不同的源文件可以有同名的内部函数，并且互不干扰。

接下来就演示在一个源文件中调用另外一个源文件定义的函数，比如在main.c中调用one.c中定义的one函数。

1.首先在one.c中定义了一个one函数

如果你想让这个one函数可以被main.c访问，那么one函数就必须是外部函数。完整的定义是要加上extern关键字。

不过这个extern跟auto关键字一样废，完全可以省略，因为默认情况下，所有的函数就是外部函数。我们可以简化一下：

 

2.接下来，我想在main.c的main函数中，调用one.c中的one函数

怎样才能调用one.c中的one函数呢？你可能会产生2个想法：

想法1：直接在main函数中写上one();

这个做法肯定不行，因为main函数根本不知道one函数的存在，怎么调用呢？这个在标准C编译器里面会报错的，但是在Xcode中只是个警告。

想法2：在main.c中包含one.c文件

大家都知道#include的作用纯粹就是内容拷贝，所以又相当于

哎，这么一看好像是对的哦，在main函数前面定义了个one函数，然后在main函数中调用了这个one函数。从语法上看是对的，所以编译是没问题的。但是这个程序不可能运行成功，因为在链接的时候会报错。我们已经在one.c中定义了one函数，现在又在main.c中定义one函数，C语言规定不允许有同名的外部函数，链接的时候链接器会发现在one.obj和main.obj中定义了同一个函数，会直接报错，Xcode中的错误信息是这样的：

duplicate symbol _one是说one这个标识符重复了，linker是指链接器。

上面的2种想法都是不可行的，其实思路是一致的：让main函数知道one函数的存在。正确的做法应该是在main函数前面对one函数进行提前声明(看清楚，是声明，不是定义，定义和声明是两码事)。

3.在main函数前面对one函数进行提前声明

你想要把其他源文件中定义的外部函数拿过来声明，完整的做法，应该使用extern关键字，表示引用别人的"外部函数"

运行程序，从控制台输出可以发现 "one.c中定义的one函数" 已经被 "main.c的main函数" 成功调用了。

也有人可能会马上冒出一个想法：假如除开one.c，还有其他源文件也有定义这个one函数怎么办？那main函数调用的究竟是谁的one函数啊？放心，绝对不会有这种情况，刚才不是说了么，不允许重复定义同一个外部函数，不然链接器会报错的，所以只会有一个外部one函数。

上述就是extern关键字对函数的作用：用来定义和声明一个外部函数。其实extern又跟auto一样废，完全可以省略。于是，我们可以简化成这样：

为了模块化地开发，在正规的项目里面，我们会把one函数的声明写到另一个头文件中，当然，这个头文件的命名最好有意义、规范一点，比如叫one.h。以后，谁想调用这个one函数，包含one.h这个头文件就行了。于是最后的代码结构是这样的：