¿Cómo inicializar todos los miembros de una matriz al mismo valor?

Tengo una gran matriz en C (no C ++ si eso hace la diferencia). Quiero inicializar a todos los miembros del mismo valor.

Podría jurar que una vez conocí una manera simple de hacer esto. Podría usar memset()en mi caso, pero ¿no hay una manera de hacer esto que esté integrada en la sintaxis de C?

A menos que ese valor sea 0 (en cuyo caso puede omitir alguna parte del inicializador y los elementos correspondientes se inicializarán a 0), no hay una manera fácil.

Sin embargo, no pase por alto la solución obvia:

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

Los elementos con valores faltantes se inicializarán a 0:

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

Entonces esto inicializará todos los elementos a 0:

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

En C ++, una lista de inicialización vacía también inicializará cada elemento a 0. Esto no está permitido con C:

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

Recuerde que los objetos con una duración de almacenamiento estático se inicializarán a 0 si no se especifica ningún inicializador:

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

Y ese "0" no necesariamente significa "todos los bits cero", por lo que usar lo anterior es mejor y más portátil que memset (). (Los valores de coma flotante se inicializarán a +0, los punteros a valor nulo, etc.)

Si su compilador es GCC, puede usar la siguiente sintaxis:

int array[1024] = {[0 ... 1023] = 5};

Consulte la descripción detallada: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html

Para inicializar estáticamente una matriz grande con el mismo valor, sin copiar y pegar múltiples, puede usar macros:

#define VAL_1X     42
#define VAL_2X     VAL_1X,  VAL_1X
#define VAL_4X     VAL_2X,  VAL_2X
#define VAL_8X     VAL_4X,  VAL_4X
#define VAL_16X    VAL_8X,  VAL_8X
#define VAL_32X    VAL_16X, VAL_16X
#define VAL_64X    VAL_32X, VAL_32X

int myArray[53] = { VAL_32X, VAL_16X, VAL_4X, VAL_1X };

Si necesita cambiar el valor, debe hacer el reemplazo en un solo lugar.

Editar: posibles extensiones útiles

(cortesía de Jonathan Leffler )

Puede generalizar esto fácilmente con:

#define VAL_1(X) X
#define VAL_2(X) VAL_1(X), VAL_1(X)
/* etc. */

Se puede crear una variante usando:

#define STRUCTVAL_1(...) { __VA_ARGS__ }
#define STRUCTVAL_2(...) STRUCTVAL_1(__VA_ARGS__), STRUCTVAL_1(__VA_ARGS__)
/*etc */ 

que funciona con estructuras o matrices compuestas.

#define STRUCTVAL_48(...) STRUCTVAL_32(__VA_ARGS__), STRUCTVAL_16(__VA_ARGS__)

struct Pair { char key[16]; char val[32]; };
struct Pair p_data[] = { STRUCTVAL_48("Key", "Value") };
int a_data[][4] = { STRUCTVAL_48(12, 19, 23, 37) };

Los nombres de las macros son negociables.

Si desea asegurarse de que cada miembro de la matriz se inicialice explícitamente, simplemente omita la dimensión de la declaración:

int myArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

El compilador deducirá la dimensión de la lista de inicializadores. Desafortunadamente, para las matrices multidimensionales solo se puede omitir la dimensión más externa:

int myPoints[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

está bien, pero

int myPoints[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

no es.

Vi un código que usaba esta sintaxis:

char* array[] = 
{
    [0] = "Hello",
    [1] = "World"
};   

Donde se vuelve particularmente útil es si está haciendo una matriz que utiliza enumeraciones como índice:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

#define _ITEM(x) [x] = #x

char* array[] = 
{
    _ITEM(ERR_OK),
    _ITEM(ERR_FAIL),
    _ITEM(ERR_MEMORY)
};   

Esto mantiene las cosas en orden, incluso si usted escribe algunos de los valores de enumeración fuera de orden.

Puede encontrar más información sobre esta técnica aquí y aquí .

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

Creo que esto es mejor que

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

en caso de que cambie el tamaño de la matriz.

Puede hacer todo lo relacionado con el inicializador estático como se detalla anteriormente, pero puede ser un verdadero fastidio cuando cambia el tamaño de su matriz (cuando su matriz se embebe, si no agrega los inicializadores adicionales apropiados, obtiene basura).

memset le proporciona un tiempo de ejecución correcto para hacer el trabajo, pero ningún resultado de tamaño de código realizado correctamente es inmune a los cambios de tamaño de la matriz. Usaría esta solución en casi todos los casos cuando la matriz fuera más grande que, digamos, unas pocas docenas de elementos.

Si fuera realmente importante que la matriz se declarara estáticamente, escribiría un programa para escribir el programa por mí y hacerlo parte del proceso de compilación.

Aquí hay otra forma:

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},
};

