Come usare strcpy in lingua c?

In questo articolo, impareremo sulla funzione strcpy () nel linguaggio di programmazione C. La funzione strcpy () è una funzione di libreria standard molto popolare per eseguire l'operazione di copia della stringa nel linguaggio di programmazione C. Esistono diversi file di intestazione standard in linguaggio di programmazione C per eseguire operazioni standard. La stringa.H "è uno di questi file di intestazione, che fornisce diverse funzioni di libreria standard per eseguire operazioni di stringa. La funzione "strcpy ()" è una delle funzioni della libreria fornite da "String.H".

Sintassi:

char* strcpy (char* destinazione_location, const char* source_string);

Comprensione strcpy ():

L'unico scopo della funzione strcpy () è di copiare una stringa da un'origine a destinazione. Ora, ci consente di guardare la sintassi sopra della funzione strcpy (). La funzione strcpy () è in grado di accettare due parametri -

• CHAR * DETTAGLIO
• fonte const char *

La fonte è 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 che l'operazione di copia è completa da un'origine a 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. Preferisce sostituire 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 superiore alla stringa di origine, è completamente responsabilità del programmatore.

Esempi:

Ora vedremo diversi esempi per capire la funzione strcpy ():

1. strcpy () - operazione normale (esempio1.C)
2. strcpy () - case -1 (esempio2.C)
3. strcpy () - case -2 (esempio3.C)
4. strcpy () - case -3 (esempio4.C)
5. strcpy () - versione definita dall'utente (esempio5.C)
6. strcpy () - versione definita dall'utente ottimizzata (Esempio6.C)

strcpy () - operazione normale (esempio1.C):

Questo programma di esempio mostra come eseguire un'operazione di copia stringa normale utilizzando la funzione strcpy () nel linguaggio di programmazione C. Si prega di notare che la lunghezza della stringa di destinazione è 30 (char destinazione_str [30];), che è maggiore della lunghezza della stringa di origine (la lunghezza è 18 incluso il carattere null) in modo che la destinazione possa ospitare tutti i caratteri dal stringa di origine.

#includere
#includere
int main ()

