C 語言編程中的 5 個常見錯誤及對應(yīng)解決方案

導(dǎo)讀：增強(qiáng) C 語言程序的彈性和可靠性的五種方法。　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　 　本文字?jǐn)?shù)：8391，閱讀時長大約：10分鐘
https://linux.cn/article-13894-1.html
作者：Jim Hall
譯者：unigeorge
即使是最好的程序員也無法完全避免錯誤。這些錯誤可能會引入安全漏洞、導(dǎo)致程序崩潰或產(chǎn)生意外操作，具體影響要取決于程序的運(yùn)行邏輯。

C 語言有時名聲不太好，因為它不像近期的編程語言（比如 Rust）那樣具有內(nèi)存安全性。但是通過額外的代碼，一些最常見和嚴(yán)重的 C 語言錯誤是可以避免的。下文講解了可能影響應(yīng)用程序的五個錯誤以及避免它們的方法：

1、未初始化的變量

程序啟動時，系統(tǒng)會為其分配一塊內(nèi)存以供存儲數(shù)據(jù)。這意味著程序啟動時，變量將獲得內(nèi)存中的一個隨機(jī)值。

有些編程環(huán)境會在程序啟動時特意將內(nèi)存“清零”，因此每個變量都得以有初始的零值。程序中的變量都以零值作為初始值，聽上去是很不錯的。但是在 C 編程規(guī)范中，系統(tǒng)并不會初始化變量。

看一下這個使用了若干變量和兩個數(shù)組的示例程序：

1. #include <stdio.h>
2. #include <stdlib.h>
4. int
5. main()
6. {
7. int i, j, k;
8. int numbers[5];
9. int *array;
11. puts("These variables are not initialized:");
13. printf(" i = %d\n", i);
14. printf(" j = %d\n", j);
15. printf(" k = %d\n", k);
17. puts("This array is not initialized:");
19. for (i = 0; i < 5; i ) {
20. printf(" numbers[%d] = %d\n", i, numbers[i]);
21. }
23. puts("malloc an array ...");
24. array = malloc(sizeof(int) * 5);
26. if (array) {
27. puts("This malloc'ed array is not initialized:");
29. for (i = 0; i < 5; i ) {
30. printf(" array[%d] = %d\n", i, array[i]);
31. }
33. free(array);
34. }
36. /* done */
38. puts("Ok");
39. return 0;
40. }

這個程序不會初始化變量，所以變量以系統(tǒng)內(nèi)存中的隨機(jī)值作為初始值。在我的 Linux 系統(tǒng)上編譯和運(yùn)行這個程序，會看到一些變量恰巧有“零”值，但其他變量并沒有：

1. These variables are not initialized:
2. i = 0
3. j = 0
4. k = 32766
5. This array is not initialized:
6. numbers[0] = 0
7. numbers[1] = 0
8. numbers[2] = 4199024
9. numbers[3] = 0
10. numbers[4] = 0
11. malloc an array ...
12. This malloc'ed array is not initialized:
13. array[0] = 0
14. array[1] = 0
15. array[2] = 0
16. array[3] = 0
17. array[4] = 0
18. Ok

很幸運(yùn)，i和j變量是從零值開始的，但k的起始值為 32766。在numbers數(shù)組中，大多數(shù)元素也恰好從零值開始，只有第三個元素的初始值為 4199024。

在不同的系統(tǒng)上編譯相同的程序，可以進(jìn)一步顯示未初始化變量的危險性。不要誤以為“全世界都在運(yùn)行 Linux”，你的程序很可能某天在其他平臺上運(yùn)行。例如，下面是在 FreeDOS 上運(yùn)行相同程序的結(jié)果：

1. These variables are not initialized:
2. i = 0
3. j = 1074
4. k = 3120
5. This array is not initialized:
6. numbers[0] = 3106
7. numbers[1] = 1224
8. numbers[2] = 784
9. numbers[3] = 2926
10. numbers[4] = 1224
11. malloc an array ...
12. This malloc'ed array is not initialized:
13. array[0] = 3136
14. array[1] = 3136
15. array[2] = 14499
16. array[3] = -5886
17. array[4] = 219
18. Ok

永遠(yuǎn)都要記得初始化程序的變量。如果你想讓變量將以零值作為初始值，請額外添加代碼將零分配給該變量。預(yù)先編好這些額外的代碼，這會有助于減少日后讓人頭疼的調(diào)試過程。

2、數(shù)組越界

C 語言中，數(shù)組索引從零開始。這意味著對于長度為 10 的數(shù)組，索引是從 0 到 9；長度為 1000 的數(shù)組，索引則是從 0 到 999。

程序員有時會忘記這一點(diǎn)，他們從索引 1 開始引用數(shù)組，產(chǎn)生了“大小差一”(off by one)錯誤。在長度為 5 的數(shù)組中，程序員在索引“5”處使用的值，實際上并不是數(shù)組的第 5 個元素。相反，它是內(nèi)存中的一些其他值，根本與此數(shù)組無關(guān)。

這是一個數(shù)組越界的示例程序。該程序使用了一個只含有 5 個元素的數(shù)組，但卻引用了該范圍之外的數(shù)組元素：

