inicializando una matriz de enteros

¿Alguien tiene una forma de inicializar una matriz de int s (cualquier tipo de multibyte está realmente bien), a un valor distinto de cero y no -1 simplemente? Con lo que quiero decir, ¿hay alguna manera de hacer esto en un trazador de líneas, sin tener que hacer cada elemento individualmente?

 int arr[30] = {1, 1, 1, 1, ...}; // that works, but takes too long to type int arr[30] = {1}; // nope, that gives 1, 0, 0, 0, ... int arr[30]; memset(arr, 1, sizeof(arr)); // That doesn't work correctly for arrays with multi-byte // types such as int 

Solo FYI, el uso de memset() de esta manera en arreglos estáticos da:

 arr[0] = 0x01010101 arr[1] = 0x01010101 arr[2] = 0x01010101 

La otra opción:

 for(count = 0; count < 30; count++) arr[count] = 1; // Yup, that does it, but it's two lines. 

Alguien tiene otras ideas? Siempre que sea código C, no hay límites en la solución. (otras librerías están bien)

Esta es una extensión de GCC:

 int a[100] = {[0 ... 99] = 1}; 
 for (count = 0; count < 30; count++) arr[count] = 1; 

Una línea. 🙂

Dijiste algo sobre 2 líneas, pero puedes hacerlo en una línea usando coma , operador.

 for(count = 0; count < 30 ; arr[count] = 1,count++); 

La única forma sensata de hacer esto durante la inicialización (en lugar del tiempo de ejecución) parece ser:

 #define ONE1 1 #define FIVE1 ONE1, ONE1, ONE1, ONE1, ONE1 #define TEN1 FIVE1, FIVE1 #define TWENTY1 TEN1, TEN1 #define FIFTY1 TWENTY1, TWENTY1, TEN1 #define HUNDRED1 FIFTY1, FIFTY1 int array [100][4] = { HUNDRED1, HUNDRED1, HUNDRED1, HUNDRED1 }; 

Y luego, #define ONE2 2 y así sucesivamente. Entiendes la idea.

EDIT: la razón por la que escribí tantas macros fue para demostrar cuán flexible es esta solución. Para este caso particular, no los necesita a todos. Pero con macros como estas puede escribir cualquier tipo de lista de inicializadores de una manera rápida y flexible:

 { FIFTY1, FIFTY2, // 1,1,1,1... 50 times, then 2,2,2,2... 50 times TWENTY3, EIGHTY4 // 3,3,3,3... 20 times, then 4,4,4,4... 80 times ... // and so on }; 

En C, normalmente desarrolla su propia “biblioteca de soporte” con macros como

 #define SET_ALL(a_, n_, v_)\ do { size_t i, n = (n_); for (i = 0; i < n; ++i) (a_)[i] = (v_); } while(0) #define SET_ALL_A(a_, v_) SET_ALL(a_, sizeof(a_) / sizeof *(a_), v_) #define ZERO_ALL(a_, n_) SET_ALL(a_, n_, 0) #define ZERO_ALL_A(a_) SET_ALL_A(a_, 0) 

y luego usarlos en tu código como

 int arr[30]; SET_ALL_A(arr, 1); 

Una línea con punteros!

 for (int *p = a; p < (a + 30); p++) *p = 1; 

O si tiene miedo prematuro al golpe de rendimiento causado por el cálculo repetido (a + 30) :

 for (int *p = a + 30 - 1; p >= a; p--) *p = 1; 

Para la inicialización a un valor estático, generalmente he considerado que es preferible tipearlo, como en:

 int arr[30] = {1, 1, 1, 1, ...}; 

En este caso, el comstackdor puede (y usualmente lo hace) escupir una inicialización optimizada en el código de preámbulo.

A veces, la inicialización es más dinámica, como en este ejemplo:

 int arr[30]; int x = fetchSomeValue(); for(int i=0; i<30; i++) arr[i] = x; 

En estos casos, debe codificarlo y la regla general es maximizar la legibilidad, no minimizar la escritura. Este código se escribirá una vez y se leerá una multitud de veces.