char source_str [] = "www.Linuxhint.com ";
Char Destination_STR [30];
printf ("prima di chiamare la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
strcpy (destinazione_str, source_str);
printf ("Dopo aver eseguito la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
restituzione 0;

strcpy () - case -1 (esempio2.C):

L'intento di questo programma di esempio è di 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à abbastanza spazi/byte per ospitare tutti i caratteri (incluso il carattere null) dalla stringa di origine. Due cose, dovresti sempre tenere a mente:

1. La funzione strcpy () non verificherà se la destinazione ha abbastanza spazio.
2. Questo potrebbe essere pericoloso nel software incorporato 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 prenderà 18 byte in memoria per archiviare, incluso il carattere null alla fine della stringa. Quindi, abbiamo dichiarato un altro array di caratteri I.e. destinazione_str con la dimensione di soli 5. Quindi, Destination_STR non può contenere la stringa di origine con una dimensione totale di 18 byte.

Ma, tuttavia, stiamo chiamando la funzione strcpy () per copiare la stringa di origine in una stringa di destinazione. Dall'output seguente, possiamo vedere affatto lo strcpy (). 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 del limite per l'array di destinazione. Alla fine, la funzione strcpy () sovrascriverà gli indirizzi di memoria che non sono assegnati all'array di destinazione. Questo è il motivo per cui la funzione strcpy () finirà per sovrascrivere le posizioni della memoria che potrebbero essere assegnate 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 stare attenti a tale comportamento.

#includere
#includere
int main ()

char source_str [] = "www.Linuxhint.com ";
Char Destination_STR [5];
printf ("prima di chiamare la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
strcpy (destinazione_str, source_str);
printf ("Dopo aver eseguito la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
// printf ("sorgente indirizzo = %u (0x %x) \ n", & source_str [0], & source_str [0]);
// printf ("destinazione indirizzo = %u (0x %x) \ n", & destinazione_str [0], & destinazione_str [0]);
restituzione 0;

strcpy () - case -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 certo valore. In questo esempio, abbiamo inizializzato:

• Source_str a “www.Linuxhint.com ”[size = 17+1 = 18]
• Destination_STR a “I_AM_A_DESTINATH_STRING” [Size = 25+1 = 26]

La funzione strcpy () copierà tutti i 17 caratteri e il carattere null dalla stringa di origine nella stringa di destinazione. Ma non sostituirà/cambierà i byte rimanenti (byte da 19 a 26, basati) nell'array di destinazione. Abbiamo usato per il ciclo per iterare 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 quando:
Dimensione stringa di destinazione> Dimensione stringa di origine
e 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.
*/
int main ()

char source_str [] = "www.Linuxhint.com ";
char destinazione_str [26] = "i_am_a_destination_string";
printf ("prima di chiamare la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
strcpy (destinazione_str, source_str);
printf ("Dopo aver eseguito la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
/* Stampa stringa di destinazione utilizzando per loop*/
printf ("stampa la stringa di destinazione char di char: \ n \ n");
printf ("\ tDestination String =");
per (int i = 0; i<25;i++)

printf ("%c", destinazione_str [i]);

printf ("\ n \ n");
restituzione 0;

strcpy () - case -3 (esempio4.C):

Abbiamo considerato questo programma come un esempio per dimostrare che non dovremmo mai chiamare strcpy () con una stringa letterale come destinazione. Ciò causerà comportamenti indefiniti e, infine, il programma si arresterà.

#includere
#includere
int main ()

char source_str [] = "www.Linuxhint.com ";
printf ("prima di chiamare la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
/* Non chiamare mai strcpy () con la stringa letterale come destinazione.
Il programma si bloccherà.
*/
strcpy ("destination_str", source_str);
printf ("Dopo aver eseguito la funzione strcpy (): \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
restituzione 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 ().

#includere
char * strcpy_user_defined (char * dest, const char * src);
/ * Versione definita dall'utente della funzione strcpy () */
char * strcpy_user_defined (char * dest, const char * src)

char * dest_backup = dest;
while (*src != '\ 0') /* itera fino a '\ 0'.*/

*dest = *src; / * Copia l'origine char in destinazione */
src ++; / * Puntatore di sorgente incremento */
dest ++; / * Puntatore di destinazione incremento */

*dest = '\ 0'; /* Inserisci '\ 0' a destinazione esplicitamente*/
restituire Dest_backup;

int main ()

char source_str [] = "www.Linuxhint.com ";
Char Destination_STR [30];
printf ("Prima di chiamare la funzione di copia stringa definita dall'utente: \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
/ * CHIAMATA FUNZIONE DI COPIA STRING DEFINITA UTENTE */
strcpy_user_defined (destinazione_str, source_str);
printf ("Dopo aver eseguito la funzione di copia stringa definita dall'utente: \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", 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 ().

#includere
char * strcpy_user_defined (char * dest, const char * src);
/ * Versione ottimizzata della funzione di strcpy () definita utente */
char * strcpy_user_defined (char * dest, const char * src)

char * dest_backup = dest;
while ( *dest ++ = *src ++)
;
restituire Dest_backup;

int main ()

char source_str [] = "www.Linuxhint.com ";
Char Destination_STR [30];
printf ("Prima di chiamare la funzione di copia stringa definita dall'utente: \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
/ * CHIAMATA FUNZIONE DI COPIA STRING DEFINITA UTENTE */
strcpy_user_defined (destinazione_str, source_str);
printf ("Dopo aver eseguito la funzione di copia stringa definita dall'utente: \ n \ n");
printf ("\ tsource string = %s \ n", source_str);
printf ("\ tDestination String = %s \ n \ n", destinazione_str);
restituzione 0;

Conclusione:

La funzione strcpy () è una funzione di libreria molto popolare e utile per eseguire l'operazione di copia della stringa nel linguaggio di programmazione C. Questo viene utilizzato principalmente per copiare la stringa da una posizione in un'altra posizione. Tuttavia, vogliamo ribadire il fatto che la funzione strcpy () non esegue il controllo del confine per l'array di destinazione, che potrebbe portare a un serio bug del software se ignorato. È sempre responsabilità del programmatore assicurarsi che l'array di destinazione abbia abbastanza spazio per contenere tutti i caratteri dalla stringa di origine incluso il carattere null.