我在这个问题中没有看到任何要求，所以解决方案必须是通用的:初始化一个未指定的可能是多维数组，由一个初始成员值的未指定的可能是结构元素构建:

#include <string.h> 

void array_init( void *start, size_t element_size, size_t elements, void *initval ){
  memcpy(        start,              initval, element_size              );
  memcpy( (char*)start+element_size, start,   element_size*(elements-1) );
}

// testing
#include <stdio.h> 

struct s {
  int a;
  char b;
} array[2][3], init;

int main(){
  init = (struct s){.a = 3, .b = 'x'};
  array_init( array, sizeof(array[0][0]), 2*3, &init );

  for( int i=0; i<2; i++ )
    for( int j=0; j<3; j++ )
      printf("array[%i][%i].a = %i .b = '%c'\n",i,j,array[i][j].a,array[i][j].b);
}

结果:

array[0][0].a = 3 .b = 'x'
array[0][1].a = 3 .b = 'x'
array[0][2].a = 3 .b = 'x'
array[1][0].a = 3 .b = 'x'
array[1][1].a = 3 .b = 'x'
array[1][2].a = 3 .b = 'x'

编辑:start+element_size更改为(char*)start+element_size

除非该值为0(在这种情况下，可以省略初始化式的某些部分 并且相应的元素将被初始化为0)，没有简单的方法。

不过，不要忽视显而易见的解决方案:

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

缺少值的元素将初始化为0:

int myArray[10] = { 1, 2 }; // initialize to 1,2,0,0,0...

所以这将把所有元素初始化为0:

int myArray[10] = { 0 }; // all elements 0

在c++中，空初始化列表也会将每个元素初始化为0。 C在C23之前是不允许的:

int myArray[10] = {}; // all elements 0 in C++ and C23

记住，如果没有，具有静态存储持续时间的对象将初始化为0 初始化式被指定:

static int myArray[10]; // all elements 0

而“0”并不一定意味着“全位零”，所以使用上面的是 比memset()更好、更可移植。(浮点值将是 初始化为+0，指向空值，等等)

我知道用户Tarski以类似的方式回答了这个问题，但我添加了更多细节。请原谅我的一些C语言，因为我对它有点生疏，因为我更倾向于使用c++，但它就在这里。

如果你提前知道数组的大小……

#include <stdio.h>

typedef const unsigned int cUINT;
typedef unsigned int UINT;

cUINT size = 10;
cUINT initVal = 5;

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal );
void printArray( UINT* myArray ); 

int main() {        
    UINT myArray[size]; 
    /* Not initialized during declaration but can be
    initialized using a function for the appropriate TYPE*/
    arrayInitializer( myArray, size, initVal );

    printArray( myArray );

    return 0;
}

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal ) {
    for ( UINT n = 0; n < size; n++ ) {
        myArray[n] = initVal;
    }
}

void printArray( UINT* myArray ) {
    printf( "myArray = { " );
    for ( UINT n = 0; n < size; n++ ) {
        printf( "%u", myArray[n] );

        if ( n < size-1 )
            printf( ", " );
    }
    printf( " }\n" );
}

上面有一些注意事项;一个是UINT myArray[size];声明时不会直接初始化，但是下一个代码块或函数调用确实会将数组的每个元素初始化为所需的相同值。另一个注意事项是，您必须为将要支持的每种类型编写初始化函数，并且还必须修改printArray()函数以支持这些类型。

您可以使用这里找到的在线编译器尝试此代码。

如果数组声明为静态或全局，则所有元素 在数组中已经有默认默认值0。 一些编译器在调试模式中将array的默认值设置为0。 将默认值设置为0很容易: Int数组[10]= {0}; 但是，对于其他值，您必须使用memset()或loop;

例子: int数组[10]; Memset(数组，- 1,10 *sizeof(int));

#include<stdio.h>
int main(){
int i,a[50];
for (i=0;i<50;i++){
    a[i]=5;// set value 5 to all the array index
}
for (i=0;i<50;i++)
printf("%d\n",a[i]);
   return 0;
}

它将给o/p 5 5 5 5 5 5 ......直到整个数组的大小

作为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);                                       
}

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