Wie verkette ich konstante / literale Zeichenfolgen in C?

Ich arbeite in C und muss ein paar Dinge verketten.

Im Moment habe ich Folgendes:

message = strcat("TEXT ", var);

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

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

In C sind "Strings" nur einfache charArrays. Daher können Sie sie nicht direkt mit anderen "Zeichenfolgen" verketten.

Sie können die strcatFunktion verwenden, mit der die Zeichenfolge, auf die von gezeigt wird, srcan das Ende der Zeichenfolge angehängt wird, auf die gezeigt wird von 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];

Stellen Sie sicher, dass der erste Parameter genügend Speicherplatz hat, um zu speichern, was Sie in ihn kopieren möchten. Wenn zur Verfügung, ist es sicherer , Funktionen zu verwenden wie: strcpy_sund strcat_swo Sie müssen explizit die Größe des Zielpuffers angeben.

Hinweis : Ein Zeichenfolgenliteral 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 strcatkann einfach ignoriert werden, er gibt lediglich den gleichen Zeiger zurück, der als erstes Argument übergeben wurde. Es dient der Bequemlichkeit und ermöglicht es Ihnen, die Anrufe in einer 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);

Vermeiden Sie die Verwendung strcatin C-Code. Der sauberste und vor allem sicherste Weg ist 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 weiterhin kompiliert wird. Die meisten Compiler geben jedoch bereits eine Warnung aus, wenn dies der Fall ist.

Leute, verwenden Sie str n cpy (), str n cat () oder s n printf ().
Wenn Sie Ihren Pufferplatz überschreiten, wird alles andere im Speicher gelöscht!
(Und denken Sie daran, Platz für das nachfolgende Nullzeichen '\ 0' zu lassen!)

Zeichenfolgen können auch zur Kompilierungszeit 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 */ 
                ;

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

Vergessen Sie nicht, den Ausgabepuffer zu initialisieren. Das erste Argument für strcat muss eine nullterminierte Zeichenfolge sein, der genügend zusätzlicher Speicherplatz für die resultierende Zeichenfolge zugewiesen ist:

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

Wie die Leute betonten, verbesserte sich das Saitenhandling erheblich. Vielleicht möchten Sie lernen, wie Sie die C ++ - Zeichenfolgenbibliothek anstelle von Zeichenfolgen im C-Stil verwenden. Hier ist jedoch eine Lösung in reinem C.

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

void appendToHello(const char *s) {
    const char *const hello = "hello ";

    const size_t sLength     = strlen(s);
    const size_t helloLength = strlen(hello);
    const size_t totalLength = sLength + helloLength;

    char *const strBuf = malloc(totalLength + 1);
    if (strBuf == NULL) {
        fprintf(stderr, "malloc failed\n");
        exit(EXIT_FAILURE);
    }

    strcpy(strBuf, hello);
    strcpy(strBuf + helloLength, s);

    puts(strBuf);

    free(strBuf);

}

int main (void) {
    appendToHello("blah blah");
    return 0;
}

Ich bin nicht sicher, ob es richtig / sicher ist, aber im Moment könnte ich in ANSI C keinen besseren Weg finden, dies zu tun.

Es ist ein undefiniertes Verhalten, zu versuchen, Zeichenfolgenliterale zu ändern.

strcat ("Hello, ", name);

werde versuchen zu tun. Es wird versucht, die nameZeichenfolge bis zum Ende des Zeichenfolgenliteral anzuheften"Hello, " , das nicht genau definiert ist.

Probieren Sie etwas aus. Es erreicht das, was Sie zu versuchen scheinen:

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

Dies erzeugt einen Pufferbereich, der ist verändert und kopiert dann sowohl die Stringliteral und anderen Text ihm erlaubt sein. Seien Sie vorsichtig mit Pufferüberläufen. Wenn Sie die Eingabedaten steuern (oder vorher überprüfen), ist es in Ordnung, Puffer mit fester Länge wie ich zu verwenden.

