Quelle est l'utilité de la fonction memset()
?.
Définition : définit le premier nombre d'octets du bloc de mémoire pointé par ptr sur le. valeur spécifiée (interprétée comme un caractère non signé).
Cela signifie-t-il que la valeur d’une adresse mémoire est codée en dur?
memset(&serv_addr,0,sizeof(serv_addr)
est l'exemple que j'essaie de comprendre.
Quelqu'un peut-il expliquer s'il vous plaît d'une manière TRÈS simplifiée?
memset()
est une version très rapide d’une opération relativement simple:
void* memset(void* b, int c, size_t len) {
char* p = (char*)b;
for (size_t i = 0; i != len; ++i) {
p[i] = c;
}
return b;
}
C'est-à-dire que memset(b, c, l)
définit les l
octets commençant à l'adresse b
à la valeur c
. Il le fait simplement beaucoup plus rapidement que dans la mise en œuvre ci-dessus.
memset()
est généralement utilisé pour initialiser des valeurs. Par exemple, considérons la structure suivante:
struct Size {
int width;
int height;
}
Si vous en créez un sur la pile, procédez comme suit:
struct Size someSize;
Ensuite, les valeurs dans cette structure vont être indéfinies. Elles peuvent être nulles, quelles que soient les valeurs trouvées depuis la dernière utilisation de cette partie de la pile. Donc, généralement, vous suivriez cette ligne avec:
memset(&someSize, 0, sizeof(someSize));
Bien sûr, il peut être utilisé pour d'autres scénarios, il ne s'agit que de l'un d'entre eux. Pensez-y simplement comme un moyen de définir simplement une partie de la mémoire à une certaine valeur.
memset
est un moyen courant de définir une région de mémoire sur 0 quel que soit le type de données. On peut dire que memset
ne se soucie pas du type de données et met tous les octets à zéro.
IMHO en C++, il faut éviter de faire memset
lorsque cela est possible, car cela contourne le type de sécurité fourni par C++, mais plutôt le constructeur ou l'initialisation comme moyen d'initialisation. memset fait sur une instance de classe peut aussi détruire quelque chose involontairement:
par exemple.
class A
{
public:
shared_ptr<char*> _p;
};
une memset
sur une instance de ce qui précède ne ferait pas un décrément de compteur de référence correctement.
Je suppose que serv_addr
est une variable locale ou globale d’un type struct
-perhaps struct sockaddr
- (ou peut-être une class
).
&serv_addr
prend l'adresse de cette variable. C'est une adresse valide, donnée en premier argument à memset
. Le deuxième argument de memset
est l'octet à utiliser pour le remplissage (zéro octet). Le dernier argument de memset
est la taille, en octets, de cette zone mémoire à remplir, qui correspond à la taille de cette variable serv_addr
dans votre exemple.
Donc, cet appel à memset
efface une variable globale ou locale serv_addr
contenant une struct
.
En pratique, le compilateur GCC, lorsqu’il optimise, générera un code intelligent pour cela, le déroulant et l’alignant en ligne (en fait, il s’agit souvent d’une commande intégrée, donc GCC peut générer très code intelligent pour cela).
Ce n'est rien d'autre que mettre la mémoire à une valeur particulière.
Voici un exemple de code.
Memset (const * p, unit8_t V, unit8_t L), ici le P est le pointeur sur la mémoire cible, V est la valeur du tampon cible qui sera définie sur V et l est la longueur des données.
while(L --> 0)
{
*p++ = V;
}
memset - définir des octets en mémoire
Synopsis-
#include<string.h>
void * memset (void * s, int c, size_t n)
Description- La fonction memset () doit copier c (converti en caractère non signé) dans chacun des n premiers octets de l'objet pointé par s. Ici, pour la fonction ci-dessus, memset () doit renvoyer la valeur s.