strdup () - cosa fa in C?

Qual è lo scopo della strdup()funzione in C?

Esattamente come sembra, supponendo che tu sia abituato al modo abbreviato in cui C e UNIX assegnano le parole, duplica le stringhe :-)

Tenendo presente che in realtà non fa parte dello standard ISO C stesso ^(a) (è una cosa POSIX), sta effettivamente facendo lo stesso del seguente codice:

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
}

In altre parole:

1. Tenta di allocare memoria sufficiente per contenere la vecchia stringa (più un carattere '\ 0' per segnare la fine della stringa).

2. Se l'assegnazione non è riuscita, imposta errnoper ENOMEMe ritorna NULLimmediatamente. L'impostazione di errnoto ENOMEMè qualcosa che mallocfa in POSIX, quindi non è necessario farlo esplicitamente nel nostro strdup. Se sei non conforme a POSIX, ISO C in realtà non mandato l'esistenza di ENOMEMcosì non ho incluso che qui ^(b) .

3. Altrimenti l'allocazione ha funzionato, quindi copiamo la vecchia stringa nella nuova stringa ^(c) e restituiamo il nuovo indirizzo (che il chiamante è responsabile della liberazione a un certo punto).

Tieni presente che è la definizione concettuale. Qualsiasi scrittore degno del proprio stipendio può aver fornito un codice fortemente ottimizzato destinato al particolare processore utilizzato.

^(a) Tuttavia, le funzioni che iniziano con stre una lettera minuscola sono riservate dallo standard per le direzioni future. Da C11 7.1.3 Reserved identifiers:

Ogni intestazione dichiara o definisce tutti gli identificatori elencati nella sua sotto-clausola associata e * facoltativamente dichiara o definisce gli identificatori elencati nella sua sotto-clausola delle direzioni della libreria future associate. **

Le direzioni future per string.hpossono essere trovate in C11 7.31.13 String handling <string.h>:

I nomi delle funzioni che iniziano con str, memo wcse una lettera minuscola possono essere aggiunti alle dichiarazioni del <string.h>intestazione.

Quindi dovresti probabilmente chiamarlo qualcos'altro se vuoi essere al sicuro.

^(b) La modifica verrebbe sostanzialmente sostituita if (d == NULL) return NULL;da:

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

^(c) Nota che lo uso strcpyper quello poiché questo mostra chiaramente l'intento. In alcune implementazioni, può essere più veloce (poiché si conosce già la lunghezza) da utilizzare memcpy, in quanto possono consentire il trasferimento dei dati in blocchi più grandi o in parallelo. Oppure potrebbe non :-) Mantra di ottimizzazione # 1: "misura, non indovinare".

In ogni caso, se decidessi di percorrere quella strada, faresti qualcosa del tipo:

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;
}

Forse il codice è un po 'più veloce di con strcpy()poiché \0non è necessario cercare nuovamente il carattere (lo era già con strlen()).

Inutile ripetere le altre risposte, ma tieni presente che strdup()può fare tutto ciò che vuole dal punto di vista C, poiché non fa parte di alcuno standard C. È tuttavia definito da POSIX.1-2001.

Da strdup man :

La strdup()funzione deve restituire un puntatore a una nuova stringa, che è un duplicato della stringa a cui punta s1. Il puntatore restituito può essere passato a free(). Viene restituito un puntatore null se non è possibile creare la nuova stringa.

strdup () esegue l'allocazione dinamica della memoria per l'array di caratteri incluso il carattere finale '\ 0' e restituisce l'indirizzo della memoria dell'heap:

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
}

Quindi, ciò che fa è darci un'altra stringa identica alla stringa fornita dal suo argomento, senza che ci venga richiesto di allocare memoria. Ma dobbiamo ancora liberarlo, più tardi.

Crea una copia duplicata della stringa passata eseguendo un malloc e strcpy della stringa passata. Il buffer di malloc viene restituito al chiamante, quindi la necessità di funzionare liberamente sul valore restituito.

strdupe strndupsono definiti nei sistemi POSIX compatibili come:

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

La funzione strdup () alloca memoria sufficiente per una copia della stringa str, esegue la copia e restituisce un puntatore ad essa.

Il puntatore può essere successivamente utilizzato come argomento per la funzione free.

Se la memoria disponibile è insufficiente, NULLviene restituita ed errnoè impostata su ENOMEM.

La funzione strndup () copia al massimo i lencaratteri dalla stringa strsempre null, terminando la stringa copiata.

La cosa più preziosa che fa è darti un'altra stringa identica alla prima, senza che tu debba allocare memoria (posizione e dimensione) da solo. Ma, come notato, è ancora necessario liberarlo (ma che non richiede nemmeno un calcolo della quantità.)

La dichiarazione:

strcpy(ptr2, ptr1);

è equivalente a (a parte il fatto che cambia i puntatori):

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

Mentre:

ptr2 = strdup(ptr1);

è equivalente a:

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

Pertanto, se desideri che la stringa che hai copiato sia utilizzata in un'altra funzione (poiché viene creata nella sezione heap), puoi utilizzare strdup, altrimenti strcpyè sufficiente,

La funzione strdup () è una scorciatoia per il duplicato di stringa, accetta un parametro come costante di stringa o valore letterale di stringa e alloca lo spazio sufficiente per la stringa e scrive i caratteri corrispondenti nello spazio allocato e infine restituisce l'indirizzo dell'allocato spazio alla routine chiamante.