Ver:

Extensiones C

Inits designados

Luego haga la pregunta: ¿Cuándo se pueden usar extensiones C?

El ejemplo de código anterior está en un sistema integrado y nunca verá la luz de otro compilador.

Para inicializar los tipos de datos 'normales' (como las matrices int), puede usar la notación de paréntesis, pero pondrá a cero los valores después de la última si todavía hay espacio en la matriz:

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

Si la matriz resulta ser int o algo con el tamaño de int o el tamaño de su patrón de memoria se ajusta a tiempos exactos en un int (es decir, todos los ceros o 0xA5A5A5A5), la mejor manera es usar memset () .

De lo contrario, llame a memcpy () en un bucle que mueve el índice.

Una respuesta ligeramente irónica; escribe la declaración

array = initial_value

en su lenguaje favorito con capacidad de matriz (el mío es Fortran, pero hay muchos otros), y vincúlelo a su código C. Probablemente quieras envolverlo para que sea una función externa.

Hay una forma rápida de inicializar una matriz de cualquier tipo con un valor dado. Funciona muy bien con matrices grandes. El algoritmo es el siguiente:

• inicializar el primer elemento de la matriz (forma habitual)
• copiar parte que se ha configurado en una parte que no se ha configurado, duplicando el tamaño con cada operación de copia siguiente

Para la matriz de 1 000 000elementos int, es 4 veces más rápido que la inicialización de bucle normal (i5, 2 núcleos, 2.3 GHz, memoria 4GiB, 64 bits):

loop runtime 0.004248 [seconds]

memfill() runtime 0.001085 [seconds]

#include <stdio.h>
#include <time.h>
#include <string.h>
#define ARR_SIZE 1000000

void memfill(void *dest, size_t destsize, size_t elemsize) {
   char   *nextdest = (char *) dest + elemsize;
   size_t movesize, donesize = elemsize;

   destsize -= elemsize;
   while (destsize) {
      movesize = (donesize < destsize) ? donesize : destsize;
      memcpy(nextdest, dest, movesize);
      nextdest += movesize; destsize -= movesize; donesize += movesize;
   }
}    
int main() {
    clock_t timeStart;
    double  runTime;
    int     i, a[ARR_SIZE];

    timeStart = clock();
    for (i = 0; i < ARR_SIZE; i++)
        a[i] = 9;    
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("loop runtime %f [seconds]\n",runTime);

    timeStart = clock();
    a[0] = 10;
    memfill(a, sizeof(a), sizeof(a[0]));
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("memfill() runtime %f [seconds]\n",runTime);
    return 0;
}

Nadie ha mencionado el orden del índice para acceder a los elementos de la matriz inicializada. Mi código de ejemplo le dará un ejemplo ilustrativo.

#include <iostream>

void PrintArray(int a[3][3])
{
    std::cout << "a11 = " << a[0][0] << "\t\t" << "a12 = " << a[0][1] << "\t\t" << "a13 = " << a[0][2] << std::endl;
    std::cout << "a21 = " << a[1][0] << "\t\t" << "a22 = " << a[1][1] << "\t\t" << "a23 = " << a[1][2] << std::endl;
    std::cout << "a31 = " << a[2][0] << "\t\t" << "a32 = " << a[2][1] << "\t\t" << "a33 = " << a[2][2] << std::endl;
    std::cout << std::endl;
}

