Phenquestions
Sintassi:
char* strcpy (char* posizione_destinazione, const char* stringa_origine);Capire srcpy():
L'unico scopo della funzione strcpy() è copiare una stringa dalla sorgente 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 dalla sorgente 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 sorgente.
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() - Operazione normale (esempio1.c)
- strcpy() - Caso-1 (esempio2.c)
- strcpy() - Caso-2 (esempio3.c)
- strcpy() - Caso-3 (esempio4.c)
- strcpy() - Versione definita dall'utente (esempio5.c)
- strcpy() - Versione definita dall'utente ottimizzata (esempio6.c)
strcpy() - Operazione 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
intero principale()
char source_str[] = "www.linuxhint.com";
char destinazione_str[30];
printf("Prima di chiamare la funzione strcpy(): \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
strcpy(destination_str, source_str);
printf("Dopo aver eseguito la funzione strcpy() : \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
restituisce 0;
strcpy() - Caso-1 (esempio2.c):
L'intento di questo programma esempioèdi spiegare chiaramente cosa succede quando la lunghezza della stringa di destinazioneèminore della 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.
Vediamo il programma di esempio. Abbiamo dichiarato source_str e inizializzato su "www.linuxhint.com", che occuperà 18 byte in memoria per essere archiviato, incluso il carattere Null alla fine della stringa. Quindi, abbiamo dichiarato un altro array di caratteri i.e. destination_str con una dimensione di soli 5. Quindi, destination_str non può contenere la stringa di origine con una dimensione totale di 18 byte.
Ma, ancora, stiamo 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 sorgente stessa. I programmatori dovrebbero sempre stare attenti a questo comportamento.
#includere#includere
intero principale()
char source_str[] = "www.linuxhint.com";
char destinazione_str[5];
printf("Prima di chiamare la funzione strcpy(): \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
strcpy(destination_str, source_str);
printf("Dopo aver eseguito la funzione strcpy() : \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
//printf("Indirizzo sorgente = %u (0x%x)\n", &source_str[0], &source_str[0]);
//printf("Indirizzo di destinazione = %u (0x%x)\n", &destination_str[0], &destination_str[0]);
restituisce 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 qualche valore. In questo esempio, abbiamo inizializzato:
- source_str a “www.linuxhint.com” [dimensione = 17+1 = 18]
- str_destinazione a "I_AM_A_STRING_DESTINAZIONE" [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:
“www.linuxhint.com_STRING”.
#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 a destinazione.
Nota: la dimensione della stringa di destinazione dovrebbe sempre
essere maggiore o uguale alla stringa di origine.
*/
intero principale()
char source_str[] = "www.linuxhint.com";
char destination_str[26] = "I_AM_A_DESTINATION_STRING";
printf("Prima di chiamare la funzione strcpy(): \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
strcpy(destination_str, source_str);
printf("Dopo aver eseguito la funzione strcpy() : \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
/* stampa la stringa di destinazione usando il ciclo for*/
printf("Stampa la stringa di destinazione char by char : \n\n");
printf("\tStringa destinazione = ");
for(int i=0; i<25;i++)
printf("%c", str_destinazione[i]);
printf("\n\n");
restituisce 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 andrà in crash.
#includere#includere
intero principale()
char source_str[] = "www.linuxhint.com";
printf("Prima di chiamare la funzione strcpy() : \n\n");
printf("\tStringa sorgente = %s\n", source_str);
/* Non chiamare mai strcpy() con stringa letterale come destinazione.
Il programma andrà in crash.
*/
strcpy("destination_str", source_str);
printf("Dopo aver eseguito la funzione strcpy() : \n\n");
printf("\tStringa sorgente = %s\n", source_str);
restituisce 0;
strcpy() - Versione definita dall'utente (esempio5.c):
In questo programma di esempio, abbiamo mostrato come scrivere una versione definita dall'utente della funzione strcpy().
#includerechar * strcpy_user_defined(char *dest, const char * src);
/* Versione definita dall'utente della funzione strcpy() */
char * strcpy_user_defined(char *dest, const char * src)
carattere * backup_dest = destinazione;
while(*src != '\0') /* Itera fino a trovare '\0'.*/
*dest = *src; /* Copia il carattere di origine nella destinazione */
src++; /* Incrementa il puntatore della sorgente */
destinazione++; /* Incrementa il puntatore di destinazione */
*destinazione = '\0'; /* Inserisci '\0' nella destinazione in modo esplicito*/
return dest_backup;
intero principale()
char source_str[] = "www.linuxhint.com";
char destinazione_str[30];
printf("Prima di chiamare la funzione di copia stringa definita dall'utente: \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
/* Chiamata alla funzione di copia stringa definita dall'utente */
strcpy_user_defined(destination_str, source_str);
printf("Dopo aver eseguito la funzione di copia stringa definita dall'utente: \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
restituisce 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 *dest, const char * src);
/* Versione ottimizzata della funzione strcpy() definita dall'utente */
char * strcpy_user_defined(char *dest, const char * src)
carattere * backup_dest = destinazione;
while(*dest++ = *src++)
;
return dest_backup;
intero principale()
char source_str[] = "www.linuxhint.com";
char destinazione_str[30];
printf("Prima di chiamare la funzione di copia stringa definita dall'utente: \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
/* Chiamata alla funzione di copia stringa definita dall'utente */
strcpy_user_defined(destination_str, source_str);
printf("Dopo aver eseguito la funzione di copia stringa definita dall'utente: \n\n");
printf("\tStringa sorgente = %s\n", source_str);
printf("\tStringa destinazione = %s\n\n", str_destinazione);
restituisce 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 dalla stringa di origine incluso il carattere NULL.
