Syntax:
verkohlen* strcpy (verkohlen*Zielort, const verkohlen*source_string);strcpy() verstehen:
Der einzige Zweck der Funktion strcpy() besteht darin, einen String von der Quelle zum Ziel zu kopieren. Sehen wir uns nun die obige Syntax der Funktion strcpy() an. Die Funktion strcpy() kann zwei Parameter akzeptieren –
- char * Ziel
- const char * source
Die Quelle ist hier eine Konstante, um sicherzustellen, dass die Funktion strcpy() den Quellstring nicht ändern kann. Die Funktion strcpy() kopiert alle Zeichen (einschließlich des NULL-Zeichens am Ende des Strings) vom Quellstring zum Ziel. Sobald der Kopiervorgang von der Quelle zum Ziel abgeschlossen ist, gibt die Funktion strcpy() die Adresse des Ziels an die Aufruferfunktion zurück.
Der wichtige Punkt, den Sie hier beachten sollten, ist, dass die Funktion strcpy() den Quellstring nicht mit dem Zielstring anhängt. Es ersetzt vielmehr den Inhalt des Ziels durch den Inhalt des Quellstrings.
Außerdem führt die Funktion strcpy() keine Überprüfungen durch, um sicherzustellen, dass die Größe des Ziels größer als der Quellstring ist, es liegt vollständig in der Verantwortung des Programmierers.
Beispiele:
Nun werden wir mehrere Beispiele sehen, um die Funktion strcpy() zu verstehen:
- strcpy() – Normaler Betrieb (Beispiel1.c)
- strcpy() – Fall-1 (Beispiel2.c)
- strcpy() – Fall-2 (Beispiel3.c)
- strcpy() – Fall-3 (Beispiel4.c)
- strcpy() – Benutzerdefinierte Version (Beispiel5.c)
- strcpy() – Benutzerdefinierte Version optimiert (Beispiel6.c)
strcpy() – Normaler Betrieb (Beispiel1.c):
Dieses Beispielprogramm zeigt, wie Sie mit der Funktion strcpy() in der Programmiersprache C einen normalen String-Kopiervorgang ausführen. Bitte beachten Sie, dass die Länge des Ziel-Strings 30 (char destination_str[30]; ) ist, was größer ist als die Länge des Quell-Strings (Länge ist 18 inklusive NULL-Zeichen), damit das Ziel alle Zeichen aus dem Quellstring.
#enthalten
#enthalten
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
verkohlendestination_str[30];
druckenf ('Bevor Sie die Funktion strcpy() aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
strcpy (destination_str,source_str);
druckenf ('Nach Ausführung der Funktion strcpy(): ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
Rückkehr 0;
}
strcpy() – Fall-1 (Beispiel2.c):
Die Absicht dieses Beispielprogramms besteht darin, klar zu erklären, was passiert, wenn die Länge der Zielzeichenfolge kleiner als die Länge der Quellzeichenfolge ist. In solchen Fällen verfügt der Zielspeicherort nicht über genügend Leerzeichen/Bytes, um alle Zeichen (einschließlich NULL-Zeichen) aus der Quellzeichenfolge aufzunehmen. Zwei Dinge sollten Sie immer im Hinterkopf behalten:
- Die Funktion strcpy() überprüft nicht, ob das Ziel über genügend Speicherplatz verfügt.
- Dies kann in eingebetteter Software gefährlich sein, da strcpy() den Speicherbereich jenseits der Grenze des Ziels ersetzt.
Schauen wir uns das Beispielprogramm an. Wir haben source_str deklariert und initialisiert auf www.linuxhint.com , die zum Speichern 18 Byte benötigt, einschließlich des Null-Zeichens am Ende der Zeichenfolge. Dann haben wir ein weiteres Zeichen-Array deklariert, z. B. destination_str mit der Größe von nur 5. Daher kann destination_str den Quellstring mit einer Gesamtgröße von 18 Byte nicht aufnehmen.
Trotzdem rufen wir die Funktion strcpy() auf, um den Quellstring in den Zielstring zu kopieren. Aus der folgenden Ausgabe können wir sehen, dass sich strcpy() überhaupt nicht beschwert hat. In diesem Fall beginnt die Funktion strcpy() mit dem Kopieren des Zeichens aus der Quellzeichenfolge (bis sie das NULL-Zeichen in der Quellzeichenfolge findet) an die Zieladresse (auch wenn die Zielgrenze überschritten wird). Das bedeutet, dass die Funktion strcpy() keine Grenzüberprüfung für das Zielarray durchführt. Schließlich überschreibt die Funktion strcpy() die Speicheradressen, die dem Zielarray nicht zugewiesen sind. Aus diesem Grund überschreibt die Funktion strcpy() am Ende die Speicherorte, die möglicherweise einer anderen Variablen zugewiesen sind.
In diesem Beispiel können wir aus der folgenden Ausgabe sehen, dass die Funktion strcpy() den Quellstring selbst überschreibt. Programmierer sollten mit solchem Verhalten immer vorsichtig sein.
#enthalten#enthalten
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
verkohlendestination_str[5];
druckenf ('Bevor Sie die Funktion strcpy() aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
strcpy (destination_str,source_str);
druckenf ('Nach Ausführung der Funktion strcpy(): ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
//printf('Quelladresse = %u (0x%x) ', &source_str[0], &source_str[0]);
//printf('Zieladresse = %u (0x%x) ', &destination_str[0], &destination_str[0]);
Rückkehr 0;
}
strcpy() – Fall-2 (Beispiel3.c):
Dieses Programm veranschaulicht die Situation, wenn die Größe der Zielzeichenfolge größer als die Größe der Quellzeichenfolge ist und die Zielzeichenfolge bereits mit einem Wert initialisiert ist. In diesem Beispiel haben wir initialisiert:
- source_str zu www.linuxhint.com [Größe = 17+1 = 18]
- destination_str bis I_AM_A_DESTINATION_STRING [Größe = 25+1 = 26]
Die Funktion strcpy() kopiert alle 17 Zeichen und das NULL-Zeichen aus dem Quellstring in den Zielstring. Es wird jedoch nicht die verbleibenden Bytes (Byte 19 bis 26, eines basierend) im Zielarray ersetzen/ändern. Wir haben eine for-Schleife verwendet, um über das Zielarray zu iterieren und das gesamte Array auszugeben, um zu beweisen, dass die Bytes-19 bis 26 im Zielarray unverändert sind. Deshalb sehen wir die letzte Ausgabe als:
#enthalten#enthalten
/* Dieses Programm veranschaulicht die Situation, wenn:
Ziel-String-Größe > Quell-String-Größe
und wir führen die Funktion strcpy() aus, um die zu kopieren
Quellstring zum Ziel.
Hinweis: Die Größe der Zielzeichenfolge sollte immer
größer oder gleich der Quellzeichenfolge sein.
* /
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
verkohlendestination_str[26] = 'I_AM_A_DESTINATION_STRING';
druckenf ('Bevor Sie die Funktion strcpy() aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
strcpy (destination_str,source_str);
druckenf ('Nach Ausführung der Funktion strcpy(): ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
/* Zielstring mit for-Schleife ausgeben*/
druckenf ('Zielzeichenfolge char für char ausgeben: ');
druckenf ('TZielzeichenfolge = ');
zum(intich=0;ich<25;ich++)
{
druckenf ('% C',destination_str[ich]);
}
druckenf (' ');
Rückkehr 0;
}
strcpy() – Fall-3 (Beispiel4.c):
Wir haben dieses Programm als Beispiel betrachtet, um zu zeigen, dass wir strcpy() niemals mit einem String-Literal als Ziel aufrufen sollten. Dies führt zu undefiniertem Verhalten und schließlich stürzt das Programm ab.
#enthalten#enthalten
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
druckenf ('Bevor Sie die Funktion strcpy() aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
/* Rufe niemals strcpy() mit einem String-Literal als Ziel auf.
Das Programm wird abstürzen.
* /
strcpy ('ziel_str',source_str);
druckenf ('Nach Ausführung der Funktion strcpy(): ');
druckenf ('TQuellstring = %s ',source_str);
Rückkehr 0;
}
strcpy() – Benutzerdefinierte Version (Beispiel5.c):
In diesem Beispielprogramm haben wir gezeigt, wie man eine benutzerdefinierte Version der Funktion strcpy() schreibt.
#enthaltenverkohlen *strcpy_user_defined(verkohlen *dest, const verkohlen *src);
/* Benutzerdefinierte Version der Funktion strcpy() */
verkohlen *strcpy_user_defined(verkohlen *dest, const verkohlen *src)
{
verkohlen *dest_backup=dest;
während(*src! = ' 0') /* Iteriere, bis ' ' gefunden wird.*/
{
*dest= *src; /* Quellzeichen zum Ziel kopieren */
src++; /* Quellzeiger inkrementieren */
dest++; /* Zielzeiger inkrementieren */
}
*dest= ' 0'; /* Füge ' ' explizit in das Ziel ein*/
Rückkehrdest_backup;
}
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
verkohlendestination_str[30];
druckenf ('Bevor Sie die benutzerdefinierte Zeichenfolgenkopierfunktion aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
/* Aufruf einer benutzerdefinierten String-Kopierfunktion */
strcpy_user_defined(destination_str,source_str);
druckenf ('Nach dem Ausführen der benutzerdefinierten Zeichenfolgenkopierfunktion: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
Rückkehr 0;
}
strcpy() – Benutzerdefinierte Version optimiert (Beispiel6.c):
In diesem Beispielprogramm werden wir nun die benutzerdefinierte Version von strcpy() optimieren.
#enthaltenverkohlen *strcpy_user_defined(verkohlen *dest, const verkohlen *src);
/* Optimierte Version der benutzerdefinierten Funktion strcpy() */
verkohlen *strcpy_user_defined(verkohlen *dest, const verkohlen *src)
{
verkohlen *dest_backup=dest;
während(*dest++ = *src++)
;
Rückkehrdest_backup;
}
inthauptsächlich()
{
verkohlensource_str[] = 'www.linuxhint.com';
verkohlendestination_str[30];
druckenf ('Bevor Sie die benutzerdefinierte Zeichenfolgenkopierfunktion aufrufen: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
/* Aufruf einer benutzerdefinierten String-Kopierfunktion */
strcpy_user_defined(destination_str,source_str);
druckenf ('Nach dem Ausführen der benutzerdefinierten Zeichenfolgenkopierfunktion: ');
druckenf ('TQuellstring = %s ',source_str);
druckenf ('TZielzeichenfolge = %s ',destination_str);
Rückkehr 0;
}
Abschluss :
Die Funktion strcpy() ist eine sehr beliebte und praktische Bibliotheksfunktion, um den String-Kopiervorgang in der Programmiersprache C durchzuführen. Dies wird hauptsächlich verwendet, um die Zeichenfolge von einem Speicherort an einen anderen Speicherort zu kopieren. Wir möchten jedoch noch einmal auf die Tatsache hinweisen, dass die Funktion strcpy() keine Überprüfung der Grenzen für das Zielarray durchführt, was bei Nichtbeachtung zu einem schwerwiegenden Softwarefehler führen könnte. Es liegt immer in der Verantwortung des Programmierers, sicherzustellen, dass das Zielarray genügend Platz hat, um alle Zeichen aus der Quellzeichenfolge einschließlich des NULL-Zeichens aufzunehmen.