it-swarm.com.de

Wie kopiere ich ein Zeichen-Array in C?

In C habe ich zwei Zeichen-Arrays:

char array1[18] = "abcdefg";
char array2[18];

Wie kopiere ich den Wert von array1 bis array2? Kann ich das einfach machen: array2 = array1?

65
user2131316

Sie können nicht direkt tun array2 = array1, weil Sie in diesem Fall die Adressen manipulieren würden (char *) der Arrays und nicht deren Werte.

Für diese Art von Situation wird empfohlen, strncpy zu verwenden, um Pufferüberlauf zu vermeiden, insbesondere wenn array1 wird über Benutzereingaben (Tastatur, Netzwerk usw.) gefüllt. Wie so:

// Will copy 18 characters from array1 to array2
strncpy(array2, array1, 18);

Als @Prof. Falken erwähnte in einem Kommentar: strncpykann böse sein . Stellen Sie sicher, dass Ihr Zielpuffer groß genug ist, um den Quellpuffer (einschließlich des \0 am Ende der Zeichenkette).

77
aymericbeaumet

Wenn Ihre Arrays keine String-Arrays sind, verwenden Sie: memcpy(array2, array1, sizeof(array2));

25
kAmol

Wenn Sie sich vor nicht abgeschlossenen Zeichenfolgen schützen möchten, die alle möglichen Probleme verursachen können, kopieren Sie die Zeichenfolge folgendermaßen:

char array1[18] = {"abcdefg"};
char array2[18];

size_t destination_size = sizeof (array2);

strncpy(array2, array1, destination_size);
array2[destination_size - 1] = '\0';

Diese letzte Zeile ist eigentlich wichtig, da strncpy() nicht immer null terminate Strings ist. (Wenn der Zielpuffer zu klein ist, um die gesamte Quellzeichenfolge zu enthalten, beendet sntrcpy () die Zielzeichenfolge nicht mit Null.)

In der Manpage für strncpy () wird sogar angegeben. "Warnung: Wenn sich unter den ersten n Bytes von src kein Null-Byte befindet, wird der in dest platzierte String nicht mit Null abgeschlossen."

Der Grund, warum sich strncpy () auf diese etwas seltsame Weise verhält, ist, dass es ursprünglich nicht als sichere Methode zum Kopieren von Zeichenfolgen gedacht war.

Eine andere Möglichkeit ist, snprintf () als sicheren Ersatz für strcpy () zu verwenden:

snprintf(array2, destination_size, "%s", array1);

(Danke jxh für den Tipp.)

22
Prof. Falken

Sie können keine Arrays zuweisen, die Namen sind Konstanten, die nicht geändert werden können.

Sie können das Inhalt kopieren mit:

strcpy(array2, array1);

angenommen, die Quelle ist eine gültige Zeichenfolge und das Ziel ist groß genug, wie in Ihrem Beispiel.

6
unwind

Wie andere angemerkt haben, werden Zeichenfolgen mit strcpy() oder seinen Varianten kopiert. In bestimmten Fällen können Sie auch snprintf() verwenden.

Sie können Arrays im Rahmen einer Strukturzuweisung nur so zuweisen, wie Sie möchten:

typedef struct { char a[18]; } array;
array array1 = { "abcdefg" };
array array2;

array2 = array1;

Wenn Ihre Arrays an eine Funktion übergeben werden, können Sie sie anscheinend zuweisen, dies ist jedoch nur ein Zufall der Semantik. In C zerfällt ein Array in einen Zeigertyp mit dem Wert der Adresse des ersten Mitglieds des Arrays, und dieser Zeiger wird übergeben. Ihr Array-Parameter in Ihrer Funktion ist also eigentlich nur ein Zeiger. Die Zuweisung ist nur eine Zeigerzuweisung:

void foo (char x[10], char y[10]) {
    x = y;    /* pointer assignment! */
    puts(x);
}

Das Array selbst bleibt nach der Rückkehr von der Funktion unverändert.

Diese "Decay to Pointer Value" -Semantik für Arrays ist der Grund, warum die Zuweisung nicht funktioniert. Der l-Wert hat den Array-Typ, aber der r-Wert ist der verfallene Zeigertyp, sodass die Zuordnung zwischen inkompatiblen Typen erfolgt.

char array1[18] = "abcdefg";
char array2[18];
array2 = array1; /* fails because array1 becomes a pointer type,
                    but array2 is still an array type */

