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?
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 por
dest':
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);
É 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.
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.