Question

有没有办法以浓缩形式这样做？

GLfloat coordinates[8];
...
coordinates[0] = 1.0f;
coordinates[1] = 0.0f;
coordinates[2] = 1.0f;
coordinates[3] = 1.0f;
coordinates[4] = 0.0f;
coordinates[5] = 1.0f;
coordinates[6] = 0.0f;
coordinates[7] = 0.0f;
return coordinates;

像coordinates = {1.0f, ...};？

之类的东西

Answer 1

如果你真的要分配值（而不是初始化），你可以这样做：

 GLfloat coordinates[8]; 
 static const GLfloat coordinates_defaults[8] = {1.0f, 0.0f, 1.0f ....};
 ... 
 memcpy(coordinates, coordinates_defaults, sizeof(coordinates_defaults));

 return coordinates;

Answer 2

老派方式：

GLfloat coordinates[8];
...

GLfloat *p = coordinates;
*p++ = 1.0f; *p++ = 0.0f; *p++ = 1.0f; *p++ = 1.0f;
*p++ = 0.0f; *p++ = 1.0f; *p++ = 0.0f; *p++ = 0.0f;

return coordinates;

Answer 3

有一个技巧可以将数组包装成一个结构（可以在声明后初始化）。

即

struct foo {
  GLfloat arr[10];
};
...
struct foo foo;
foo = (struct foo) { .arr = {1.0, ... } };

Answer 4

确切地说，你几乎得到了它：

GLfloat coordinates[8] = {1.0f, ..., 0.0f};

Answer 5

您可以使用：

GLfloat coordinates[8] = {1.0f, ..., 0.0f};

但这是一个编译时初始化 - 您不能在当前标准中使用该方法重新初始化（尽管我认为在即将推出的标准中有一些方法可以做到这一点，这可能无法立即帮助您）。

如果它们被修复了，另外两种让人想起的方法是抨击内容：

GLfloat base_coordinates[8] = {1.0f, ..., 0.0f};
GLfloat coordinates[8];
:
memcpy (coordinates, base_coordinates, sizeof (coordinates));

或者提供一个看起来像你的初始化代码的函数：

void setCoords (float *p0, float p1, ..., float p8) {
    p0[0] = p1; p0[1] = p2; p0[2] = p3; p0[3] = p4;
    p0[4] = p5; p0[5] = p6; p0[6] = p7; p0[7] = p8;
}
:
setCoords (coordinates, 1.0f, ..., 0.0f);

请记住这些省略号（...）是占位符，而不是字面上插入代码中的东西。

Answer 6

如果你在程序中经常做同样的任务并想要一个快捷方式，那么最直接的解决方案可能只是添加一个函数

static inline void set_coordinates(
        GLfloat coordinates[static 8],
        GLfloat c0, GLfloat c1, GLfloat c2, GLfloat c3,
        GLfloat c4, GLfloat c5, GLfloat c6, GLfloat c7)
{
    coordinates[0] = c0;
    coordinates[1] = c1;
    coordinates[2] = c2;
    coordinates[3] = c3;
    coordinates[4] = c4;
    coordinates[5] = c5;
    coordinates[6] = c6;
    coordinates[7] = c7;
}

然后简单地调用

GLfloat coordinates[8];
// ...
set_coordinates(coordinates, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f);

Answer 7

使用如下代码：

const int node_ct = 8;
const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };

在configure.ac

中

AC_PROG_CC_C99

我的开发机器上的编译器很高兴。服务器上的编译器抱怨：

error: variable-sized object may not be initialized
   const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };

和

warning: excess elements in array initializer
   const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };

每个元素

它完全不抱怨，例如：

int expected[] = { 1, 2, 3, 4, 5 };

但是，我决定我喜欢尺寸检查。

我没有战斗，而是使用了varargs初始化程序：

#include <stdarg.h>

void int_array_init(int *a, const int ct, ...) {
  va_list args;
  va_start(args, ct);
  for(int i = 0; i < ct; ++i) {
    a[i] = va_arg(args, int);
  }
  va_end(args);
}

称为，

const int node_ct = 8;
int expected[node_ct];
int_array_init(expected, node_ct, 1, 3, 4, 2, 5, 6, 7, 8);

这样，varargs支持比数组支持更健壮初始化程序。

某人也许可以在宏中执行类似的操作。

在https://github.com/wbreeze/davenport/pull/15/files处找到带有示例代码的PR

关于@paxdiablo的https://stackoverflow.com/a/3535455/608359，我喜欢它；但是，对于将初始化指针前进的次数与分配给数组的元素的次数同步感到不安全。最坏的情况是，初始化指针超出分配的长度。因此，PR中的差异包含

  int expected[node_ct];
- int *p = expected;
- *p++ = 1; *p++ = 2; *p++ = 3; *p++ = 4;
+ int_array_init(expected, node_ct, 1, 2, 3, 4);

如果int_array_init方法的数量为参数少于node_ct。垃圾分配应该更容易进行调试。

Answer 8

typedef struct{
  char array[4];
}my_array;

my_array array = { .array = {1,1,1,1} }; // initialisation

void assign(my_array a)
{
  array.array[0] = a.array[0];
  array.array[1] = a.array[1];
  array.array[2] = a.array[2];
  array.array[3] = a.array[3]; 
}

char num = 5;
char ber = 6;

int main(void)
{
  printf("%d\n", array.array[0]);
// ...

  // this works even after initialisation
  assign((my_array){ .array = {num,ber,num,ber} });

  printf("%d\n", array.array[0]);
// ....
  return 0;
}

在C中为数组分配多个值

8 个答案: