¿Anexar Char a la cadena en C?

¿Cómo agrego un solo carácter a una cadena en C?

es decir

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

char* str = "blablabla";     

No debe modificar esta cadena en absoluto. Reside en la región de solo lectura definida por la implementación. Modificarlo provoca Comportamiento indefinido.

Necesita una matriz de caracteres, no un literal de cadena.

Buena lectura:
¿Cuál es la diferencia entre char a[] = “cadena”; y char *p = “cadena”;

Para agregar un carácter a una cadena en C, primero debe asegurarse de que el búfer de memoria que contiene la cadena sea lo suficientemente grande como para acomodar un carácter adicional. En su programa de ejemplo, tendría que asignar un nuevo bloque de memoria adicional porque la cadena literal dada no se puede modificar.

Aquí hay una muestra:

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

Primer uso malloc para asignar una nueva porción de memoria que sea lo suficientemente grande como para acomodar todos los caracteres de la cadena de entrada, el carácter adicional para agregar, y el cero final. Luego llame strcpy para copiar la cadena de entrada en el nuevo búfer. Finalmente, cambie los últimos dos bytes en el nuevo búfer para agregar el carácter que se agregará, así como el cero final.

Si le preocupa Linux, la forma más fácil de agregar dos cadenas:

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

Esto no funcionará con MS Visual C.

Nota: tienes que free() el recuerdo devuelto por asprintf()

No creo que puedas declarar una cadena como esa en c. Solo puede hacer eso para const char* y, por supuesto, no puede modificar un const char * ya que es const.

Puede usar una matriz de caracteres dinámicos, pero tendrá que encargarse de la reasignación.

EDITAR: de hecho, esta sintaxis se compila correctamente. Aún así, no debe modificar a qué apunta str si se inicializa de la forma en que lo hace (desde el literal de cadena)

El póster original no pretendía escribir:

  char* str = "blablabla";

pero

  char str[128] = "blablabla";

Ahora, agregar un solo carácter parecería más eficiente que agregar una cadena completa con strcat. Yendo por el camino directo, podrías:

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

pero también puede escribir fácilmente su propia función (como lo han hecho varios antes que yo):

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

Crear una nueva cadena (cadena + carácter)

#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]

No altere el tamaño de la matriz ([len +1]etc.) sin saber su tamaño exacto, puede dañar otros datos. alloc una matriz con el nuevo tamaño y coloque los datos antiguos dentro, recuerde que, para una matriz char, el último valor debe ser \0; calloc() establece todos los valores en \0que es excelente para char arreglos

Espero que esto ayude.

C no tiene cadenas per se; lo que tiene es un puntero de caracteres que apunta a alguna memoria de solo lectura que contiene los caracteres “blablabla\0”. Para agregar un carácter allí, necesita a) memoria de escritura yb) suficiente espacio para la cadena en su nueva forma. El literal de cadena “blablabla\0” no tiene ninguno.

Las soluciones son:

1) Uso malloc() et al. para asignar memoria dinámicamente. (No olvides free() después.)
2) Use una matriz de caracteres.

Cuando trabaje con cadenas, considere usar strn* variantes de la str* funciones: le ayudarán a mantenerse dentro de los límites de la memoria.