1. #include <stdio.h>
2. #include <stdlib.h>
4. int
5. main()
6. {
7. int i;
8. int numbers[5];
9. int *array;
11. /* test 1 */
13. puts("This array has five elements (0 to 4)");
15. /* initalize the array */
16. for (i = 0; i < 5; i ) {
17. numbers[i] = i;
18. }
20. /* oops, this goes beyond the array bounds: */
21. for (i = 0; i < 10; i ) {
22. printf(" numbers[%d] = %d\n", i, numbers[i]);
23. }
25. /* test 2 */
27. puts("malloc an array ...");
29. array = malloc(sizeof(int) * 5);
31. if (array) {
32. puts("This malloc'ed array also has five elements (0 to 4)");
34. /* initalize the array */
35. for (i = 0; i < 5; i ) {
36. array[i] = i;
37. }
39. /* oops, this goes beyond the array bounds: */
40. for (i = 0; i < 10; i ) {
41. printf(" array[%d] = %d\n", i, array[i]);
42. }
44. free(array);
45. }
47. /* done */
49. puts("Ok");
50. return 0;
51. }

可以看到，程序初始化了數(shù)組的所有值（從索引 0 到 4），然后從索引 0 開始讀取，結(jié)尾是索引 9 而不是索引 4。前五個值是正確的，再后面的值會讓你不知所以：

1. This array has five elements (0 to 4)
2. numbers[0] = 0
3. numbers[1] = 1
4. numbers[2] = 2
5. numbers[3] = 3
6. numbers[4] = 4
7. numbers[5] = 0
8. numbers[6] = 4198512
9. numbers[7] = 0
10. numbers[8] = 1326609712
11. numbers[9] = 32764
12. malloc an array ...
13. This malloc'ed array also has five elements (0 to 4)
14. array[0] = 0
15. array[1] = 1
16. array[2] = 2
17. array[3] = 3
18. array[4] = 4
19. array[5] = 0
20. array[6] = 133441
21. array[7] = 0
22. array[8] = 0
23. array[9] = 0
24. Ok

引用數(shù)組時，始終要記得追蹤數(shù)組大小。將數(shù)組大小存儲在變量中；不要對數(shù)組大小進(jìn)行硬編碼(hard-code)。否則，如果后期該標(biāo)識符指向另一個不同大小的數(shù)組，卻忘記更改硬編碼的數(shù)組長度時，程序就可能會發(fā)生數(shù)組越界。

3、字符串溢出

字符串只是特定類型的數(shù)組。在 C 語言中，字符串是一個由char類型值組成的數(shù)組，其中用一個零字符表示字符串的結(jié)尾。

因此，與數(shù)組一樣，要注意避免超出字符串的范圍。有時也稱之為 字符串溢出。

使用gets函數(shù)讀取數(shù)據(jù)是一種很容易發(fā)生字符串溢出的行為方式。gets函數(shù)非常危險，因為它不知道在一個字符串中可以存儲多少數(shù)據(jù)，只會機(jī)械地從用戶那里讀取數(shù)據(jù)。如果用戶輸入像foo這樣的短字符串，不會發(fā)生意外；但是當(dāng)用戶輸入的值超過字符串長度時，后果可能是災(zāi)難性的。

下面是一個使用gets函數(shù)讀取城市名稱的示例程序。在這個程序中，我還添加了一些未使用的變量，來展示字符串溢出對其他數(shù)據(jù)的影響：

1. #include <stdio.h>
2. #include <string.h>
4. int
5. main()
6. {
7. char name[10]; /* Such as "Chicago" */
8. int var1 = 1, var2 = 2;
10. /* show initial values */
12. printf("var1 = %d; var2 = %d\n", var1, var2);
14. /* this is bad .. please don't use gets */
16. puts("Where do you live?");
17. gets(name);
19. /* show ending values */
21. printf("<%s> is length %d\n", name, strlen(name));
22. printf("var1 = %d; var2 = %d\n", var1, var2);
24. /* done */
26. puts("Ok");
27. return 0;
28. }

當(dāng)你測試類似的短城市名稱時，該程序運(yùn)行良好，例如伊利諾伊州的Chicago或北卡羅來納州的Raleigh：

1. var1 = 1; var2 = 2
2. Where do you live?
3. Raleigh
4. <Raleigh> is length 7
5. var1 = 1; var2 = 2
6. Ok

威爾士的小鎮(zhèn)Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch有著世界上最長的名字之一。這個字符串有 58 個字符，遠(yuǎn)遠(yuǎn)超出了name變量中保留的 10 個字符。結(jié)果，程序?qū)⒅荡鎯υ趦?nèi)存的其他區(qū)域，覆蓋了var1和var2的值：

1. var1 = 1; var2 = 2
2. Where do you live?
3. Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
4. <Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch> is length 58
5. var1 = 2036821625; var2 = 2003266668
6. Ok
7. Segmentation fault (core dumped)

在運(yùn)行結(jié)束之前，程序會用長字符串覆蓋內(nèi)存的其他部分區(qū)域。注意，var1和var2的值不再是起始的1和2。

