Wie verkette ich const/literal strings in C?

Question

Ich arbeite in C und muss ein paar Dinge verketten.

Im Moment habe ich das hier:

message = strcat("TEXT ", var);

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

Wenn Sie Erfahrung mit C haben, ist Ihnen sicher klar, dass dies zu einem Segmentierungsfehler führt, wenn Sie versuchen, es auszuführen. Wie kann ich das also umgehen?

Answer 1

In C sind "Strings" einfach nur char Arrays. Daher können Sie sie nicht direkt mit anderen "Strings" verketten.

Sie können die strcat Funktion, die die Zeichenkette anfügt, auf die in src an das Ende der Zeichenkette, auf die mit dest :

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

Hier ist ein Beispiel von cplusplus.com :

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

Für den ersten Parameter müssen Sie den Zielpuffer selbst angeben. Der Zielpuffer muss ein Char-Array-Puffer sein. z.B.: char buffer[1024];

Vergewissern Sie sich dass der erste Parameter genügend Platz hat, um das zu speichern, was Sie hineinkopieren wollen. Wenn Sie die Möglichkeit haben, ist es sicherer, Funktionen wie zu verwenden: strcpy_s y strcat_s wobei Sie die Größe des Zielpuffers explizit angeben müssen.

備考 : Ein String-Literal kann nicht als Puffer verwendet werden, da es eine Konstante ist. Daher müssen Sie immer ein Char-Array für den Puffer zuweisen.

Der Rückgabewert von strcat kann einfach ignoriert werden, es gibt lediglich denselben Zeiger zurück, der als erstes Argument übergeben wurde. Er dient der Bequemlichkeit und ermöglicht es Ihnen, die Aufrufe in einer einzigen Codezeile zu verketten:

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

Ihr Problem könnte also wie folgt gelöst werden:

char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);

Answer 2

Vermeiden Sie die Verwendung von strcat in C-Code. Der sauberste und vor allem sicherste Weg ist die Verwendung von snprintf :

char buf[256];
snprintf(buf, sizeof(buf), "%s%s%s%s", str1, str2, str3, str4);

Einige Kommentatoren wiesen darauf hin, dass die Anzahl der Argumente möglicherweise nicht mit der Formatzeichenkette übereinstimmt und der Code trotzdem kompiliert werden kann, aber die meisten Compiler geben in diesem Fall bereits eine Warnung aus.

Answer 3

Strings können auch zur Kompilierzeit verkettet werden.

#define SCHEMA "test"
#define TABLE  "data"

const char *table = SCHEMA "." TABLE ; // note no + or . or anything
const char *qry =               // include comments in a string
    " SELECT * "                // get all fields
    " FROM " SCHEMA "." TABLE   /* the table */
    " WHERE x = 1 "             /* the filter */ 
                ;

Answer 4

Leute, benutzt str n cpy(), str n cat(), oder s n printf().
Ein Überschreiten des Pufferspeichers wird alles andere im Speicher zerstören!
(Und denken Sie daran, Platz für die abschließende Null zu lassen ' \0 ' Zeichen!)

Answer 5

Auch malloc und realloc sind nützlich, wenn man nicht im Voraus weiß, wie viele Zeichenketten verkettet werden sollen.

#include <stdio.h>
#include <string.h>

void example(const char *header, const char **words, size_t num_words)
{
    size_t message_len = strlen(header) + 1; /* + 1 for terminating NULL */
    char *message = (char*) malloc(message_len);
    strncat(message, header, message_len);

    for(int i = 0; i < num_words; ++i)
    {
       message_len += 1 + strlen(words[i]); /* 1 + for separator ';' */
       message = (char*) realloc(message, message_len);
       strncat(strncat(message, ";", message_len), words[i], message_len);
    }

    puts(message);

    free(message);
}