Como a função Memset é usada

Em C, a função memset () é usada para definir um valor de um byte para um bloco de memória byte a byte. Esta função é útil para a inicialização de um bloco de memória byte a byte por um valor particular. Neste artigo, veremos em detalhes como essa função pode ser usada. Então vamos começar.

Arquivo de cabeçalho:

1	fragmento.h

Sintaxe:

1	void * memset (void * str, int ch, size_t n)

Esta função define o primeiro n bytes do bloco de memória apontado por str de CH.

Argumentos:

A função leva 3 argumentos:

str: Este é o ponteiro do local da memória onde a memória será configurada. Este é um ponteiro vazio, então podemos definir qualquer tipo de bloco de memória, mas a memória será definida byte a byte.
CH: Este é o valor que deve ser copiado para o bloco de memória. Este é um valor inteiro, mas é convertido em um caractere sem sinal antes de ser copiado.
n: Este é o número de bytes no bloco de memória que é definido.

Valores de retorno:

memset () retorna o primeiro endereço do bloco de memória de onde começa para definir o valor.

Exemplos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//Exemplo 1.c
#incluir
#incluir
int main ()

char str [30] = "ABCD EFGH";
printf ("Antes do memset =>% s", str);
memset (str, 'x', 3);
printf ("\ nApós memset =>% s \ n", str);
return 0;

No Exemplo 1.c, declaramos uma matriz de caracteres de tamanho 30. Então, nós o inicializamos com a string “ABCD EFGH.”Na função memset, passamos 3 argumentos str, 'x' e 3. Então, o bloco de memória apontado por str será reiniciado os primeiros 3 caracteres por 'x.'Após o memset, quando imprimirmos a memória, obteremos “xxxD EFGH.”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Exemplo2.c
#incluir
#incluir
int main ()

char str [30] = "ABCD EFGH";
printf ("Antes do memset =>% s", str);
memset (str + 4, 'x', 3);
printf ("\ nApós memset =>% s \ n", str);
return 0;

No Exemplo 2.c, passamos str + 4 para a função memset. Então, ele redefiniu a memória após a 4ª localização de str. Após o memset, quando imprimirmos a memória, obteremos “ABCDxxxGH.”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Exemplo3.c
#incluir
#incluir
int main ()

int arr [5], i;
memset (arr, 10,5 * sizeof (arr [0]));
printf ("\ elementos narr => \ n");
para (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
return 0;

No Exemplo 3.c, declaramos um array inteiro de tamanho 5 e tentamos inicializá-lo em 10. Mas, pela saída, vimos que o array não é inicializado por 10; em vez disso, temos o valor “168430090”. Isso ocorre porque o valor inteiro é maior que um byte e a função memset converte o valor em um caractere sem sinal antes de copiado. Agora, veremos como obteremos o valor “168430090”.

A representação binária de 10 é 00000000 00000000 00000000 00001010.

Quando inteiro convertido em unsigned char, o 1 byte inferior é considerado. Então, quando 10 é convertido para unsigned char, é uma representação binária é 00001010.

A função memset () define a localização da memória byte a byte. Portanto, um total de 4 bytes será: 00001010 00001010 00001010 00001010.

O valor decimal da representação binária de 4 bytes é 168430090.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Exemplo4.c
#incluir
#incluir
int main ()

int arr [5], i;
memset (arr, 0,5 * sizeof (arr [0]));
printf ("\ elementos narr => \ n");
para (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
return 0;

No Exemplo 4.c, inicializamos a matriz de inteiros em 0. Todos os bits da representação binária de 0 são 0. Portanto, a matriz é inicializada por 0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Exemplo 5.c
#incluir
#incluir
int main ()

int arr [5], i;
memset (arr, -1,5 * sizeof (arr [0]));
printf ("\ elementos narr => \ n");
para (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
return 0;

No Exemplo 5.c, inicializamos a matriz de inteiros em 0. Todos os bits da representação binária de -1 é 1. Portanto, a matriz é inicializada por -1.

Conclusão:

Neste artigo, vimos usando a função memset como podemos inicializar ou definir o valor de um bloco de memória de forma eficiente. Podemos definir qualquer caractere e 0 ou -1 como um valor inteiro para um bloco de memória. A função Memset é mais rápida para definir um grande pedaço de memória contígua em comparação com simplesmente definir a localização usando um loop.