Como copiar um array char em C?

Em C, tenho dois conjuntos de caracteres:

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

Como copiar o valor de array1 para array2 ? Posso apenas fazer isso: array2 = array1 ?

    Você não pode fazer diretamente array1 = array2 . Porque nesse caso você manipularia os endereços ( char * ) dos arrays e não seus valores.

    Para este tipo de situação, recomenda-se usar o strncpy para evitar um estouro de buffer , especialmente se array1 for preenchido pela input do usuário (teclado, rede, etc.). Igual a:

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

    Como @Prof. Falken mencionado em um comentário, strncpy pode ser mal . Certifique-se de que seu buffer de destino seja grande o suficiente para conter o buffer de origem (incluindo o \0 no final da string).

    Se você quiser se proteger contra sequências não terminadas, o que pode causar todos os tipos de problemas, copie sua string assim:

     char array1[18] = {"abcdefg"}; char array2[18]; size_t destination_size = sizeof (array2); strncpy(array2, array1, destination_size); array2[destination_size - 1] = '\0'; 

    Essa última linha é realmente importante, porque strncpy() nem sempre nula termina strings. (Se o buffer de destino for muito pequeno para conter toda a string de origem, o sntrcpy () não terminará nulo a string de destino.)

    A página man do strncpy () até informa “Atenção: Se não houver nenhum byte nulo entre os primeiros n bytes de src, a string colocada no destino não será terminada com valor nulo.”

    A razão pela qual o strncpy () se comporta dessa maneira um tanto estranha, é porque ele não era originalmente planejado como uma maneira segura de copiar strings.

    Outra maneira é usar o snprintf () como um substituto seguro para o strcpy ():

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

    (Obrigado jxh pela dica.)

    Se os seus arrays não forem arrays de strings, use: memcpy(array2, array1, sizeof(array2));

    Você não pode atribuir matrizes, os nomes são constantes que não podem ser alterados.

    Você pode copiar o conteúdo com:

     strcpy(array2, array1); 

    assumindo que a fonte é uma string válida e que o destino é grande o suficiente, como no seu exemplo.

    Como outros notaram, as strings são copiadas com strcpy() ou suas variantes. Em certos casos, você poderia usar snprintf() também.

    Você só pode atribuir matrizes da maneira desejada como parte de uma atribuição de estrutura:

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

    Se seus arrays forem passados ​​para uma function, parecerá que você tem permissão para atribuí-los, mas isso é apenas um acidente da semântica. Em C, uma matriz decairá para um tipo de ponteiro com o valor do endereço do primeiro membro da matriz, e esse ponteiro é o que é passado. Então, seu parâmetro de matriz na sua function é realmente apenas um ponteiro. A atribuição é apenas uma atribuição de ponteiro:

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

    O array permanece inalterado depois de retornar da function.

    Essa semântica “decay to pointer value” para matrizes é a razão pela qual a atribuição não funciona. O valor l tem o tipo de matriz, mas o valor r é o tipo de ponteiro decaído, portanto, a atribuição é entre tipos incompatíveis.

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

    Quanto ao motivo pelo qual a semântica “decay to pointer value” foi introduzida, isso foi para alcançar uma compatibilidade de código fonte com o predecessor de C. Você pode ler O Desenvolvimento da Linguagem C para detalhes.

    deve ficar assim:

     void cstringcpy(char *src, char * dest) { while (*src) { *(dest++) = *(src++); } *dest = '\0'; } ..... char src[6] = "Hello"; char dest[6]; cstringcpy(src, dest); 
     array2 = array1; 

    não é suportado em c. Você tem que usar funções como strcpy () para fazer isso.

    Eu recomendo usar o memcpy () para copiar dados. Além disso, se atribuirmos um buffer a outro como array2 = array1 , ambos os arrays terão a mesma memory e qualquer alteração na arrary1 também será desviada no array2. Mas nós usamos o memcpy, ambos os buffers possuem um array diferente. Eu recomendo memcpy () porque strcpy e function relacionada não copiam o caractere NULL.

    c funções abaixo apenas … c + + você tem que fazer char array, em seguida, usar uma cópia de seqüência de caracteres, em seguida, usuário as funções de tokenizor string … c + + tornou muito mais difícil fazer anythng

     #include  #include  #include  #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: "< 

    para tipos inteiros

     #include  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") 

    Você não pode atribuir matrizes para copiá-los. Como você pode copiar o conteúdo de um para o outro depende de vários fatores:

    Para matrizes de char , se você souber que a matriz de origem está nula e a matriz de destino é grande o suficiente para a cadeia na matriz de origem, incluindo o terminador nulo, use strcpy() :

     #include  char array1[18] = "abcdefg"; char array2[18]; ... strcpy(array2, array1); 

    Se você não sabe se a matriz de destino é grande o suficiente, mas a fonte é uma string C, e você quer que o destino seja uma string C apropriada, use snprinf() :

     #include  char array1[] = "a longer string that might not fit"; char array2[18]; ... snprintf(array2, sizeof array2, "%s", array1); 

    Se a matriz de origem não for necessariamente terminada em null, mas você sabe que ambas as matrizes têm o mesmo tamanho, você pode usar o memcpy :

     #include  char array1[28] = "a non null terminated string"; char array2[28]; ... memcpy(array2, array1, sizeof array2);