分配数组后从用户那里接受大小。

huangapple
go评论148阅读模式
英文:

Allocating array after accepting size from user

问题

我在C语言中写了类似这样的代码：

  1. #include <stdio.h>
  3. int main() {
  4.     int x;
  5.     printf("enter no of elements/n");
  6.     scanf("%d", &x);
  7.     int arr[x];
  9.     return 0;
  10. }

这个代码可以运行，但很多人说它不是一个好的做法，或者说是不合法的？有人能给出原因吗？

更新：除了可移植性或未定义大小之外，还有其他问题吗？

英文:

I was writing something like this in C.

  1. #include&lt;stdio.h&gt;
  3. int main() {
  4.     int x;
  5.     printf(&quot;enter no of elements/n&quot;);
  6.     scanf(&quot;%d&quot;,&amp;x);
  7.     int arr[x];
  9.     return 0;
  10. }

This works fine, but many said it's not a good practice or it is illegal? Can anybody give reasons for it?

Update: anything wrong other than
portability, or undefined size?

答案1

得分: 4

  1. 假设你的实际代码看起来像以下内容，它将会编译。
  3. ```c
  4. #include <stdio.h>;
  6. int main(void) {
  7.     int n;
  8.     printf("Enter number of elements:\n");
  9.     scanf("%d", &n);
  11.     int arr[n];
  13.     // 其他部分...
  14. }

然而，存在一些问题。

  • 不是所有编译器都支持可变长度数组（Variable length arrays，简称VLAs）。特别是MSVC不支持。依赖它们会影响代码的可移植性。
  • 你没有验证输入。scanf 可能没有读取有效的数字，即使它读取了，0 或负数都会导致未定义的行为。

对此你可以采取以下措施：

  • 你可以动态分配数组的内存，而不是使用VLA。
  • 你可以编写一个函数，检查用户的输入并验证它是正整数。它可以提示用户重新输入，或返回一个 main 可以检查然后优雅地退出程序的值。
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #define LINE_LENGTH 1024
  7. int get_positive_int(void);
  9. int main(void) {
  10.     int n = get_positive_int();
  11.     int *arr = malloc(sizeof(int) * n);
  13.     if (arr == NULL) {
  14.         printf("Array allocation failed.\n");
  15.         return 1;
  16.     }
  18.     // 其他部分...
  19. }
  21. int get_positive_int(void) {
  22.     char line[LINE_LENGTH] = "";
  24.     while (1) {
  25.         printf("Enter number of elements:\n");
  27.         int input = -1;
  29.         fgets(line, LINE_LENGTH, stdin);
  30.         if (sscanf(line, "%d", &input) == 1 && input > 0)
  31.             return input;
  32.     }
  33. }
  2. <details>
  3. <summary>英文:</summary>
  5. Assuming your actual code looks something like the following, it will compile.

#include <stdio.h>

int main(void) {
int n;
printf("Enter number of elements:\n");
scanf("%d", &n);

  1. int arr[n];
  3. // Other stuff...

}

  2. However, there are a few issues.
  4. - Variable length arrays (or VLAs) are not supported by all compilers. Notably MSVC. Relying on them will impact the portability of your code.
  5. - You never validate the input. `scanf` may not have read a valid number, and even if it did, `0` or a negative number are going to lead to undefined behavior.
  7. What can you do about these?
  9. - You can dynamically allocate memory for your array rather than using a VLA.
  10. - You can write a function which checks the input from the user and validates that it&#39;s a positive integer. It might prompt for repeat input or return a value that `main` can check and then gracefully exit the program.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LINE_LENGTH 1024

int get_positive_int(void);

int main(void) {
int n = get_positive_int();
int *arr = malloc(sizeof(int) * n);

  1. if (arr == NULL) {
  2.     printf(&quot;Array allocation failed.\n&quot;);
  3.     return 1;
  4. }
  6. // Other stuff...

}

int get_positive_int(void) {
char line[LINE_LENGTH] = "";

  1. while (1) {
  2.     printf(&quot;Enter number of elements:\n&quot;);
  4.     int input = -1;
  6.     fgets(line, LINE_LENGTH, stdin);
  7.     if (sscanf(line, &quot;%d&quot;, &amp;input) == 1 &amp;&amp; input &gt; 0)
  8.         return input;
  9. }

}

  2. </details>
  6. # 答案2
  7. **得分**: 3
  9. > 但许多人说这不是一个好的做法，或者是非法的？
  11. **合法？**
  13. 是的，但这取决于编译器版本和可选支持。
  15. [可变长度数组](https://en.wikipedia.org/wiki/Variable-length_array)（VLA）如 `int Arr[x];` 在 C99 中得到支持，可选地在 C11 及以后版本中支持（请查阅 `__STDC_NO_VLA__` 进行研究）。
  17. 这会影响可移植性。
  19. **良好的做法？**
  21. * 不检查 `scanf("%d", &x);` 的返回值是不可取的。
  23. * 对于 `int Arr[x];`，如果 `x <= 0`，会导致_未定义行为_（UB）。
  25. * 如果 `x` 很大，我们有可能会面临内存耗尽，如堆栈溢出或其他 UB。
  27. 在以下情况下，VLAs是可以接受的：
  28. * 大小为正且不太大
  29. * 可移植性不是主要关注点
  31. 使用适合工作的正确工具。
  32. VLAs 只在有限的情况下是最佳解决方案。
  34. **更好的示例用法**
  36. ```c
  37. #define VLA_LIMIT 42
  39. printf("输入元素数量：");
  40. int x;
  41. if (scanf("%d", &x) != 1) {
  42.   处理输入错误();  // 待定的代码
  43. } 
  44. if (x <= 0 || x > VLA_LIMIT) {
  45.   处理范围错误();  // 待定的代码
  46. } 
  47. int Arr[x];
  48. ...
英文:

> but many said it's not a good practice or it is illegal?

Legal?

Yes, yet depends on the compiler version and optional support.

Variable length arrays (VLA) like int Arr[x]; are supported starting in C99 and optionally in C11 and later (research __STDC_NO_VLA__).

This impacts portability.

Good practice?

  • Not checking the return value of scanf(&quot;%d&quot;,&amp;x); is weak.

  • With int Arr[x];, if x &lt;= 0, we have undefined behavior (UB).

  • If x is large, we risk memory exhaustion like stack overflow or other UB.

VLAs are OK when:

  • The size is positive and not too large
  • Portability is not a large concern.

Use the right tool for the job.
VLAs have limited cases when they are the best solution.

Better example usage

  1.   #define VLA_LIMIT 42
  3.   printf(&quot;enter no of elements &quot;);
  4.   int x;
  5.   if (scanf(&quot;%d&quot;,&amp;x) != 1) {
  6.     Handle_Input_Error();  // TBD code
  7.   } 
  8.   if (x &lt;= 0 || x &gt; VLA_LIMIT) {
  9.     Handle_Range_Error();  // TBD code
  10.   } 
  11.   int Arr[x];
  12.   ...

huangapple
  • 本文由 发表于 2023年8月5日 10:44:52
  • 转载请务必保留本文链接：https://go.coder-hub.com/76839960.html
  • arrays
  • c
  • declaration
  • indexing
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定