Sintassi:
char* strcpy (char*destinazione_posizione, cost char*stringa_origine);Capire srcpy():
L'unico scopo della funzione strcpy() è copiare una stringa dall'origine alla destinazione. Ora, diamo un'occhiata alla sintassi sopra della funzione strcpy(). La funzione strcpy() è in grado di accettare due parametri:
- carattere * destinazione
- const char * source
L'origine è una costante qui per garantire che la funzione strcpy() non possa modificare la stringa di origine. La funzione strcpy() copia tutti i caratteri (incluso il carattere NULL alla fine della stringa) dalla stringa di origine alla destinazione. Una volta completata l'operazione di copia dall'origine alla destinazione, la funzione strcpy() restituisce l'indirizzo della destinazione alla funzione chiamante.
Il punto importante da notare qui è che la funzione strcpy() non aggiunge la stringa di origine con la stringa di destinazione. Piuttosto sostituisce il contenuto della destinazione con il contenuto della stringa di origine.
Inoltre, la funzione strcpy() non esegue alcun controllo per garantire che la dimensione della destinazione sia maggiore della stringa di origine, è completamente responsabilità del programmatore.
Esempi:
Ora vedremo diversi esempi per comprendere la funzione strcpy():
- strcpy() – Funzionamento normale (esempio1.c)
- strcpy() – Caso-1 (esempio2.c)
- strcpy() – Caso-2 (esempio3.c)
- strcpy() – Caso-3 (esempio4.c)
- strcpy() – Versione definita dall'utente (esempio 5.c)
- strcpy() – Versione definita dall'utente ottimizzata (esempio6.c)
strcpy() – Funzionamento normale (esempio1.c):
Questo programma di esempio mostra come eseguire una normale operazione di copia di una stringa utilizzando la funzione strcpy() nel linguaggio di programmazione C. Si noti che la lunghezza della stringa di destinazione è 30 (char destination_str[30]; ), che è maggiore della lunghezza della stringa di origine (la lunghezza è 18 incluso il carattere NULL) in modo che la destinazione possa contenere tutti i caratteri del stringa di origine.
#includere
#includere
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
chardestinazione_str[30];
printf ('Prima di chiamare la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
strcpy (destinazione_str,source_str);
printf ('Dopo aver eseguito la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
Restituzione 0;
}
strcpy() – Caso-1 (esempio2.c):
Lo scopo di questo programma di esempio è spiegare chiaramente cosa succede quando la lunghezza della stringa di destinazione è inferiore alla lunghezza della stringa di origine. In tali casi, la posizione di destinazione non avrà spazi/byte sufficienti per contenere tutti i caratteri (incluso il carattere NULL) dalla stringa di origine. Due cose, dovresti sempre tenere a mente:
- La funzione strcpy() non verificherà se la destinazione ha spazio sufficiente.
- Questo potrebbe essere pericoloso nel software embedded perché strcpy() sostituirà l'area di memoria oltre il confine della destinazione.
Esaminiamo il programma di esempio. Abbiamo dichiarato source_str e inizializzato su www.linuxhint.com , che richiederà 18 byte di memoria per essere archiviati, incluso il carattere Null alla fine della stringa. Quindi, abbiamo dichiarato un altro array di caratteri, ad esempio destination_str con la dimensione di soli 5. Quindi, destination_str non può contenere la stringa di origine con una dimensione totale di 18 byte.
Tuttavia, stiamo ancora chiamando la funzione strcpy() per copiare la stringa di origine nella stringa di destinazione. Dall'output seguente, possiamo vedere che strcpy() non si è affatto lamentato. In questo caso, la funzione strcpy() inizierà a copiare il carattere dalla stringa di origine (fino a quando non trova il carattere NULL nella stringa di origine) all'indirizzo di destinazione (anche se il limite di destinazione supera). Ciò significa che la funzione strcpy() non esegue alcun controllo dei limiti per l'array di destinazione. Alla fine, la funzione strcpy() sovrascriverà gli indirizzi di memoria che non sono allocati all'array di destinazione. Questo è il motivo per cui la funzione strcpy() finirà per sovrascrivere le posizioni di memoria che potrebbero essere allocate a una variabile diversa.
In questo esempio, possiamo vedere dall'output seguente che la funzione strcpy() sovrascrive la stringa di origine stessa. I programmatori dovrebbero sempre prestare attenzione a tale comportamento.
#includere#includere
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
chardestinazione_str[5];
printf ('Prima di chiamare la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
strcpy (destinazione_str,source_str);
printf ('Dopo aver eseguito la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
//printf('Indirizzo sorgente = %u (0x%x) ', &source_str[0], &source_str[0]);
//printf('Indirizzo di destinazione = %u (0x%x) ', &destination_str[0], &destination_str[0]);
Restituzione 0;
}
strcpy() – Caso-2 (esempio3.c):
Questo programma illustra la situazione in cui la dimensione della stringa di destinazione è maggiore della dimensione della stringa di origine e la stringa di destinazione è già inizializzata con un valore. In questo esempio, abbiamo inizializzato:
- source_str a www.linuxhint.com [taglia = 17+1 = 18]
- destination_str a I_AM_A_DESTINATION_STRING [dimensione = 25+1 = 26]
La funzione strcpy() copierà tutti i 17 caratteri e il carattere NULL dalla stringa di origine alla stringa di destinazione. Ma non sostituirà/cambierà i byte rimanenti (da 19 a 26 byte, uno basato) nell'array di destinazione. Abbiamo usato il ciclo for per scorrere l'array di destinazione e stampare l'intero array per dimostrare che i byte da 19 a 26 sono invariati nell'array di destinazione. Ecco perché vediamo l'ultimo output come:
#includere#includere
/* Questo programma illustra la situazione in cui:
dimensione della stringa di destinazione > dimensione della stringa di origine
ed eseguiamo la funzione strcpy() per copiare il
stringa di origine alla destinazione.
Nota: la dimensione della stringa di destinazione dovrebbe sempre
essere maggiore o uguale alla stringa di origine.
* /
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
chardestinazione_str[26] = 'I_AM_A_DESTINATION_STRING';
printf ('Prima di chiamare la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
strcpy (destinazione_str,source_str);
printf ('Dopo aver eseguito la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
/* stampa la stringa di destinazione usando il ciclo for*/
printf ('Stampa la stringa di destinazione char per char: ');
printf ('TStringa di destinazione = ');
per(intio=0;io<25;io++)
{
printf ('% C',destinazione_str[io]);
}
printf (' ');
Restituzione 0;
}
strcpy() – Caso-3 (esempio4.c):
Abbiamo considerato questo programma come un esempio per mostrare che non dovremmo mai chiamare strcpy() con una stringa letterale come destinazione. Ciò causerà un comportamento indefinito e alla fine il programma si bloccherà.
#includere#includere
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
printf ('Prima di chiamare la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
/* Non chiamare mai strcpy() con una stringa letterale come destinazione.
Il programma andrà in crash.
* /
strcpy ('destinazione_str',source_str);
printf ('Dopo aver eseguito la funzione strcpy(): ');
printf ('TStringa di origine = %s ',source_str);
Restituzione 0;
}
strcpy() – Versione definita dall'utente (esempio 5.c):
In questo programma di esempio, abbiamo mostrato come scrivere una versione definita dall'utente della funzione strcpy().
#includerechar *strcpy_user_defined(char *destinazione, cost char *src);
/* Versione definita dall'utente della funzione strcpy() */
char *strcpy_user_defined(char *destinazione, cost char *src)
{
char *dest_backup=destinazione;
mentre(*src! = ' 0') /* Itera fino a trovare ' '.*/
{
*destinazione= *src; /* Copia il carattere di origine nella destinazione */
src++; /* Incrementa il puntatore della sorgente */
destinazione++; /* Incrementa il puntatore di destinazione */
}
*destinazione= ' 0'; /* Inserisci ' ' nella destinazione in modo esplicito*/
Restituzionedest_backup;
}
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
chardestinazione_str[30];
printf ('Prima di chiamare la funzione di copia stringa definita dall'utente: ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
/* Chiamata alla funzione di copia stringa definita dall'utente */
strcpy_user_defined(destinazione_str,source_str);
printf ('Dopo aver eseguito la funzione di copia stringa definita dall'utente: ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
Restituzione 0;
}
strcpy() – Versione definita dall'utente ottimizzata (esempio6.c):
Ora, in questo programma di esempio, ottimizzeremo la versione definita dall'utente di strcpy().
#includerechar *strcpy_user_defined(char *destinazione, cost char *src);
/* Versione ottimizzata della funzione strcpy() definita dall'utente */
char *strcpy_user_defined(char *destinazione, cost char *src)
{
char *dest_backup=destinazione;
mentre(*destinazione++ = *src++)
;
Restituzionedest_backup;
}
intprincipale()
{
charsource_str[] = 'www.linuxhint.com';
chardestinazione_str[30];
printf ('Prima di chiamare la funzione di copia stringa definita dall'utente: ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
/* Chiamata alla funzione di copia stringa definita dall'utente */
strcpy_user_defined(destinazione_str,source_str);
printf ('Dopo aver eseguito la funzione di copia stringa definita dall'utente: ');
printf ('TStringa di origine = %s ',source_str);
printf ('TStringa di destinazione = %s ',destinazione_str);
Restituzione 0;
}
Conclusione :
La funzione strcpy() è una funzione di libreria molto popolare e utile per eseguire l'operazione di copia delle stringhe nel linguaggio di programmazione C. Questo è principalmente usato per copiare la stringa da una posizione a un'altra posizione. Tuttavia, vogliamo ribadire il fatto che la funzione strcpy() non esegue il controllo dei limiti per l'array di destinazione, il che potrebbe portare a un grave bug del software se ignorato. È sempre responsabilità del programmatore assicurarsi che l'array di destinazione abbia spazio sufficiente per contenere tutti i caratteri della stringa di origine, incluso il carattere NULL.