Question

我有一个C程序，它接受命令行参数n，可以是1-10。基于这个数字，我需要创建n个不同的变量（例如test（n），test（n + 1）,. ..）。我能以某种方式做到这一点吗？

由于我的范围很小，我想在n上做一个if或switch语句，但这似乎是一种单调乏味的方法。

main(int argc, char *argv[]) {
    // Create argv[1] number of variables
}

有什么想法吗？

Answer 1

您可以使用数组，并使用atoi将参数转换为int：

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        printf("Program needs an int argument!\n");
        return 1;
    }

    int n = atoi(argv[1]);

    if (n < 1 || n > 10)
    {
        printf("The argument must be in the range 1-10!\n");
        return 2;
    }

    int test[n];
    // use test...
    return 0;
}

这会创建一个带有int元素的argv[1]数组，如果程序执行时至少有一个参数，并且第一个参数在[1,10]范围内]。如果第一个参数不在int范围内，即[INT_MIN，INT_MAX]，则程序将导致未定义的行为。

如果没有VLA（可变长度数组）支持，您可以使用动态数组：

int* test = malloc(n * sizeof(int));

或者你可以简单地创建一个大小为10的数组，并且只使用该数组的第一个n元素。

Answer 2

阵列的直接动态分配是解决该问题的另一种可接受的方式。对于已知范围内的少量输入，静态分配很好，但是当需要灵活性时，动态分配提供了一种根据需要增长阵列的方法，并且从一些其他选项的可移植性角度来看通常更安全。这是一个简单的例子：

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

#define MAXELE 10

int main (int argc, char **argv) {

    /* test for required input */
    if (argc < 2) {
        fprintf (stderr, "error: insufficient input.  usage: %s int (no. of array elements)\n", argv[0]);
        return 1;
    }

    /* convert input to numeric form */
    size_t nelements = atoi (argv[1]);
    size_t i = 0;

    /* test values for 1 - 10 */
    if ( nelements < 1 || nelements > MAXELE ) {
        fprintf (stderr, "error: input not within 1 - %d.\n", MAXELE);
        return 1;
    }

    /* allocate nelements int for array & initialize to 0 */
    int *array = calloc (nelements , sizeof *array);

    /* test allocation succeeded, if not exit */
    if (!array) {
        fprintf (stderr, "error: memory allocation failed.\n");
        return 1;
    }

    /* fill array with some numbers */
    for (i = 0; i < nelements; i++)
        array[i] = (i + 2) * i;

    /* print array */
    for (i = 0; i < nelements; i++)
        printf (" array[%2zu]  %d\n", i, array[i]);

    /* free memory allocated to array */
    if (array) free (array);

    return 0;
}

使用/输出

$ ./bin/nintarray 10 array[ 0] 0 array[ 1] 3 array[ 2] 8 array[ 3] 15 array[ 4] 24 array[ 5] 35 array[ 6] 48 array[ 7] 63 array[ 8] 80 array[ 9] 99

Answer 3

只是为了逐字回答问题的乐趣：这个解决方案实际上在递归中在堆栈上分配N个变量，而不仅仅是具有N个项目的数组。你不应该在严肃的背景下这样做：

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

typedef struct vars {
    struct vars *previous;
    int value;
} vars_t;

int run_main(vars_t *variables)
{
    vars_t *var;
    for (var = variables; var; var = var->previous) {
        printf("%p = %d\n", (void *) var, var->value);
    }
    return 0;
}

int alloc_vars(int n, vars_t *previous)
{
    if (n == 0) {
        return run_main(previous);
    }

    vars_t current;
    current.previous = previous;
    current.value = n;
    return alloc_vars(n-1, &current);
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        return 1;
    }

    char *err_pos = NULL;
    long n = strtol(argv[1], &err_pos, 10);
    if (err_pos == argv[1] || *err_pos || n < 0) {
        return 2;
    }

    return alloc_vars(n, NULL);
}

创建n个变量，其中n是参数

3 个答案: