Char an String in C anhängen?

Wie hänge ich ein einzelnes Zeichen an eine Zeichenfolge in C an?

dh

char* str = "blablabla";
char c="H";
str_append(str,c); /* blablablaH */

Um in C ein Zeichen an einen String anzuhängen, müssen Sie zunächst sicherstellen, dass der Speicherpuffer, der den String enthält, groß genug ist, um ein zusätzliches Zeichen aufzunehmen. In Ihrem Beispielprogramm müssten Sie einen neuen, zusätzlichen Speicherblock zuweisen, da die angegebene Literalzeichenfolge nicht geändert werden kann.

Hier ist ein Beispiel:

#include <stdlib.h>

int main()
{
    char *str = "blablabla";
    char c="H";

    size_t len = strlen(str);
   
    /* one for extra char, one for trailing zero */
    char *str2 = malloc(len + 1 + 1);

    strcpy(str2, str);
    str2[len] = c;
    str2[len + 1] = '\0';

    printf("%s\n", str2); /* prints "blablablaH" */

    free(str2);
}

Erste Benutzung malloc um einen neuen Speicherplatz zuzuweisen, der groß genug ist, um alle Zeichen der Eingabezeichenfolge, das anzuhängende zusätzliche Zeichen und die abschließende Null aufzunehmen. Dann ruf an strcpy um die Eingabezeichenfolge in den neuen Puffer zu kopieren. Ändern Sie schließlich die letzten beiden Bytes im neuen Puffer, um das hinzuzufügende Zeichen sowie die nachgestellte Null anzuheften.

char* str = "blablabla";     

Sie sollten diese Zeichenfolge überhaupt nicht ändern. Es befindet sich in einer implementierungsdefinierten Nur-Lese-Region. Das Ändern verursacht Undefiniertes Verhalten.

Sie benötigen ein Char-Array, kein String-Literal.

Gute Lektüre:
Was ist der Unterschied zwischen char a[] = “Zeichenfolge”; und char *p = “string”;

Das Originalplakat wollte nicht schreiben:

  char* str = "blablabla";

aber

  char str[128] = "blablabla";

Nun scheint das Hinzufügen eines einzelnen Zeichens effizienter zu sein als das Hinzufügen einer ganzen Zeichenfolge mit strcat. Wenn Sie den Strcat-Weg gehen, könnten Sie:

  char tmpstr[2];
  tmpstr[0] = c;
  tmpstr[1] = 0;
  strcat (str, tmpstr);

Sie können aber auch ganz einfach Ihre eigene Funktion schreiben (wie es mehrere vor mir getan haben):

  void strcat_c (char *str, char c)
  {
    for (;*str;str++); // note the terminating semicolon here. 
    *str++ = c; 
    *str++ = 0;
  }

Wenn Linux Ihr Anliegen ist, können Sie am einfachsten zwei Zeichenfolgen anhängen:

char * append(char * string1, char * string2)
{
    char * result = NULL;
    asprintf(&result, "%s%s", string1, string2);
    return result;
}

Dies funktioniert nicht mit MS Visual C.

Notiz: Sie müssen free() die Erinnerung zurückgegeben von asprintf()

Ich glaube nicht, dass Sie eine solche Zeichenfolge in c deklarieren können. Sie können das nur für const char* tun und natürlich können Sie ein const char * nicht ändern, da es const ist.

Sie können ein dynamisches Zeichenarray verwenden, müssen sich jedoch um die Neuzuweisung kümmern.

BEARBEITEN: Tatsächlich wird diese Syntax korrekt kompiliert. Trotzdem können Sie nicht ändern, worauf str zeigt, wenn es so initialisiert wird, wie Sie es tun (aus dem String-Literal).

Erstellen Sie eine neue Zeichenfolge (Zeichenfolge + Zeichen)

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

#define ERR_MESSAGE__NO_MEM "Not enough memory!"
#define allocator(element, type) _allocator(element, sizeof(type))

/** Allocator function (safe alloc) */
void *_allocator(size_t element, size_t typeSize)
{
    void *ptr = NULL;
    /* check alloc */
    if( (ptr = calloc(element, typeSize)) == NULL)
    {printf(ERR_MESSAGE__NO_MEM); exit(1);}
    /* return pointer */
    return ptr;
}

/** Append function (safe mode) */
char *append(const char *input, const char c)
{
    char *newString, *ptr;

    /* alloc */
    newString = allocator((strlen(input) + 2), char);
    /* Copy old string in new (with pointer) */
    ptr = newString;
    for(; *input; input++) {*ptr = *input; ptr++;}
    /* Copy char at end */
    *ptr = c;
    /* return new string (for dealloc use free().) */
    return newString;
}

/** Program main */
int main (int argc, const char *argv[])
{
    char *input = "Ciao Mondo"; // i am italian :), this is "Hello World"
    char c="!";
    char *newString;

    newString = append(input, c);
    printf("%s\n",newString);
    /* dealloc */
    free(newString);
    newString = NULL;

    exit(0);
}

              0   1   2   3    4    5   6   7   8   9  10   11
newString is [C] [i] [a] [o] [\32] [M] [o] [n] [d] [o] [!] [\0]

Ändern Sie nicht die Array-Größe ([len +1]etc.) ohne genaue Größe zu kennen, kann es andere Daten beschädigen. alloc ein Array mit der neuen Größe erstellen und stattdessen die alten Daten einfügen, denken Sie daran, dass für ein char-Array der letzte Wert sein muss \0; calloc() setzt alle Werte auf \0das ist ausgezeichnet für char Arrays.

Ich hoffe das hilft.

C hat per se keine Strings – was Sie haben, ist ein char-Zeiger, der auf einen Nur-Lese-Speicher zeigt, der die Zeichen “blablabla\0” enthält. Um dort ein Zeichen anzuhängen, benötigen Sie a) beschreibbaren Speicher und b) genügend Platz für den String in seiner neuen Form. Das String-Literal “blablabla\0” hat beides nicht.

Die Lösungen sind:

1) Verwenden malloc() et al. Speicher dynamisch zuzuweisen. (Nicht vergessen free() danach.)
2) Verwenden Sie ein Zeichenarray.

Wenn Sie mit Zeichenfolgen arbeiten, sollten Sie die Verwendung von in Betracht ziehen strn* Varianten der str* Funktionen — sie helfen Ihnen, innerhalb der Speichergrenzen zu bleiben.