int wmain(int argc, wchar_t * argv[])
{
    int a1[3][3] =  {   11,     12,     13,     // The most
                        21,     22,     23,     // basic
                        31,     32,     33  };  // format.

    int a2[][3] =   {   11,     12,     13,     // The first (outer) dimension
                        21,     22,     23,     // may be omitted. The compiler
                        31,     32,     33  };  // will automatically deduce it.

    int a3[3][3] =  {   {11,    12,     13},    // The elements of each
                        {21,    22,     23},    // second (inner) dimension
                        {31,    32,     33} };  // can be grouped together.

    int a4[][3] =   {   {11,    12,     13},    // Again, the first dimension
                        {21,    22,     23},    // can be omitted when the 
                        {31,    32,     33} };  // inner elements are grouped.

    PrintArray(a1);
    PrintArray(a2);
    PrintArray(a3);
    PrintArray(a4);

    // This part shows in which order the elements are stored in the memory.
    int * b = (int *) a1;   // The output is the same for the all four arrays.
    for (int i=0; i<9; i++)
    {
        std::cout << b[i] << '\t';
    }

    return 0;
}

El resultado es:

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

11      12      13      21      22      23      31      32      33

Cortando toda la charla, la respuesta corta es que si activa la optimización en tiempo de compilación, no lo hará mejor que esto:

int i,value=5,array[1000]; 
for(i=0;i<1000;i++) array[i]=value; 

Bonificación adicional: el código es realmente legible :)

1. Si su matriz se declara como estática o es global, todos los elementos en la matriz ya tienen el valor predeterminado predeterminado 0.
2. Algunos compiladores establecen la matriz predeterminada en 0 en modo de depuración.
3. Es fácil establecer el valor predeterminado en 0: int array [10] = {0};
4. Sin embargo, para otros valores, debe usar memset () o loop;

ejemplo: int array [10]; memset (matriz, -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;
}

Dará la o / p 5 5 5 5 5 5 ...... hasta el tamaño de toda la matriz

Sé que el usuario Tarskirespondió a esta pregunta de manera similar, pero agregué algunos detalles más. Perdona parte de mi C porque estoy un poco oxidado porque estoy más inclinado a querer usar C ++, pero aquí está.

Si conoce el tamaño de la matriz con anticipación ...

#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" );
}

Hay algunas advertencias arriba; uno es que UINT myArray[size];no se inicializa directamente después de la declaración, sin embargo, el siguiente bloque de código o llamada de función inicializa cada elemento de la matriz al mismo valor que desea. La otra advertencia es que tendrías que escribir una initializing functionpara cada una de las typeque admitirás y también deberías modificar la printArray()función para admitir esos tipos.

Puede probar este código con un compilador en línea que se encuentra aquí .

Para la inicialización retrasada (es decir, inicialización del constructor de miembros de clase) considere:

int a[4];

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

Sé que la pregunta original menciona explícitamente C y no C ++, pero si usted (como yo) vino aquí buscando una solución para las matrices de C ++, aquí hay un buen truco:

Si su compilador admite expresiones de plegado , puede usar la plantilla de magia y std::index_sequencegenerar una lista de inicializador con el valor que desee. Y puedes igualarlo constexpry sentirte como un jefe:

#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

Puedes echar un vistazo al código en el trabajo (en Wandbox)

No veo requisitos en la pregunta, por lo que la solución debe ser genérica: inicialización de una matriz posiblemente multidimensional no especificada construida a partir de elementos de estructura posiblemente no especificados con un valor de miembro inicial:

#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);
}

Resultado:

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'

EDITAR: start+element_sizecambiado a(char*)start+element_size

En el pasado (y no digo que sea una buena idea), configuraríamos el primer elemento y luego:

memcpy (&element [1], &element [0], sizeof (element)-sizeof (element [0]);

Ni siquiera estoy seguro de que funcionaría más (eso dependería de la implementación de memcpy) pero funciona copiando repetidamente el elemento inicial al siguiente, incluso funciona para matrices de estructuras.

Si quiere decir en paralelo, creo que el operador de coma cuando se usa junto con una expresión puede hacer eso:

a[1]=1, a[2]=2, ..., a[indexSize]; 

o si te refieres a una sola construcción, puedes hacerlo en un ciclo for:

for(int index = 0, value = 10; index < sizeof(array)/sizeof(array[0]); index++, value--)
  array[index] = index;

// Tenga en cuenta que el operador de coma en una lista de argumentos no es el operador paralelo descrito anteriormente;

Puede inicializar una declinación de matriz:

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

Puede hacer una llamada a malloc / calloc / sbrk / alloca / etc para asignar una región fija de almacenamiento a un objeto:

int *array = malloc(sizeof(int)*numberOfListElements/Indexes);

y acceder a los miembros por:

*(array + index)

Etc.