我知道最初的问题明确地提到了C而不是c++，但如果你(像我一样)来这里寻找c++数组的解决方案，这里有一个巧妙的技巧:

如果你的编译器支持fold表达式，你可以使用template magic和std::index_sequence生成一个包含你想要的值的初始化列表。你甚至可以把它想象成一个老板:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

您可以查看工作中的代码(在Wandbox中)

在过去(我并不是说这是个好主意)，我们设置了第一个元素，然后:

Memcpy (&element [1]， &element [0]， sizeof (element)-sizeof (element [0]);

甚至不确定它是否还能工作(这将取决于memcpy的实现)，但它通过重复地将初始元素复制到下一个元素来工作-甚至对结构数组也有效。

你可以像上面详细描述的那样做整个静态初始化器的事情，但是当你的数组大小发生变化时(当你的数组变大时，如果你没有添加适当的额外初始化器，你就会得到垃圾)，这可能是一个真正的麻烦。

Memset为您的工作提供了一个运行时命中，但是任何正确的代码大小命中都不受数组大小变化的影响。当数组大于几十个元素时，我几乎在所有情况下都会使用这个解决方案。

如果静态声明数组真的很重要，我会写一个程序来为我编写程序，并使其成为构建过程的一部分。

对于初始化“普通”数据类型(如int数组)，你可以使用括号符号，但如果数组中仍有空格，它将把最后一个后面的值归零:

// put values 1-8, then two zeroes
int list[10] = {1,2,3,4,5,6,7,8};

我知道最初的问题明确地提到了C而不是c++，但如果你(像我一样)来这里寻找c++数组的解决方案，这里有一个巧妙的技巧:

如果你的编译器支持fold表达式，你可以使用template magic和std::index_sequence生成一个包含你想要的值的初始化列表。你甚至可以把它想象成一个老板:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

您可以查看工作中的代码(在Wandbox中)

这里有另一种方法:

static void
unhandled_interrupt(struct trap_frame *frame, int irq, void *arg)
{
    //this code intentionally left blank
}

static struct irqtbl_s vector_tbl[XCHAL_NUM_INTERRUPTS] = {
    [0 ... XCHAL_NUM_INTERRUPTS-1] {unhandled_interrupt, NULL},
};

See:

c扩展

指定的初始化

然后问这个问题:什么时候可以使用C扩展?

上面的代码示例是在嵌入式系统中，永远不会从其他编译器中看到。