C语言 在 C 中为数组分配多个值
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/3535410/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Assign multiple values to array in C
提问by UnstableFractal
Is there any way to do this in a condensed form?
有没有办法以浓缩的形式做到这一点？
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;
Something like coordinates = {1.0f, ...};?
像coordinates = {1.0f, ...};什么？
采纳答案by James Curran
If you really to assignvalues (as opposed to initialize), you can do it like this:
如果你真的要赋值（而不是initialize），你可以这样做：
GLfloat coordinates[8];
static const GLfloat coordinates_defaults[8] = {1.0f, 0.0f, 1.0f ....};
...
memcpy(coordinates, coordinates_defaults, sizeof(coordinates_defaults));
return coordinates;
回答by domen
There's a trick to wrap the array into a struct (which can be initialized after declaration).
有一个技巧可以将数组包装成一个结构体（可以在声明后进行初始化）。
ie.
IE。
struct foo {
GLfloat arr[10];
};
...
struct foo foo;
foo = (struct foo) { .arr = {1.0, ... } };
回答by Pavel Minaev
The old-school way:
老派的方式：
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;
回答by paxdiablo
You can use:
您可以使用：
GLfloat coordinates[8] = {1.0f, ..., 0.0f};
but this is a compile-time initialisation - you can't use that method in the current standard to re-initialise (although I think there are ways to do it in the upcoming standard, which may not immediately help you).
但这是一个编译时初始化 - 您不能在当前标准中使用该方法来重新初始化（尽管我认为在即将发布的标准中可以做到这一点，但可能不会立即帮助您）。
The other two ways that spring to mind are to blat the contents if they're fixed:
浮现在脑海中的另外两种方法是在内容已修复时将其删除：
GLfloat base_coordinates[8] = {1.0f, ..., 0.0f};
GLfloat coordinates[8];
:
memcpy (coordinates, base_coordinates, sizeof (coordinates));
or provide a function that looks like your initialisation code anyway:
或者提供一个看起来像你的初始化代码的函数：
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);
keeping in mind those ellipses (...) are placeholders, not things to literally insert in the code.
请记住，那些省略号 ( ...) 是占位符，而不是真正插入代码中的东西。
回答by Felix Kling
Exactly, you nearly got it:
没错，你几乎明白了：
GLfloat coordinates[8] = {1.0f, ..., 0.0f};
回答by dpi
If you are doing these same assignments a lot in your program and want a shortcut, the most straightforward solution might be to just add a function
如果你在你的程序中做了很多相同的任务并想要一个快捷方式，最直接的解决方案可能是添加一个函数
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;
}
and then simply call
然后只需调用
GLfloat coordinates[8];
// ...
set_coordinates(coordinates, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f);
回答by Douglas Lovell
With code like this:
用这样的代码：
const int node_ct = 8;
const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };
And in the configure.ac
而在 configure.ac
AC_PROG_CC_C99
The compiler on my dev box was happy. The compiler on the server complained with:
我的开发箱上的编译器很高兴。服务器上的编译器抱怨：
error: variable-sized object may not be initialized
const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };
and
和
warning: excess elements in array initializer
const int expected[node_ct] = { 1, 3, 4, 2, 5, 6, 7, 8 };
for each element
对于每个元素
It doesn't complain at all about, for example:
它根本没有抱怨，例如：
int expected[] = { 1, 2, 3, 4, 5 };
however, I decided that I like the check on size.
然而，我决定我喜欢尺寸检查。
Rather than fighting, I went with a varargs initializer:
我没有打架，而是使用了可变参数初始化程序：
#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);
}
called like,
被称为，
const int node_ct = 8;
int expected[node_ct];
int_array_init(expected, node_ct, 1, 3, 4, 2, 5, 6, 7, 8);
As such, the varargs support is more robust than the support for the array initializer.
因此，可变参数支持比对数组初始值设定项的支持更健壮。
Someone might be able to do something like this in a macro.
有人可能能够在宏中做这样的事情。
Find PR with sample code at https://github.com/wbreeze/davenport/pull/15/files
在https://github.com/wbreeze/davenport/pull/15/files找到带有示例代码的 PR
Regarding https://stackoverflow.com/a/3535455/608359from @paxdiablo, I liked it; but, felt insecure about having the number of times the initializaion pointer advances synchronized with the number of elements allocated to the array. Worst case, the initializing pointer moves beyond the allocated length. As such, the diff in the PR contains,
关于@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);
The int_array_initmethod will safely assign junk if the number of
arguments is fewer than the node_ct. The junk assignment ought to be easier
to catch and debug.
int_array_init如果参数数量少于 node_ct，该方法将安全地分配垃圾。垃圾分配应该更容易捕获和调试。
回答by Marek
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;
}
