Usando memset para una matriz de enteros en c

char str[]="beautiful earth"; memset(str,'*',6); printf("%s",str); output: ******ful earth 

1) Al igual que el uso anterior de memset, ¿podemos inicializar solo algunos valores de índice de matriz de enteros a 1 como se indica a continuación?

 int arr[15]; memset(arr,1,6); 

No, no puedes usar memset() esta manera. La página del manual dice (énfasis mío):

La función memset() llena los primeros n bytes del área de memoria apuntada por s con el byte constante c .

Como un int suele ser de 4 u 8 bytes, esto no lo cortará.


Si usted ( incorrectamente !! ) intenta hacer esto:

 int arr[15]; memset(arr, 1, 6*sizeof(int)); //wrong! 

entonces los primeros 6 int s en la matriz realmente se configurarán en 0x01010101 = 16843009.

La única vez que es realmente aceptable escribir sobre un “blob” de datos con tipos de datos sin byte, es memset(thing, 0, sizeof(thing)); para “poner a cero” toda la estructura / matriz. Esto funciona porque NULL, 0x00000000, 0.0, son completamente ceros.


La solución es usar un bucle for y configurarlo usted mismo:

 int arr[15]; int i; for (i=0; i<6; ++i) // Set the first 6 elements in the array arr[i] = 1; // to the value 1. 

Respuesta corta, NO.

Respuesta larga, memset establece bytes y funciona para los caracteres porque son solo bytes, pero los enteros no lo son.

El tercer argumento de memset es el tamaño del byte. Por lo tanto, debe establecer el tamaño total de bytes de arr[15]

 memset(arr, 1, sizeof(arr)); 

Sin embargo, probablemente, debería querer establecer el valor 1 en elementos completos en arr. Entonces tienes mejor poner en el bucle.

 for (i = 0; i < sizeof(arr)/sizeof(arr[0]); i++) { arr[i] = 1; } 

Porque memset() establece 1 en cada byte. Así que no es lo que esperabas.

En Linux, OSX y otros sistemas operativos similares a UNIX, donde wchar_t es de 32 bits y puede usar wmemset() lugar de memset() .

 #include ... int arr[15]; wmemset( arr, 1, 6 ); 

Tenga en cuenta que wchar_t en MS-Windows es de 16 bits, por lo que es posible que este truco no funcione.

No, no puede [portiblemente] usar memset para ese propósito, a menos que el valor objective deseado sea 0 . memset trata la región de memoria de destino como una matriz de bytes, no como una matriz de int s.

Un truco bastante popular para rellenar una región de memoria con un patrón repetitivo en realidad se basa en memcpy . memcpy basa en la expectativa de que memcpy copia los datos en una dirección hacia adelante

 int arr[15]; arr[0] = 1; memcpy(&arr[1], &arr[0], sizeof arr - sizeof *arr); 

Esto es, por supuesto, un truco bastante feo, ya que el comportamiento de memcpy estándar memcpy está definido cuando las regiones de memoria de origen y destino se superponen. memcpy embargo, puede escribir su propia versión de memcpy , asegurándose de que memcpy datos en la dirección de avance y de usar de la manera anterior. Pero realmente no vale la pena. Simplemente use un ciclo simple para establecer los elementos de su matriz al valor deseado.

Como nadie lo mencionó …

Aunque no puede inicializar los enteros con el valor 1 utilizando memset, puede inicializarlos con el valor -1 y simplemente cambiar su lógica para que funcione con valores negativos.

Por ejemplo, para inicializar los primeros 6 números de tu matriz con -1 , harías

 memset(arr,-1,6*(sizeof int)); 

Además, si solo necesita hacer esta inicialización una vez, puede declarar que la matriz comienza con los valores 1 desde el momento de la comstackción.

 int arr[15] = {1,1,1,1,1,1}; 

Memset establece valores para los tipos de datos que tienen 1 byte pero los enteros tienen 4 bytes o más, por lo que no funcionará y obtendrá valores de basura. Se utiliza principalmente cuando se trabaja con tipos de caracteres y cadenas.

Probé el siguiente progtwig y parece que puedes inicializar tu matriz usando memset () solo con -1 y 0

 #include #include void printArray(int arr[], int len) { int i=0; for(i=0; i 

Lo ideal es que no pueda usar memset para establecer su arrary a todos 1.
Porque memset trabaja en byte y establece cada byte a 1.

 memset(hash, 1, cnt); 

Así que una vez leído, el valor mostrará 16843009 = 0x01010101 = 1000000010000000100000001
No 0x00000001
Pero si su requerimiento es solo para valor bool o binario, entonces podemos establecer el uso del estándar C99 para la biblioteca C

 #include  #include  #include  #include  //Use C99 standard for C language which supports bool variables int main() { int i, cnt = 5; bool *hash = NULL; hash = malloc(cnt); memset(hash, 1, cnt); printf("Hello, World!\n"); for(i=0; i 

Salida:

¡Hola Mundo!
1 1 1 1 1

 memset((char *)&tab, 0, sizeof(tab));