方法一:

int a[5] = {3,3,3,3,3}; 

形式化初始化技术。

方法二:

int a[100] = {0};

但值得注意的是

int a[10] = {1}; 

不将所有值初始化为1

这种方法只对0进行初始化

如果你这样做

int a[100];

一些编译器倾向于接受垃圾值，因此它总是首选这样做

int a[1000] = {0};

对于延迟初始化(即类成员构造函数初始化)，请考虑:

int a[4];

unsigned int size = sizeof(a) / sizeof(a[0]);
for (unsigned int i = 0; i < size; i++)
  a[i] = 0;

作为Clemens Sielaff回答的后续。这个版本需要c++ 17。

template <size_t Cnt, typename T>                                               
std::array<T, Cnt> make_array_of(const T& v)                                           
{                                                                               
    return []<size_t... Idx>(std::index_sequence<Idx...>, const auto& v)        
    {                                                                           
        auto identity = [](const auto& v, size_t) { return v; };                
        return std::array{identity(v, Idx)...};                                 
    }                                                                           
    (std::make_index_sequence<Cnt>{}, v);                                       
}

你可以在这里看到它的作用。

略带开玩笑的回答;写语句

array = initial_value

用你最喜欢的支持数组的语言(我的是Fortran，但还有很多其他语言)，并将它链接到你的C代码。你可能想把它包装成一个外部函数。

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

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

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

我知道最初的问题明确地提到了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中)