C语言中的数组声明

如何使用函数的参数在函数内声明数组

我的代码是：

double function_2(int a)
{
  int t[a];
}

出现以下错误：

Expression must have a constant value.

---

您不能直接分配它。 你必须声明它为固定常数

---

否则，请使用指针的概念。

您不能直接分配它。 你必须声明它为固定常数

---

否则，请使用指针的概念。

代替数组，您应该使用内存分配，并将其用作迭代或其他用途的数组。

代替数组，您应该使用内存分配，并将其用作迭代或其他用途的数组。

您的代码是完全有效的C代码

您正在使用VLA（可变长度数组）。这是c99特性，您必须确保编译器支持c99代码

如果您使用的是

gcc

，默认情况下

gcc

设置为

-std=gnu89

，即C89+GNU扩展。使用

-std=c99

或

-std=gnu99

和

gcc

编译程序

如果您使用的是MSVC，不幸的是它不支持c99，因此您不能将c99功能用于此编译器

编辑：

如果编译器不支持VLA，则可以使用动态内存分配：

#include <stdlib.h>

double function_2(int a)
{
    // Allocate array object
    int *t = malloc(a * sizeof *t);

    if (!t) {
        // Handle malloc errors
    }

    // Write your program here: ...

    // Free array object
    free(t);
}

#包括
双功能_2（int a）
{
//分配数组对象
int*t=malloc（a*sizeof*t）；
如果（！t）{
//处理malloc错误
}
//在这里编写程序：。。。
//自由数组对象
自由（t）；
}

您的代码是完全有效的C代码

您正在使用VLA（可变长度数组）。这是c99特性，您必须确保编译器支持c99代码

如果您使用的是

gcc

，默认情况下

gcc

设置为

-std=gnu89

，即C89+GNU扩展。使用

-std=c99

或

-std=gnu99

和

gcc

编译程序

如果您使用的是MSVC，不幸的是它不支持c99，因此您不能将c99功能用于此编译器

编辑：

如果编译器不支持VLA，则可以使用动态内存分配：

#include <stdlib.h>

double function_2(int a)
{
    // Allocate array object
    int *t = malloc(a * sizeof *t);

    if (!t) {
        // Handle malloc errors
    }

    // Write your program here: ...

    // Free array object
    free(t);
}

#包括
双功能_2（int a）
{
//分配数组对象
int*t=malloc（a*sizeof*t）；
如果（！t）{
//处理malloc错误
}
//在这里编写程序：。。。
//自由数组对象
自由（t）；
}

C99具有的扩展名。如果使用以下命令编译代码，它将正常工作：

gcc -std=gnu99 lala.c -o lala

如果您使用的是VC++，则不存在可变长度数组，因为它使用的标准是C89，带有C99的一些功能（不包括可变长度数组）

---

既然您提到使用VC++编译，我将补充几点注意事项：

• 通过将源文件的扩展名更改为

  .C

  而不是

  .cpp

  来确保代码被编译为C
• 由于不支持可变长度数组，如我前面所述，因此必须使用动态方法（见下文）

使用动态分配执行与您正在尝试的操作相同的操作：

int * t = malloc(a * sizeof(int))

---

如果您正在使用动态分配并希望返回数组，则可以让函数返回a

int*

，然后返回

t

。但是，如果执行此操作，通常也会返回数组的长度（除非它是固定的已知长度）。用于返回此长度的常用技术有：

• 提供一个单独的函数，除了检查计算所需的数组大小并返回它之外，它什么也不做

例如：

// Returns number of entries in the Lala array returned from b()
int GetNumLalaEntries(void);

// Function b which returns an array.
int * b(void)
{
  int * lala = malloc(5 * sizeof(int *));
  ...
  return lala;
}

// We are passing in the array this time.
void b(int * lala)
{
  ... // Do whatever you need with lala
}

int main(void)
{
  int * lala = malloc(GetNumLalaEntries() * sizeof(int *));
  b(lala);
  return 0;
}

struct lala_encapsulation {
  int * lala;
  int   lala_entries;
};

struct lala_encapsulation b(void)
{
  struct lala_encapsulation le;
  le.lala_entries = 5;
  le.lala         = malloc(le.lala_entires * sizeof(int *));

  return le;
}

在上述情况下，

GetNumLalaEntries

始终返回5，但如果此数字是动态的，则需要从一些内部同步信息生成

• 使用第一种技术，让调用者在数组中传递。这样做的好处是调用方随后处理数组的分配和解除分配

例如：

