Hvordan konkatenerer jeg konst/literalstrenger i C?

Jeg jobber i C, og jeg må koble sammen et par ting.

Akkurat nå har jeg dette:

message = strcat("TEXT ", var);

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

Nå hvis du har erfaring i C, er jeg sikker på at du skjønner at dette gir deg en segmenteringsfeil når du prøver å kjøre den. Så hvordan jobber jeg rundt det?

Peter Mortensen
Redigerte spørsmål 22. mai 2017 в 5:41
Programmering
string c concatenation
21. november 2008 в 1:06
6 visninger
Løsning

I C, "strenger" er bare vanlige char matriser. Derfor kan du ikke koble dem direkte sammen med andre "strenger".

Du kan bruke funksjonen strcat, som legger strengen som pekes på av src til slutten av strengen som pekes på av dest:

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

Her er et eksempel fra cplusplus.com:

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

For den første parameteren må du oppgi selve destinasjonsbufferen. Destinasjonsbufferen må være en char array-buffer. F.eks: char buffer[1024];

**Forsikre deg om at den første parameteren har nok plass til å lagre det du prøver å kopiere inn i den. Hvis det er tilgjengelig for deg, er det tryggere å bruke funksjoner som: strcpy_s og strcat_s der du eksplisitt må spesifisere størrelsen på destinasjonsbufferen.

Merk_: En strenglitteral kan ikke brukes som buffer, siden den er en konstant. Dermed må du alltid tildele en char-array for bufferen.

Returverdien til strcat kan ganske enkelt ignoreres, den returnerer bare den samme pekeren som ble sendt inn som det første argumentet. Det er der for enkelhets skyld, og lar deg kjede anropene i en linje med kode:

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

Så problemet ditt kan løses som følger:

char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);
Endre
Redigert svar 16. mars 2015 в 5:31
Kommentarer (14)

Det er udefinert oppførsel å forsøke å modifisere strenglitteraler, som er hva noe som:

strcat ("Hello, ", name);

vil forsøke å gjøre. Den vil prøve å feste name-strengen til slutten av strenglitteralen "Hello, ", som ikke er veldefinert.

Prøv noe dette. Det oppnår det du ser ut til å prøve å gjøre:

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

Dette oppretter et bufferområde som kan endres, og kopierer deretter både strenglitteralen og annen tekst til det. Bare vær forsiktig med bufferoverløp. Hvis du kontrollerer inndataene (eller sjekker dem på forhånd), er det greit å bruke buffere med fast lengde som jeg har.

Ellers bør du bruke avbøtende strategier som å tildele nok minne fra bunken for å sikre at du kan håndtere det. Med andre ord, noe sånt som:

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
Redigert svar 22. februar 2016 в 2:27
Kommentarer (5)

Det første argumentet i strcat() må ha nok plass til den sammenkjedede strengen. Så tildel en buffer med nok plass til å motta resultatet.

char bigEnough[64] = "";

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

/* and so on */

strcat() vil konkatenere det andre argumentet med det første argumentet, og lagre resultatet i det første argumentet, den returnerte char* er ganske enkelt dette første argumentet, og bare for din bekvemmelighet.

Du får ikke en ny allokert streng med det første og andre argumentet sammenkjedet, noe jeg antar du forventet basert på koden din.

Kommentarer (0)