避免使用gets函數(shù)，改用更安全的方法來讀取用戶數(shù)據(jù)。例如，getline函數(shù)會分配足夠的內(nèi)存來存儲用戶輸入，因此不會因輸入長值而發(fā)生意外的字符串溢出。

4、重復(fù)釋放內(nèi)存

“分配的內(nèi)存要手動釋放”是良好的 C 語言編程原則之一。程序可以使用malloc函數(shù)為數(shù)組和字符串分配內(nèi)存，該函數(shù)會開辟一塊內(nèi)存，并返回一個指向內(nèi)存中起始地址的指針。之后，程序可以使用free函數(shù)釋放內(nèi)存，該函數(shù)會使用指針將內(nèi)存標(biāo)記為未使用。

但是，你應(yīng)該只使用一次free函數(shù)。第二次調(diào)用free會導(dǎo)致意外的后果，可能會毀掉你的程序。下面是一個針對此點(diǎn)的簡短示例程序。程序分配了內(nèi)存，然后立即釋放了它。但為了模仿一個健忘但有條理的程序員，我在程序結(jié)束時又一次釋放了內(nèi)存，導(dǎo)致兩次釋放了相同的內(nèi)存：

1. #include <stdio.h>
2. #include <stdlib.h>
4. int
5. main()
6. {
7. int *array;
9. puts("malloc an array ...");
11. array = malloc(sizeof(int) * 5);
13. if (array) {
14. puts("malloc succeeded");
16. puts("Free the array...");
17. free(array);
18. }
20. puts("Free the array...");
21. free(array);
23. puts("Ok");
24. }

運(yùn)行這個程序會導(dǎo)致第二次使用free函數(shù)時出現(xiàn)戲劇性的失?。?

1. malloc an array ...
2. malloc succeeded
3. Free the array...
4. Free the array...
5. free(): double free detected in tcache 2
6. Aborted (core dumped)

要記得避免在數(shù)組或字符串上多次調(diào)用free。將malloc和free函數(shù)定位在同一個函數(shù)中，這是避免重復(fù)釋放內(nèi)存的一種方法。

例如，一個紙牌游戲程序可能會在主函數(shù)中為一副牌分配內(nèi)存，然后在其他函數(shù)中使用這副牌來玩游戲。記得在主函數(shù)，而不是其他函數(shù)中釋放內(nèi)存。將malloc和free語句放在一起有助于避免多次釋放內(nèi)存。

5、使用無效的文件指針

文件是一種便捷的數(shù)據(jù)存儲方式。例如，你可以將程序的配置數(shù)據(jù)存儲在config.dat文件中。Bash shell 會從用戶家目錄中的.bash_profile讀取初始化腳本。GNU Emacs 編輯器會尋找文件.emacs以從中確定起始值。而 Zoom 會議客戶端使用zoomus.conf文件讀取其程序配置。

所以，從文件中讀取數(shù)據(jù)的能力幾乎對所有程序都很重要。但是假如要讀取的文件不存在，會發(fā)生什么呢？

在 C 語言中讀取文件，首先要用fopen函數(shù)打開文件，該函數(shù)會返回指向文件的流指針。你可以結(jié)合其他函數(shù)，使用這個指針來讀取數(shù)據(jù)，例如fgetc會逐個字符地讀取文件。

如果要讀取的文件不存在或程序沒有讀取權(quán)限，fopen函數(shù)會返回NULL作為文件指針，這表示文件指針無效。但是這里有一個示例程序，它機(jī)械地直接去讀取文件，不檢查fopen是否返回了NULL：

1. #include <stdio.h>
3. int
4. main()
5. {
6. FILE *pfile;
7. int ch;
9. puts("Open the FILE.TXT file ...");
11. pfile = fopen("FILE.TXT", "r");
13. /* you should check if the file pointer is valid, but we skipped that */
15. puts("Now display the contents of FILE.TXT ...");
17. while ((ch = fgetc(pfile)) != EOF) {
18. printf("<%c>", ch);
19. }
21. fclose(pfile);
23. /* done */
25. puts("Ok");
26. return 0;
27. }

當(dāng)你運(yùn)行這個程序時，第一次調(diào)用fgetc會失敗，程序會立即中止：

1. Open the FILE.TXT file ...
2. Now display the contents of FILE.TXT ...
3. Segmentation fault (core dumped)

始終檢查文件指針以確保其有效。例如，在調(diào)用fopen打開一個文件后，用類似if (pfile != NULL)的語句檢查指針，以確保指針是可以使用的。

人都會犯錯，最優(yōu)秀的程序員也會產(chǎn)生編程錯誤。但是，遵循上面這些準(zhǔn)則，添加一些額外的代碼來檢查這五種類型的錯誤，就可以避免最嚴(yán)重的 C 語言編程錯誤。提前編寫幾行代碼來捕獲這些錯誤，可能會幫你節(jié)省數(shù)小時的調(diào)試時間。

via: https://opensource.com/article/21/10/programming-bugs

作者：Jim Hall 選題：lujun9972 譯者：unigeorge 校對：wxy

本文由 LCTT 原創(chuàng)編譯