// Returns number of entries in the Lala array returned from b()
int GetNumLalaEntries(void);

// Function b which returns an array.
int * b(void)
{
  int * lala = malloc(5 * sizeof(int *));
  ...
  return lala;
}

// We are passing in the array this time.
void b(int * lala)
{
  ... // Do whatever you need with lala
}

int main(void)
{
  int * lala = malloc(GetNumLalaEntries() * sizeof(int *));
  b(lala);
  return 0;
}

struct lala_encapsulation {
  int * lala;
  int   lala_entries;
};

struct lala_encapsulation b(void)
{
  struct lala_encapsulation le;
  le.lala_entries = 5;
  le.lala         = malloc(le.lala_entires * sizeof(int *));

  return le;
}

• 返回一个同时具有数组指针和数组大小的

  struct

例如：

// Returns number of entries in the Lala array returned from b()
int GetNumLalaEntries(void);

// Function b which returns an array.
int * b(void)
{
  int * lala = malloc(5 * sizeof(int *));
  ...
  return lala;
}

// We are passing in the array this time.
void b(int * lala)
{
  ... // Do whatever you need with lala
}

int main(void)
{
  int * lala = malloc(GetNumLalaEntries() * sizeof(int *));
  b(lala);
  return 0;
}

struct lala_encapsulation {
  int * lala;
  int   lala_entries;
};

struct lala_encapsulation b(void)
{
  struct lala_encapsulation le;
  le.lala_entries = 5;
  le.lala         = malloc(le.lala_entires * sizeof(int *));

  return le;
}

最后一个方法允许您通过将整个数组包装在一个可以通过值返回的

结构中来返回它。
C99有一个扩展名。如果使用以下命令编译代码，它将正常工作：

gcc -std=gnu99 lala.c -o lala

double function_2(int a)
{
  int * t = (int*)malloc(sizeof(int)*a);
  for(int i = 0; i<a; i++)
  {
    // do your work here, accessing t like an array
    t[i]=...
  }
  free(t);

...
}

如果您使用的是VC++，则不存在可变长度数组，因为它使用的标准是C89，带有C99的一些功能（不包括可变长度数组）


既然您提到使用VC++编译，我将补充几点注意事项：


通过将源文件的扩展名更改为
.C
而不是
.cpp
来确保代码被编译为C
由于不支持可变长度数组，如我前面所述，因此必须使用动态方法（见下文）

使用动态分配执行与您正在尝试的操作相同的操作：

int * t = malloc(a * sizeof(int))


如果您正在使用动态分配并希望返回数组，则可以让函数返回a
int*
，然后返回
t
。但是，如果执行此操作，通常也会返回数组的长度（除非它是固定的已知长度）。用于返回此长度的常用技术有：


提供一个单独的函数，除了检查计算所需的数组大小并返回它之外，它什么也不做

例如：

// Returns number of entries in the Lala array returned from b()
int GetNumLalaEntries(void);

// Function b which returns an array.
int * b(void)
{
  int * lala = malloc(5 * sizeof(int *));
  ...
  return lala;
}

// We are passing in the array this time.
void b(int * lala)
{
  ... // Do whatever you need with lala
}

int main(void)
{
  int * lala = malloc(GetNumLalaEntries() * sizeof(int *));
  b(lala);
  return 0;
}

struct lala_encapsulation {
  int * lala;
  int   lala_entries;
};

struct lala_encapsulation b(void)
{
  struct lala_encapsulation le;
  le.lala_entries = 5;
  le.lala         = malloc(le.lala_entires * sizeof(int *));

  return le;
}

在上述情况下，
GetNumLalaEntries
始终返回5，但如果此数字是动态的，则需要从一些内部同步信息生成


使用第一种技术，让调用者在数组中传递。这样做的好处是调用方随后处理数组的分配和解除分配

例如：

// Returns number of entries in the Lala array returned from b()
int GetNumLalaEntries(void);

// Function b which returns an array.
int * b(void)
{
  int * lala = malloc(5 * sizeof(int *));
  ...
  return lala;
}

// We are passing in the array this time.
void b(int * lala)
{
  ... // Do whatever you need with lala
}

int main(void)
{
  int * lala = malloc(GetNumLalaEntries() * sizeof(int *));
  b(lala);
  return 0;
}

struct lala_encapsulation {
  int * lala;
  int   lala_entries;
};

struct lala_encapsulation b(void)
{
  struct lala_encapsulation le;
  le.lala_entries = 5;
  le.lala         = malloc(le.lala_entires * sizeof(int *));

  return le;
}


返回一个同时具有a和