Hoe voeg ik const/literale strings aan elkaar toe in C?

Ik werk in C, en ik moet een paar dingen samenvoegen.

Op dit moment heb ik dit:

message = strcat("TEXT ", var);

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

Als je ervaring hebt met C, weet ik zeker dat je je realiseert dat dit een segmentatiefout oplevert als je het probeert uit te voeren. Dus hoe kan ik daar omheen werken?

Peter Mortensen
Bewerkte vraag 22ste0 mei 2017 в 5:41
Programmering
string c concatenation
21ste4 november 2008 в 1:06
25 views
Oplossing

In C, "strings" zijn gewoon char arrays. Daarom kun je'ze niet direct aaneenschakelen met andere "strings".

Je kunt de strcat functie gebruiken, die de string waarnaar src verwijst toevoegt aan het einde van de string waarnaar dest verwijst:

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

Hier is een voorbeeld van cplusplus.com:

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

Voor de eerste parameter moet je de bestemmingsbuffer zelf opgeven. De bestemmingsbuffer moet een char array buffer zijn. Bijv: char buffer[1024];

Zorg ervoor dat de eerste parameter genoeg ruimte heeft om op te slaan wat je'erin probeert te kopiëren. Indien voor u beschikbaar, is het veiliger om functies te gebruiken als: strcpy_s en strcat_s waarbij je expliciet de grootte van de bestemmingsbuffer moet opgeven.

Note: Een string literal kan niet als buffer worden gebruikt, omdat het een constante is. Je moet dus altijd een char array toewijzen voor de buffer.

De return waarde van strcat kan gewoon genegeerd worden, het geeft alleen dezelfde pointer terug als het eerste argument. Het is er voor het gemak, en stelt je in staat om de aanroepen in één regel code te zetten:

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

Uw probleem kan dus als volgt worden opgelost:

char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);
Endre
Bewerkt antwoord 16de0 maart 2015 в 5:31
Commentaren (14)

Het is ongedefinieerd gedrag om te proberen string literals te wijzigen, wat zoiets is als:

strcat ("Hello, ", name);

zal proberen om dat te doen. Het zal proberen om de naam string aan het eind van de string letterlijke "Hello, " te plakken, wat niet goed gedefinieerd is.

Probeer dit eens. Het bereikt wat je lijkt te proberen te doen:

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

Dit creëert een buffergebied dat is toegestaan om te worden gewijzigd en kopieert dan zowel de string literal als andere tekst naar het. Wees voorzichtig met buffer overflows. Als je de invoergegevens controleert (of van tevoren controleert), is het prima om buffers met een vaste lengte te gebruiken, zoals ik heb gedaan.

Anders moet je mitigatiestrategieën gebruiken zoals het toewijzen van genoeg geheugen van de heap om er zeker van te zijn dat je het aankan. Met andere woorden, iets als:

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
Bewerkt antwoord 22ste0 februari 2016 в 2:27
Commentaren (5)

Het eerste argument van strcat() moet genoeg ruimte hebben voor de aaneengeschakelde string. Dus wijs een buffer toe met genoeg ruimte om het resultaat te ontvangen.

char bigEnough[64] = "";

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

/* and so on */

strcat() zal het tweede argument samenvoegen met het eerste argument, en het resultaat opslaan in het eerste argument, de geretourneerde char* is gewoon dit eerste argument, en alleen voor uw gemak.

Je krijgt geen nieuw gealloceerde string met het eerste en tweede argument aaneengeschakeld, wat ik'zou denken dat je verwachtte op basis van je code.

Commentaren (0)