Como concatenar cordas constantes/literárias em C?

I'estou trabalhando em C, e eu tenho que concatenar algumas coisas.

Neste momento, tenho isto:

message = strcat("TEXT ", var);

message2 = strcat(strcat("TEXT ", foo), strcat(" TEXT ", bar));

Agora, se você tem experiência em C I'tenho certeza que você percebe que isso lhe dá uma falha de segmentação quando você tenta executá-lo. Então como faço para contornar isso?

Peter Mortensen
Pergunta editada :em
Programação
string c concatenation
21º novembro 2008 в 1:06
22 vistas
Solução

Em C, "strings" são apenas 'arrays' simples de 'char'. Portanto, você pode't concatená-los diretamente com outros "strings".

Você pode utilizar a função 'strcat', que anexa a string apontada por src' ao final da string apontada pordest':

char *strcat(char *dest, const char *src);

Aqui está um exemplo de cplusplus.com:

char str[80];
strcpy(str, "these ");
strcat(str, "strings ");
strcat(str, "are ");
strcat(str, "concatenated.");

Para o primeiro parâmetro, você precisa fornecer o próprio buffer de destino. O buffer de destino deve ser um buffer de matriz de caracteres. Por exemplo..: 'buffer de char[1024];``

**Certifique-se*** de que o primeiro parâmetro tem espaço suficiente para armazenar o que você'está tentando copiar para ele. Se estiver disponível para você, é mais seguro usar funções como: strcpy_s e strcat_s onde você tem que especificar explicitamente o tamanho do buffer de destino.

Note_: Uma string literal não pode ser usada como um buffer, uma vez que é uma constante. Assim, você sempre tem que alocar uma matriz de caracteres para o buffer.

O valor de retorno do strcat pode simplesmente ser ignorado, ele simplesmente retorna o mesmo ponteiro em que foi passado como o primeiro argumento. Ele está lá por conveniência, e permite que você acorrente as chamadas em uma linha de código:

strcat(strcat(str, foo), bar);

Então, o seu problema poderia ser resolvido da seguinte forma:

char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);
Endre
Resposta editada :em
Comentários (14)

É um comportamento indefinido tentar modificar os literais das cordas, que é o que é algo parecido:

strcat ("Hello, ", name);

vai tentar fazer. Ele tentará colar a string 'nome' no final da string literal "Olá, ", que não está bem definida.

Tente algo assim. Atinge o que parece que estás a tentar fazer:

char message[1000];
strcpy (message, "TEXT ");
strcat (message, var);

Isto cria uma área de buffer que é autorizada a ser modificada e depois copia tanto a string literal como outro texto para ela. Basta ter cuidado com os estouros de buffer. Se você controlar os dados de entrada (ou verificá-los com antecedência), não há problema em usar buffers de comprimento fixo como eu tenho.

Caso contrário, você deve usar estratégias de mitigação, como a alocação de memória suficiente da pilha para garantir que você possa lidar com ela. Em outras palavras, algo como:

const static char TEXT[] = "TEXT ";

// Make *sure* you have enough space.

char *message = malloc (sizeof(TEXT) + strlen(var) + 1);
if (message == NULL)
     handleOutOfMemoryIntelligently();
strcpy (message, TEXT);
strcat (message, var);

// Need to free message at some point after you're done with it.
paxdiablo
Resposta editada :em
Comentários (5)

O primeiro argumento de strcat() precisa ser capaz de manter espaço suficiente para a string concatenada. Portanto, alocar um buffer com espaço suficiente para receber o resultado.

char bigEnough[64] = "";

strcat(bigEnough, "TEXT");
strcat(bigEnough, foo);

/* and so on */

strcat() irá concatenar o segundo argumento com o primeiro argumento, e armazenar o resultado no primeiro argumento, o char* devolvido é simplesmente este primeiro argumento, e apenas para sua conveniência.

Você não recebe uma string recentemente alocada com o primeiro e segundo argumentos concatenados, que I'd suponho que você esperava baseado no seu código.

Comentários (0)