Comment la fonction Memset est utilisée

En C, la fonction memset() est utilisée pour définir une valeur d'un octet sur un bloc mémoire octet par octet. Cette fonction est utile pour l'initialisation d'un bloc mémoire octet par octet par une valeur particulière. Dans cet article, nous verrons en détail comment cette fonction peut être utilisée. Alors, commençons.

En tête de fichier:

chaîne.h

Syntaxe:

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

Cette fonction définit le premier m octets du bloc mémoire pointé par str par ch.

Arguments:

La fonction prend 3 arguments :

str: C'est le pointeur de l'emplacement mémoire où la mémoire sera définie. Ceci est un pointeur vide, nous pouvons donc définir n'importe quel type de bloc mémoire, mais la mémoire sera définie octet par octet.
ch: C'est la valeur qui doit être copiée dans le bloc mémoire. Il s'agit d'une valeur entière, mais elle est convertie en un caractère non signé avant d'être copié.
m: C'est le nombre d'octets dans le bloc mémoire qui est défini.

Valeurs de retour :

memset() renvoie la première adresse du bloc mémoire à partir de laquelle il commence à définir la valeur.

Exemples:

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

//Exemple 1.c
#inclure
#inclure
int main()

char str[30] = "ABCD EFGH" ;
printf("Avant memset => %s",str);
memset(str,'x',3) ;
printf("\nAprès memset => %s\n",str);
renvoie 0 ;

Dans Exemple1.c, nous avons déclaré un tableau de caractères de taille 30. Ensuite, nous l'avons initialisé avec la chaîne "ABCD EFGH.” Dans la fonction memset, nous avons passé 3 arguments str, 'x' et 3. Ainsi, le bloc mémoire pointé par str sera réinitialisé les 3 premiers caractères par 'x.' Après memset, lorsque nous imprimons la mémoire, nous obtiendrons « xxxD EFGH."

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

//Exemple2.c
#inclure
#inclure
int main()

char str[30] = "ABCD EFGH" ;
printf("Avant memset => %s",str);
memset(str+4,'x',3) ;
printf("\nAprès memset => %s\n",str);
renvoie 0 ;

Dans Exemple2.c, nous avons passé str+4 à la fonction memset. Donc, il réinitialise la mémoire après le 4ème emplacement de str. Après memset, lorsque nous imprimons la mémoire, nous obtiendrons « ABCDxxxGH."

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

// Exemple3.c
#inclure
#inclure
int main()

int arr[5],i;
memset(arr,10,5*sizeof(arr[0]));
printf("\narr Éléments => \n");
pour(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
renvoie 0 ;

Dans l'exemple3.c, nous avons déclaré un tableau d'entiers de taille 5 et essayé de l'initialiser par 10. Mais à partir de la sortie, nous avons vu que le tableau n'est pas initialisé par 10 ; à la place, nous avons la valeur "168430090". En effet, la valeur entière est supérieure à un octet et la fonction memset convertit la valeur en un caractère non signé avant de la copier. Maintenant, nous allons voir comment nous obtiendrons la valeur « 168430090 ».

La représentation binaire de 10 est 00000000 00000000 00000000 00001010.

Lorsque l'entier est converti en caractère non signé, l'octet inférieur est pris en compte. Ainsi, lorsque 10 est converti en caractère non signé, c'est une représentation binaire est 00001010.

La fonction memset() définit l'emplacement mémoire octet par octet. Ainsi, un total de 4 octets sera : 00001010 00001010 00001010 00001010.

La valeur décimale de la représentation binaire de 4 octets est 168430090.

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

// Exemple4.c
#inclure
#inclure
int main()

int arr[5],i;
memset(arr,0,5*sizeof(arr[0]));
printf("\narr Éléments => \n");
pour(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
renvoie 0 ;

Dans l'exemple4.c, nous avons initialisé le tableau d'entiers par 0. Tous les bits de la représentation binaire de 0 sont 0. Donc le tableau est initialisé par 0.

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

// Exemple5.c
#inclure
#inclure
int main()

int arr[5],i;
memset(arr,-1,5*sizeof(arr[0]));
printf("\narr Éléments => \n");
pour(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
renvoie 0 ;

Dans l'exemple5.c, nous avons initialisé le tableau d'entiers par 0. Tous les bits de la représentation binaire de -1 sont 1. Donc le tableau est initialisé par -1.

Conclusion:

Dans cet article, nous avons vu en utilisant la fonction memset comment nous pouvons initialiser ou définir la valeur d'un bloc de mémoire efficacement. Nous pouvons définir n'importe quel caractère et 0 ou -1 comme valeur entière dans un bloc de mémoire. La fonction Memset est plus rapide pour définir une grande partie de la mémoire contiguë par rapport à la simple définition de l'emplacement à l'aide d'une boucle.