Um herauszufinden, warum die Semantik "Decay to Pointer Value" eingeführt wurde, sollte eine Quellcode-Kompatibilität mit dem Vorgänger von C hergestellt werden. Lesen Sie Die Entwicklung der C-Sprache für Details.

4
jxh

es sollte so aussehen:

void cstringcpy(char *src, char * dest)
{
    while (*src) {
        *(dest++) = *(src++);
    }
    *dest = '\0';
}
.....

char src[6] = "Hello";
char dest[6];
cstringcpy(src, dest);
3
Boris
array2 = array1;

wird in c nicht unterstützt. Sie müssen Funktionen wie strcpy () verwenden, um dies zu tun.

1
MOHAMED

c-Funktionen nur unten ... c ++ Sie müssen char array ausführen, dann eine String-Kopie verwenden und dann die String-Tokenizor-Funktionen verwenden ... c ++ machte es viel schwieriger, irgendetwas zu tun

#include <iostream>
#include <fstream>
#include <cstring>
#define TRUE 1
#define FALSE 0
typedef int Bool;
using namespace std;
Bool PalTrueFalse(char str[]);
int main(void)
{
char string[1000], ch;
int i = 0;
cout<<"Enter a message: ";

while((ch = getchar()) != '\n') //grab users input string untill 
{                               //Enter is pressed
    if (!isspace(ch) && !ispunct(ch)) //Cstring functions checking for
    {                                //spaces and punctuations of all kinds
        string[i] = tolower(ch); 
        i++;
    }
}
string[i] = '\0';  //hitting null deliminator once users input
cout<<"Your string: "<<string<<endl; 
if(PalTrueFalse(string)) //the string[i] user input is passed after
                        //being cleaned into the null function.
    cout<<"is a "<<"Palindrome\n"<<endl;
else
   cout<<"Not a palindrome\n"<<endl;
return 0;
}

Bool PalTrueFalse(char str[])
{
int left = 0;
int right = strlen(str)-1;
while (left<right)
{
   if(str[left] != str[right]) //comparing most outer values of string
       return FALSE;          //to inner values.
   left++;
   right--;
}
return TRUE;
}

Ich empfehle, memcpy () zum Kopieren von Daten zu verwenden. Auch wenn wir einen Puffer einem anderen als array2 = array1 Zuweisen, haben beide Arrays denselben Speicher und jede Änderung in arrary1 lenkt auch in array2 aus. Aber wir benutzen memcpy, beide Buffer haben unterschiedliche Arrays. Ich empfehle memcpy (), da strcpy und die zugehörige Funktion kein NULL-Zeichen kopieren.

1
akhil

für ganzzahlige Typen

#include <string.h>    

int array1[10] = {0,1,2,3,4,5,6,7,8,9};
int array2[10];


memcpy(array2,array1,sizeof(array1)); // memcpy("destination","source","size")
0
D0rm1nd0

Nun, technisch gesehen können Sie ...

typedef struct { char xx[18]; } arr_wrap;

char array1[18] = "abcdefg";
char array2[18];

*((arr_wrap *) array2) = *((arr_wrap *) array1);

printf("%s\n", array2);     /* "abcdefg" */

aber es wird nicht sehr schön aussehen.

(Ja, der obige Code ist bewilligt um immer zu funktionieren und es ist portabel)

0
madmurphy

Sie können keine Arrays zuweisen, um sie zu kopieren. Wie Sie den Inhalt eines Dokuments in ein anderes kopieren können, hängt von mehreren Faktoren ab:

Verwenden Sie für char Arrays strcpy(), wenn Sie wissen, dass das Quellarray nullterminiert ist und das Zielarray groß genug für die Zeichenfolge im Quellarray ist, einschließlich des Nullterminators:

#include <string.h>

char array1[18] = "abcdefg";
char array2[18];

...

strcpy(array2, array1);

Wenn Sie nicht wissen, ob das Ziel-Array groß genug ist, die Quelle jedoch eine C-Zeichenfolge ist, und Sie möchten, dass das Ziel eine richtige C-Zeichenfolge ist, verwenden Sie snprinf():

#include <stdio.h>

char array1[] = "a longer string that might not fit";
char array2[18];

...

snprintf(array2, sizeof array2, "%s", array1);

Wenn das Quell-Array nicht unbedingt mit Null terminiert ist, Sie jedoch wissen, dass beide Arrays dieselbe Größe haben, können Sie memcpy verwenden:

#include <string.h>

char array1[28] = "a non null terminated string";
char array2[28];

...

memcpy(array2, array1, sizeof array2);
0
chqrlie