Andernfalls sollten Sie Schadensbegrenzungsstrategien verwenden, z. B. die Zuweisung von genügend Speicher aus dem Heap, um sicherzustellen, dass Sie damit umgehen können. Mit anderen Worten, so etwas wie:

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.

Das erste Argument von strcat () muss genügend Speicherplatz für die verkettete Zeichenfolge enthalten. Weisen Sie also einen Puffer mit genügend Speicherplatz zu, um das Ergebnis zu erhalten.

char bigEnough[64] = "";

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

/* and so on */

strcat () verkettet das zweite Argument mit dem ersten Argument und speichert das Ergebnis im ersten Argument. Das zurückgegebene Zeichen * ist einfach dieses erste Argument und nur zur Vereinfachung.

Sie erhalten keine neu zugewiesene Zeichenfolge mit dem ersten und zweiten verketteten Argument, was Sie aufgrund Ihres Codes wahrscheinlich erwartet hätten.

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

Wenn Sie Erfahrung mit C haben, werden Sie feststellen, dass Zeichenfolgen nur Zeichenarrays sind, bei denen das letzte Zeichen ein Nullzeichen ist.

Das ist ziemlich unpraktisch, da Sie das letzte Zeichen finden müssen, um etwas anzuhängen. strcatwerde das für dich tun.

Strcat durchsucht also das erste Argument nach einem Nullzeichen. Dann wird dies durch den Inhalt des zweiten Arguments ersetzt (bis dies mit einer Null endet).

Lassen Sie uns nun Ihren Code durchgehen:

message = strcat("TEXT " + var);

Hier fügen Sie dem Zeiger etwas auf den Text "TEXT" hinzu (der Typ von "TEXT" ist const char *. Ein Zeiger.).

Das wird normalerweise nicht funktionieren. Auch das Ändern des "TEXT" -Arrays funktioniert nicht, da es normalerweise in einem konstanten Segment platziert wird.

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

Das könnte besser funktionieren, außer dass Sie erneut versuchen, statische Texte zu ändern. strcat weist dem Ergebnis keinen neuen Speicher zu.

Ich würde stattdessen vorschlagen, so etwas zu tun:

sprintf(message2, "TEXT %s TEXT %s", foo, bar);

Lesen Sie die Dokumentation von sprintf, um die Optionen zu überprüfen.

Und jetzt ein wichtiger Punkt:

Stellen Sie sicher, dass im Puffer genügend Speicherplatz für den Text UND das Nullzeichen vorhanden ist. Es gibt einige Funktionen, die Ihnen helfen können, z. B. strncat und spezielle Versionen von printf, die den Puffer für Sie zuweisen. Wenn die Puffergröße nicht sichergestellt wird, führt dies zu Speicherbeschädigungen und aus der Ferne ausnutzbaren Fehlern.

Sie können Ihre eigene Funktion schreiben, die dasselbe tut wie strcat(), aber nichts ändert:

#define MAX_STRING_LENGTH 1000
char *strcat_const(const char *str1,const char *str2){
    static char buffer[MAX_STRING_LENGTH];
    strncpy(buffer,str1,MAX_STRING_LENGTH);
    if(strlen(str1) < MAX_STRING_LENGTH){
        strncat(buffer,str2,MAX_STRING_LENGTH - strlen(buffer));
    }
    buffer[MAX_STRING_LENGTH - 1] = '\0';
    return buffer;
}

int main(int argc,char *argv[]){
    printf("%s",strcat_const("Hello ","world"));    //Prints "Hello world"
    return 0;
}

Wenn beide Zeichenfolgen zusammen mehr als 1000 Zeichen lang sind, wird die Zeichenfolge auf 1000 Zeichen gekürzt. Sie können den Wert von MAX_STRING_LENGTHan Ihre Bedürfnisse anpassen.

Angenommen, Sie haben ein Zeichen [fixed_size] anstelle eines Zeichens *, können Sie ein einzelnes kreatives Makro verwenden, um alles auf einmal mit einer <<cout<<likeBestellung zu erledigen ("eher% s das disjunkte% s \ n", "als", "printf Stilformat "). Wenn Sie mit eingebetteten Systemen arbeiten, können Sie mit dieser Methode auch malloc und die große *printfFunktionsfamilie wie snprintf()(Dies verhindert, dass dietlibc sich auch über * printf beschwert) weglassen.

