document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2024-12-26 21:30:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

PRF

Browse Source 
@unigeorge
This commit is contained in:
Xingyu Wang 2021-10-18 17:41:56 +08:00
parent 4ebd8ea093
commit 44f8c8e996
1 changed files with 138 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

279
translated/tech/20211014 5 common bugs in C programming and how to fix them.md
View File

@ -3,21 +3,22 @@
[#]: author: "Jim Hall https://opensource.com/users/jim-hall" [#]: author: "Jim Hall https://opensource.com/users/jim-hall"
[#]: collector: "lujun9972" [#]: collector: "lujun9972"
[#]: translator: "unigeorge" [#]: translator: "unigeorge"
[#]: reviewer: " " [#]: reviewer: "wxy"
[#]: publisher: " " [#]: publisher: " "
[#]: url: " " [#]: url: " "
C 语言编程中的 5 个常见 bug 及对应解决方案 C 语言编程中的 5 个常见错误及对应解决方案
====== ======
增强 C 语言程序弹性和可靠性的五种方法。 > 增强 C 语言程序的弹性和可靠性的五种方法。
![Bug tracking magnifying glass on computer screen][1]
即使是最好的程序员也无法完全避免 bug。这些 bug 可能会引入安全漏洞、导致程序崩溃或产生意外操作，具体影响要取决于程序的运行逻辑。 ![](https://img.linux.net.cn/data/attachment/album/202110/18/174123p4cz99skp9zz4nf4.jpg)
C 语言有时名声不太好，因为它不像近期的编程语言（比如 Rust）那样具有内存安全性。但是通过额外的代码，一些最常见和严重的 C 语言 bug 是可以避免的。下文讲解了可能影响应用程序的五个 bug 以及避免这些 bug 的方法： 即使是最好的程序员也无法完全避免错误。这些错误可能会引入安全漏洞、导致程序崩溃或产生意外操作，具体影响要取决于程序的运行逻辑。
### 1\. 未初始化的变量 C 语言有时名声不太好，因为它不像近期的编程语言（比如 Rust）那样具有内存安全性。但是通过额外的代码，一些最常见和严重的 C 语言错误是可以避免的。下文讲解了可能影响应用程序的五个错误以及避免它们的方法：
### 1、未初始化的变量
程序启动时，系统会为其分配一块内存以供存储数据。这意味着程序启动时，变量将获得内存中的一个随机值。 程序启动时，系统会为其分配一块内存以供存储数据。这意味着程序启动时，变量将获得内存中的一个随机值。
@ -25,7 +26,6 @@ C 语言有时名声不太好，因为它不像近期的编程语言（比如 Ru
看一下这个使用了若干变量和两个数组的示例程序： 看一下这个使用了若干变量和两个数组的示例程序：
``` ```
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -33,39 +33,39 @@ C 语言有时名声不太好，因为它不像近期的编程语言（比如 Ru
int int
main() main()
{ {
  int i, j, k; int i, j, k;
  int numbers[5]; int numbers[5];
  int *array; int *array;
  [puts][2]("These variables are not initialized:"); puts("These variables are not initialized:");
  [printf][3]("  i = %d\n", i); printf(" i = %d\n", i);
  [printf][3]("  j = %d\n", j); printf(" j = %d\n", j);
  [printf][3]("  k = %d\n", k); printf(" k = %d\n", k);
  [puts][2]("This array is not initialized:"); puts("This array is not initialized:");
  for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
    [printf][3]("  numbers[%d] = %d\n", i, numbers[i]); printf(" numbers[%d] = %d\n", i, numbers[i]);
  } }
  [puts][2]("malloc an array ..."); puts("malloc an array ...");
  array = [malloc][4](sizeof(int) * 5); array = malloc(sizeof(int) * 5);
  if (array) { if (array) {
    [puts][2]("This malloc'ed array is not initialized:"); puts("This malloc'ed array is not initialized:");
    for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
      [printf][3]("  array[%d] = %d\n", i, array[i]); printf(" array[%d] = %d\n", i, array[i]);
    } }
    [free][5](array); free(array);
  } }
  /* done */ /* done */
  [puts][2]("Ok"); puts("Ok");
  return 0; return 0;
} }
``` ```
@ -73,57 +73,57 @@ main()
``` ```
These variables are not initialized: These variables are not initialized:
  i = 0 i = 0
  j = 0 j = 0
  k = 32766 k = 32766
This array is not initialized: This array is not initialized:
  numbers[0] = 0 numbers[0] = 0
  numbers[1] = 0 numbers[1] = 0
  numbers[2] = 4199024 numbers[2] = 4199024
  numbers[3] = 0 numbers[3] = 0
  numbers[4] = 0 numbers[4] = 0
malloc an array ... malloc an array ...
This malloc'ed array is not initialized: This malloc'ed array is not initialized:
  array[0] = 0 array[0] = 0
  array[1] = 0 array[1] = 0
  array[2] = 0 array[2] = 0
  array[3] = 0 array[3] = 0
  array[4] = 0 array[4] = 0
Ok Ok
``` ```
很幸运，`i` 和 `j` 变量是从零值开始的，但 `k` 的起始值为 32766。在 numbers 数组中，大多数元素也恰好从零值开始，只有第三个元素的初始值为 4199024。 很幸运，`i` 和 `j` 变量是从零值开始的，但 `k` 的起始值为 32766。在 `numbers` 数组中，大多数元素也恰好从零值开始，只有第三个元素的初始值为 4199024。
在不同的系统上编译相同的程序，可以进一步显示未初始化变量的危险性。不要误以为“全世界都在运行 Linux”，你的程序很可能某天在其他平台上运行。例如，下面是在 FreeDOS 上运行相同程序的结果： 在不同的系统上编译相同的程序，可以进一步显示未初始化变量的危险性。不要误以为“全世界都在运行 Linux”，你的程序很可能某天在其他平台上运行。例如，下面是在 FreeDOS 上运行相同程序的结果：
``` ```
These variables are not initialized: These variables are not initialized:
  i = 0 i = 0
  j = 1074 j = 1074
  k = 3120 k = 3120
This array is not initialized: This array is not initialized:
  numbers[0] = 3106 numbers[0] = 3106
  numbers[1] = 1224 numbers[1] = 1224
  numbers[2] = 784 numbers[2] = 784
  numbers[3] = 2926 numbers[3] = 2926
  numbers[4] = 1224 numbers[4] = 1224
malloc an array ... malloc an array ...
This malloc'ed array is not initialized: This malloc'ed array is not initialized:
  array[0] = 3136 array[0] = 3136
  array[1] = 3136 array[1] = 3136
  array[2] = 14499 array[2] = 14499
  array[3] = -5886 array[3] = -5886
  array[4] = 219 array[4] = 219
Ok Ok
``` ```
永远都要记得初始化程序的变量。如果你想让变量将以零值作为初始值，请额外添加代码将零分配给该变量。预先编好这些额外的代码，这会有助于减少日后让人头疼的 debug 过程。 永远都要记得初始化程序的变量。如果你想让变量将以零值作为初始值，请额外添加代码将零分配给该变量。预先编好这些额外的代码，这会有助于减少日后让人头疼的调试过程。
### 2\. 数组越界 ### 2、数组越界
C 语言中，数组索引从零开始。这意味着对于长度为 10 的数组，索引是从 0 到 9；长度为 1000 的数组，索引则是从 0 到 999。 C 语言中，数组索引从零开始。这意味着对于长度为 10 的数组，索引是从 0 到 9；长度为 1000 的数组，索引则是从 0 到 999。
程序员有时会忘记这一点，他们从索引 1 开始引用数组，产生了<ruby>“大小差一”<rt>off by one</rt></ruby> bug。在长度为 5 的数组中，程序员在索引“5”处使用的值，实际上并不是数组的第 5 个元素。相反，它是内存中的一些其他值，根本与此数组无关。 程序员有时会忘记这一点，他们从索引 1 开始引用数组，产生了<ruby>“大小差一”<rt>off by one</rt></ruby>错误。在长度为 5 的数组中，程序员在索引“5”处使用的值，实际上并不是数组的第 5 个元素。相反，它是内存中的一些其他值，根本与此数组无关。
这是一个数组越界的示例程序。该程序使用了一个只含有 5 个元素的数组，但却引用了该范围之外的数组元素： 这是一个数组越界的示例程序。该程序使用了一个只含有 5 个元素的数组，但却引用了该范围之外的数组元素：
@ -134,50 +134,50 @@ C 语言中，数组索引从零开始。这意味着对于长度为 10 的数
int int
main() main()
{ {
  int i; int i;
  int numbers[5]; int numbers[5];
  int *array; int *array;
  /* test 1 */ /* test 1 */
  [puts][2]("This array has five elements (0 to 4)"); puts("This array has five elements (0 to 4)");
  /* initalize the array */ /* initalize the array */
  for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
    numbers[i] = i; numbers[i] = i;
  } }
  /* oops, this goes beyond the array bounds: */ /* oops, this goes beyond the array bounds: */
  for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
    [printf][3]("  numbers[%d] = %d\n", i, numbers[i]); printf(" numbers[%d] = %d\n", i, numbers[i]);
  } }
  /* test 2 */ /* test 2 */
  [puts][2]("malloc an array ..."); puts("malloc an array ...");
  array = [malloc][4](sizeof(int) * 5); array = malloc(sizeof(int) * 5);
  if (array) { if (array) {
    [puts][2]("This malloc'ed array also has five elements (0 to 4)"); puts("This malloc'ed array also has five elements (0 to 4)");
    /* initalize the array */ /* initalize the array */
    for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
      array[i] = i; array[i] = i;
    } }
    /* oops, this goes beyond the array bounds: */ /* oops, this goes beyond the array bounds: */
    for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
      [printf][3]("  array[%d] = %d\n", i, array[i]); printf(" array[%d] = %d\n", i, array[i]);
    } }
    [free][5](array); free(array);
  } }
  /* done */ /* done */
  [puts][2]("Ok"); puts("Ok");
  return 0; return 0;
} }
``` ```
@ -210,10 +210,9 @@ This malloc'ed array also has five elements (0 to 4)
Ok Ok
``` ```
引用数组时，始终要记得追踪数组大小。将数组大小存储在变量中；不要对数组大小进行<ruby>硬编码<rt>hard-code</rt></ruby>。否则，如果后期该标识符指向另一个不同大小的数组，却忘记更改硬编码的数组长度 引用数组时，始终要记得追踪数组大小。将数组大小存储在变量中；不要对数组大小进行<ruby>硬编码<rt>hard-code</rt></ruby>。否则，如果后期该标识符指向另一个不同大小的数组，却忘记更改硬编码的数组长度时，程序就可能会发生数组越界。
时，程序就可能会发生数组越界。
### 3\. 字符串溢出 ### 3、字符串溢出
字符串只是特定类型的数组。在 C 语言中，字符串是一个由 `char` 类型值组成的数组，其中用一个零字符表示字符串的结尾。 字符串只是特定类型的数组。在 C 语言中，字符串是一个由 `char` 类型值组成的数组，其中用一个零字符表示字符串的结尾。
@ -230,31 +229,31 @@ Ok
int int
main() main()
{ {
  char name[10];                       /* Such as "Chicago" */ char name[10]; /* Such as "Chicago" */
  int var1 = 1, var2 = 2; int var1 = 1, var2 = 2;
  /* show initial values */ /* show initial values */
  [printf][3]("var1 = %d; var2 = %d\n", var1, var2); printf("var1 = %d; var2 = %d\n", var1, var2);
  /* this is bad .. please don't use gets */ /* this is bad .. please don't use gets */
  [puts][2]("Where do you live?"); puts("Where do you live?");
  [gets][6](name); gets(name);
  /* show ending values */ /* show ending values */
  [printf][3]("<%s> is length %d\n", name, [strlen][7](name)); printf("<%s> is length %d\n", name, strlen(name));
  [printf][3]("var1 = %d; var2 = %d\n", var1, var2); printf("var1 = %d; var2 = %d\n", var1, var2);
  /* done */ /* done */
  [puts][2]("Ok"); puts("Ok");
  return 0; return 0;
} }
``` ```
当您测试类似的短城市名称时，该程序运行良好，例如伊利诺伊州的<ruby>`芝加哥`<rt>Chicago</rt></ruby>或北卡罗来纳州的<ruby>`罗利`<rt>Raleigh</rt></ruby>： 当你测试类似的短城市名称时，该程序运行良好，例如伊利诺伊州的 `Chicago` 或北卡罗来纳州的`Raleigh`：
``` ```
var1 = 1; var2 = 2 var1 = 1; var2 = 2
@ -265,7 +264,7 @@ var1 = 1; var2 = 2
Ok Ok
``` ```
威尔士小镇 `Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch` 有着世界上最长的名字之一。这个字符串有 58 个字符，远远超出了 `name` 变量中保留的 10 个字符。结果，程序将值存储在内存的其他区域，覆盖了 `var1` 和 `var2` 的值： 威尔士的小镇 `Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch` 有着世界上最长的名字之一。这个字符串有 58 个字符，远远超出了 `name` 变量中保留的 10 个字符。结果，程序将值存储在内存的其他区域，覆盖了 `var1` 和 `var2` 的值：
``` ```
var1 = 1; var2 = 2 var1 = 1; var2 = 2
@ -281,7 +280,7 @@ Segmentation fault (core dumped)
避免使用 `gets` 函数，改用更安全的方法来读取用户数据。例如，`getline` 函数会分配足够的内存来存储用户输入，因此不会因输入长值而发生意外的字符串溢出。 避免使用 `gets` 函数，改用更安全的方法来读取用户数据。例如，`getline` 函数会分配足够的内存来存储用户输入，因此不会因输入长值而发生意外的字符串溢出。
### 4\. 重复释放内存 ### 4、重复释放内存
“分配的内存要手动释放”是良好的 C 语言编程原则之一。程序可以使用 `malloc` 函数为数组和字符串分配内存，该函数会开辟一块内存，并返回一个指向内存中起始地址的指针。之后，程序可以使用 `free` 函数释放内存，该函数会使用指针将内存标记为未使用。 “分配的内存要手动释放”是良好的 C 语言编程原则之一。程序可以使用 `malloc` 函数为数组和字符串分配内存，该函数会开辟一块内存，并返回一个指向内存中起始地址的指针。之后，程序可以使用 `free` 函数释放内存，该函数会使用指针将内存标记为未使用。
@ -294,23 +293,23 @@ Segmentation fault (core dumped)
int int
main() main()
{ {
  int *array; int *array;
  [puts][2]("malloc an array ..."); puts("malloc an array ...");
  array = [malloc][4](sizeof(int) * 5); array = malloc(sizeof(int) * 5);
  if (array) { if (array) {
    [puts][2]("malloc succeeded"); puts("malloc succeeded");
    [puts][2]("Free the array..."); puts("Free the array...");
    [free][5](array); free(array);
  } }
  [puts][2]("Free the array..."); puts("Free the array...");
  [free][5](array); free(array);
  [puts][2]("Ok"); puts("Ok");
} }
``` ```
@ -329,16 +328,14 @@ Aborted (core dumped)
例如，一个纸牌游戏程序可能会在主函数中为一副牌分配内存，然后在其他函数中使用这副牌来玩游戏。记得在主函数，而不是其他函数中释放内存。将 `malloc` 和 `free` 语句放在一起有助于避免多次释放内存。 例如，一个纸牌游戏程序可能会在主函数中为一副牌分配内存，然后在其他函数中使用这副牌来玩游戏。记得在主函数，而不是其他函数中释放内存。将 `malloc` 和 `free` 语句放在一起有助于避免多次释放内存。
### 5\. 使用无效的文件指针 ### 5、使用无效的文件指针
文件是一种便捷的数据存储方式。例如，你可以将程序的配置数据存储在 `config.dat` 文件中。Bash shell 会从用户家目录中的`.bash_profile` 读取初始化脚本。GNU Emacs 编辑器会寻找文件 `.emacs` 以从中确定起始值。而 Zoom 会议客户端使用 `zoomus.conf` 文件读取其程序配置。 文件是一种便捷的数据存储方式。例如，你可以将程序的配置数据存储在 `config.dat` 文件中。Bash shell 会从用户家目录中的 `.bash_profile` 读取初始化脚本。GNU Emacs 编辑器会寻找文件 `.emacs` 以从中确定起始值。而 Zoom 会议客户端使用 `zoomus.conf` 文件读取其程序配置。
所以，从文件中读取数据的能力几乎对所有程序都很重要。但是假如要读取的文件不存在，会发生什么呢？ 所以，从文件中读取数据的能力几乎对所有程序都很重要。但是假如要读取的文件不存在，会发生什么呢？
在 C 语言中读取文件，首先要用 `fopen` 函数打开文件，该函数会返回指向文件的流指针。你可以结合其他函数，使用这个指针来读取数据，例如 `fgetc` 会逐个字符地读取文件。 在 C 语言中读取文件，首先要用 `fopen` 函数打开文件，该函数会返回指向文件的流指针。你可以结合其他函数，使用这个指针来读取数据，例如 `fgetc` 会逐个字符地读取文件。
If the file you want to read isn't there or isn't readable by your program, then the `fopen` function will return `NULL` as the file pointer, which is an indication the file pointer is invalid. But here's a sample program that innocently does not check if `fopen` returned `NULL` and tries to read the file regardless:
如果要读取的文件不存在或程序没有读取权限，`fopen` 函数会返回 `NULL` 作为文件指针，这表示文件指针无效。但是这里有一个示例程序，它机械地直接去读取文件，不检查 `fopen` 是否返回了 `NULL`： 如果要读取的文件不存在或程序没有读取权限，`fopen` 函数会返回 `NULL` 作为文件指针，这表示文件指针无效。但是这里有一个示例程序，它机械地直接去读取文件，不检查 `fopen` 是否返回了 `NULL`：
``` ```
@ -347,27 +344,27 @@ If the file you want to read isn't there or isn't readable by your program, then
int int
main() main()
{ {
  FILE *pfile; FILE *pfile;
  int ch; int ch;
  [puts][2]("Open the FILE.TXT file ..."); puts("Open the FILE.TXT file ...");
  pfile = [fopen][8]("FILE.TXT", "r"); pfile = fopen("FILE.TXT", "r");
  /* you should check if the file pointer is valid, but we skipped that */ /* you should check if the file pointer is valid, but we skipped that */
  [puts][2]("Now display the contents of FILE.TXT ..."); puts("Now display the contents of FILE.TXT ...");
  while ((ch = [fgetc][9](pfile)) != EOF) { while ((ch = fgetc(pfile)) != EOF) {
    [printf][3]("<%c>", ch); printf("<%c>", ch);
  } }
  [fclose][10](pfile); fclose(pfile);
  /* done */ /* done */
  [puts][2]("Ok"); puts("Ok");
  return 0; return 0;
} }
``` ```
@ -381,7 +378,7 @@ Segmentation fault (core dumped)
始终检查文件指针以确保其有效。例如，在调用 `fopen` 打开一个文件后，用类似 `if (pfile != NULL)` 的语句检查指针，以确保指针是可以使用的。 始终检查文件指针以确保其有效。例如，在调用 `fopen` 打开一个文件后，用类似 `if (pfile != NULL)` 的语句检查指针，以确保指针是可以使用的。
人都会犯错，最优秀的程序员也会产生编程 bug。但是，遵循上面这些准则，添加一些额外的代码来检查这五种类型的 bug，就可以避免最严重的 C 语言编程错误。提前编写几行代码来捕获这些错误，可能会帮你节省数小时的调试时间。 人都会犯错，最优秀的程序员也会产生编程错误。但是，遵循上面这些准则，添加一些额外的代码来检查这五种类型的错误，就可以避免最严重的 C 语言编程错误。提前编写几行代码来捕获这些错误，可能会帮你节省数小时的调试时间。
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
@ -390,7 +387,7 @@ via: https://opensource.com/article/21/10/programming-bugs
作者：[Jim Hall][a] 作者：[Jim Hall][a]
选题：[lujun9972][b] 选题：[lujun9972][b]
译者：[unigeorge](https://github.com/unigeorge) 译者：[unigeorge](https://github.com/unigeorge)
校对：[校对者ID](https://github.com/校对者ID) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出