strdup () - que fait-il en C?

Quel est le but de la strdup()fonction en C?

Exactement ce à quoi cela ressemble, en supposant que vous êtes habitué à la façon abrégée dont C et UNIX attribuent les mots, il duplique les chaînes :-)

En gardant à l'esprit que cela ne fait pas partie de la norme ISO C elle-même ^(a) (c'est une chose POSIX), cela fait en fait la même chose que le code suivant:

char *strdup(const char *src) {
    char *dst = malloc(strlen (src) + 1);  // Space for length plus nul
    if (dst == NULL) return NULL;          // No memory
    strcpy(dst, src);                      // Copy the characters
    return dst;                            // Return the new string
}

En d'autres termes:

1. Il essaie d'allouer suffisamment de mémoire pour contenir l'ancienne chaîne (plus un caractère «\ 0» pour marquer la fin de la chaîne).

2. Si l'allocation échoue, il met errnoà ENOMEMet retourne NULLimmédiatement. La définition de errnoto ENOMEMest quelque chose qui se mallocfait dans POSIX, nous n'avons donc pas besoin de le faire explicitement dans notre strdup. Si vous n'êtes pas conforme à POSIX, ISO C n'exige pas réellement l'existence de ENOMEMdonc je ne l'ai pas inclus ici ^(b) .

3. Sinon, l'allocation a fonctionné, nous copions donc l'ancienne chaîne dans la nouvelle chaîne ^(c) et renvoyons la nouvelle adresse (que l'appelant est responsable de libérer à un moment donné).

Gardez à l'esprit que c'est la définition conceptuelle. Tout écrivain de bibliothèque digne de ce nom peut avoir fourni un code fortement optimisé ciblant le processeur particulier utilisé.

^(a) Cependant, les fonctions commençant par stret une lettre minuscule sont réservées par la norme pour les directions futures. De C11 7.1.3 Reserved identifiers:

Chaque en-tête déclare ou définit tous les identificateurs répertoriés dans sa sous-clause associée, et * déclare ou définit facultativement les identificateurs répertoriés dans sa future sous-clause de directions de bibliothèque associées. **

Les orientations futures pour string.hse trouvent dans C11 7.31.13 String handling <string.h>:

Les noms de fonctions commençant par str, memou wcset une lettre minuscule peuvent être ajoutés aux déclarations dans l'en- <string.h>tête.

Donc, vous devriez probablement l'appeler autrement si vous voulez être en sécurité.

^(b) Le changement serait essentiellement remplacé if (d == NULL) return NULL;par:

if (d == NULL) {
    errno = ENOMEM;
    return NULL;
}

^(c) Notez que j'utilise strcpypour cela car cela montre clairement l'intention. Dans certaines implémentations, il peut être plus rapide (car vous connaissez déjà la longueur) à utiliser memcpy, car ils peuvent permettre de transférer les données en plus gros morceaux, ou en parallèle. Ou ce n'est peut-être pas le cas :-) Mantra d'optimisation # 1: "mesurer, ne pas deviner".

Dans tous les cas, si vous décidez de suivre cette voie, vous feriez quelque chose comme:

char *strdup(const char *src) {
    size_t len = strlen(src) + 1;       // String plus '\0'
    char *dst = malloc(len);            // Allocate space
    if (dst == NULL) return NULL;       // No memory
    memcpy (dst, src, len);             // Copy the block
    return dst;                         // Return the new string
}

char * strdup(const char * s)
{
  size_t len = 1+strlen(s);
  char *p = malloc(len);

  return p ? memcpy(p, s, len) : NULL;
}

Peut-être que le code est un peu plus rapide qu'avec, strcpy()car le caractère \0n'a pas besoin d'être recherché à nouveau (il l'était déjà avec strlen()).

Inutile de répéter les autres réponses, mais veuillez noter que cela strdup()peut faire tout ce qu'il veut d'un point de vue C, car il ne fait partie d'aucune norme C. Il est cependant défini par POSIX.1-2001.

De l' homme strdup :

La strdup()fonction doit renvoyer un pointeur vers une nouvelle chaîne, qui est un doublon de la chaîne pointée par s1. Le pointeur renvoyé peut être transmis à free(). Un pointeur nul est renvoyé si la nouvelle chaîne ne peut pas être créée.

strdup () effectue l'allocation de mémoire dynamique pour le tableau de caractères, y compris le caractère de fin «\ 0» et renvoie l'adresse de la mémoire de tas:

char *strdup (const char *s)
{
    char *p = malloc (strlen (s) + 1);   // allocate memory
    if (p != NULL)
        strcpy (p,s);                    // copy string
    return p;                            // return the memory
}

Donc, ce qu'il fait, c'est nous donner une autre chaîne identique à la chaîne donnée par son argument, sans nous obliger à allouer de la mémoire. Mais nous devons encore le libérer plus tard.

Il crée une copie en double de la chaîne transmise en exécutant un malloc et strcpy de la chaîne transmise. Le tampon mallocé est renvoyé à l'appelant, d'où la nécessité de s'exécuter librement sur la valeur de retour.

strdupet strndupsont définis dans les systèmes compatibles POSIX comme:

char *strdup(const char *str);
char *strndup(const char *str, size_t len);

La fonction strdup () alloue suffisamment de mémoire pour une copie de la chaîne str, effectue la copie et lui renvoie un pointeur.

Le pointeur peut ensuite être utilisé comme argument de la fonction free.

Si la mémoire disponible est insuffisante, NULLest renvoyée et errnoest définie sur ENOMEM.

La fonction strndup () copie au maximum la plupart des lencaractères de la chaîne, strmettant ainsi fin à la chaîne copiée.

La chose la plus précieuse qu'il fait est de vous donner une autre chaîne identique à la première, sans vous obliger à allouer de la mémoire (emplacement et taille) vous-même. Mais, comme indiqué, vous devez toujours le libérer (mais qui ne nécessite pas non plus de calcul de quantité.)

La déclaration:

strcpy(ptr2, ptr1);

est équivalent à (à part le fait que cela change les pointeurs):

while(*ptr2++ = *ptr1++);

Tandis que:

ptr2 = strdup(ptr1);

est équivalent à:

ptr2 = malloc(strlen(ptr1) + 1);
if (ptr2 != NULL) strcpy(ptr2, ptr1);

Donc, si vous voulez que la chaîne que vous avez copiée soit utilisée dans une autre fonction (telle qu'elle est créée dans la section tas), vous pouvez utiliser strdup, sinon strcpyc'est assez,

La fonction strdup () est un raccourci pour la duplication de chaîne, elle prend un paramètre comme une constante de chaîne ou un littéral de chaîne et alloue juste assez d'espace pour la chaîne et écrit les caractères correspondants dans l'espace alloué et renvoie finalement l'adresse de l'alloué espace à la routine d'appel.