Wie verkette ich Const/Literal-Strings in C?

Ich arbeite in C und muss ein paar Dinge verketten.

Momentan habe ich das:

message = strcat("TEXT ", var);

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

Wenn Sie Erfahrung in C haben, bin ich mir sicher, dass Sie erkennen, dass dies zu einem Segmentierungsfehler führt, wenn Sie versuchen, es auszuführen. Wie kann ich das umgehen?

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

Du kannst den … benutzen strcat Funktion, die die Zeichenfolge anhängt, auf die gezeigt wird src bis zum Ende der Zeichenfolge, auf die gezeigt wird 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 bereitstellen. Der Zielpuffer muss ein Char-Array-Puffer sein. Z.B: char buffer[1024];

Vergewissere dich dass der erste Parameter genügend Platz hat, um das zu speichern, was Sie hineinkopieren möchten. Falls für Sie verfügbar, ist es sicherer, Funktionen zu verwenden wie: strcpy_s und strcat_s wobei Sie die Größe des Zielpuffers explizit angeben müssen.

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

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

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

Dein 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);

Vermeide das Benutzen strcat im C-Code. Der sauberste und vor allem sicherste Weg ist die Anwendung snprintf:

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

Einige Kommentatoren haben ein Problem angesprochen, dass die Anzahl der Argumente möglicherweise nicht mit der Formatzeichenfolge übereinstimmt und der Code trotzdem kompiliert wird, aber die meisten Compiler geben bereits eine Warnung aus, wenn dies der Fall ist.

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 */ 
                ;

Leute, benutzt strncpy(), strncat() oder snprintf().

Wenn Sie Ihren Pufferspeicher überschreiten, wird alles andere im Speicher zerstört!

(Und denken Sie daran, Platz für das abschließende Nullzeichen ‘\0’ zu lassen!)

Auch malloc und realloc sind nützlich, wenn Sie nicht im Voraus wissen, wie viele Zeichenfolgen verkettet werden.

#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);
}

Der beste Weg, dies ohne eine begrenzte Puffergröße zu tun, ist die Verwendung von asprintf()

char* concat(const char* str1, const char* str2)
{
    char* result;
    asprintf(&result, "%s%s", str1, str2);
    return result;
}

Vergessen Sie nicht, den Ausgabepuffer zu initialisieren. Das erste Argument für strcat muss eine nullterminierte Zeichenfolge mit genügend zusätzlichem Platz für die resultierende Zeichenfolge sein:

char out[1024] = ""; // must be initialized
strcat( out, null_terminated_string ); 
// null_terminated_string has less than 1023 chars