#include <unistd.h> //for the write example
//note: you should check if offset==sizeof(buf) after use
#define strcpyALL(buf, offset, ...) do{ \
    char *bp=(char*)(buf+offset); /*so we can add to the end of a string*/ \
    const char *s, \
    *a[] = { __VA_ARGS__,NULL}, \
    **ss=a; \
    while((s=*ss++)) \
         while((*s)&&(++offset<(int)sizeof(buf))) \
            *bp++=*s++; \
    if (offset!=sizeof(buf))*bp=0; \
}while(0)

char buf[256];
int len=0;

strcpyALL(buf,len,
    "The config file is in:\n\t",getenv("HOME"),"/.config/",argv[0],"/config.rc\n"
);
if (len<sizeof(buf))
    write(1,buf,len); //outputs our message to stdout
else
    write(2,"error\n",6);

//but we can keep adding on because we kept track of the length
//this allows printf-like buffering to minimize number of syscalls to write
//set len back to 0 if you don't want this behavior
strcpyALL(buf,len,"Thanks for using ",argv[0],"!\n");
if (len<sizeof(buf))
    write(1,buf,len); //outputs both messages
else
    write(2,"error\n",6);

• Hinweis 1: Normalerweise würden Sie argv [0] nicht so verwenden - nur ein Beispiel
• Hinweis 2: Sie können jede Funktion verwenden, die ein Zeichen * ausgibt, einschließlich nicht standardmäßiger Funktionen wie itoa (), um Ganzzahlen in Zeichenfolgentypen zu konvertieren.
• Hinweis 3: Wenn Sie printf bereits an einer beliebigen Stelle in Ihrem Programm verwenden, gibt es keinen Grund, snprintf () nicht zu verwenden, da der kompilierte Code größer (aber inline und erheblich schneller) wäre.

int main()
{
    char input[100];
    gets(input);

    char str[101];
    strcpy(str, " ");
    strcat(str, input);

    char *p = str;

    while(*p) {
       if(*p == ' ' && isalpha(*(p+1)) != 0)
           printf("%c",*(p+1));
       p++;
    }

    return 0;
}

Sie versuchen, eine Zeichenfolge in eine statisch zugewiesene Adresse zu kopieren. Sie müssen in einen Puffer katzen.

Speziell:

... schnipsen ...

Ziel

Pointer to the destination array, which should contain a C string, and be large enough to contain the concatenated resulting string.

... schnipsen ...

http://www.cplusplus.com/reference/clibrary/cstring/strcat.html

Auch hier gibt es ein Beispiel.

Das war meine Lösung

#include <stdlib.h>
#include <stdarg.h>

char *strconcat(int num_args, ...) {
    int strsize = 0;
    va_list ap;
    va_start(ap, num_args);
    for (int i = 0; i < num_args; i++) 
        strsize += strlen(va_arg(ap, char*));

    char *res = malloc(strsize+1);
    strsize = 0;
    va_start(ap, num_args);
    for (int i = 0; i < num_args; i++) {
        char *s = va_arg(ap, char*);
        strcpy(res+strsize, s);
        strsize += strlen(s);
    }
    va_end(ap);
    res[strsize] = '\0';

    return res;
}

Sie müssen jedoch angeben, wie viele Zeichenfolgen Sie verketten möchten

char *str = strconcat(3, "testing ", "this ", "thing");

Versuchen Sie etwas Ähnliches:

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

int main(int argc, const char * argv[])
{
  // Insert code here...
  char firstname[100], secondname[100];
  printf("Enter First Name: ");
  fgets(firstname, 100, stdin);
  printf("Enter Second Name: ");
  fgets(secondname,100,stdin);
  firstname[strlen(firstname)-1]= '\0';
  printf("fullname is %s %s", firstname, secondname);

  return 0;
}