Añadir char a cadena en C?

Question

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

Answer 1

char* str = "blablabla";  

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

Necesita una matriz de caracteres no una cadena literal.

Buena lectura:
What is the difference between char a[] = "string"; and char *p = "string";

Answer 2

no creo que se puede declarar una cadena como la de c. Solo puede hacer eso para const char * y, por supuesto, no puede modificar un const char *, ya que es const.

Usted puede utilizar matriz de caracteres dinámico, pero que tendrá que hacerse cargo de la reasignación.

EDITAR: de hecho, esta sintaxis se compila correctamente. Todavía no se puede modificar lo que debe str puntos a si se ha inicializado en la forma que lo hace (de cadena literal)

Answer 3

para anexar un char a una cadena en C, primero hay que asegurarse de que el búfer de memoria que contiene la cadena es lo suficientemente grande 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.

He aquí una muestra:

#include <stdlib.h> 

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

    size_t len = strlen(str); 
    char *str2 = malloc(len + 1 + 1); /* one for extra char, one for trailing zero */ 
    strcpy(str2, str); 
    str2[len] = c; 
    str2[len + 1] = '\0'; 

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

    free(str2); 
} 

En primer lugar, utilizar malloc para asignar un nuevo trozo de memoria que es lo suficientemente grande como para dar cabida a todos los caracteres de la cadena de entrada, el carbón extra para anexar - y el cero final. Luego llame al strcpy para copiar la cadena de entrada en el nuevo buffer. Finalmente, cambie los últimos dos bytes en el nuevo buffer para virar el carácter que se agregará así como el cero final.

Answer 4

C no tiene cuerdas per se - lo que tienes es un puntero que apunta char a parte de la memoria de sólo lectura que contiene los caracteres "blablabla \ 0". Para agregar un carácter allí, necesita a) memoria grabable yb) suficiente espacio para la cadena en su nueva forma. La cadena literal "blablabla \ 0" no tiene ninguno.

Las soluciones son:

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

Al trabajar con cadenas, considere utilizar las variantes strn* de las funciones str*, que le ayudarán a mantenerse dentro de los límites de la memoria.

Answer 5

aquí es, que funciona al 100%

char* appending(char *cArr, const char c) 

{ 

int len = strlen(cArr); 

cArr[len + 1] = cArr[len]; 

cArr[len] = c; 

return cArr; 


} 

Answer 6

manera más fácil de añadir dos cadenas:

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

Answer 7

crear una nueva cadena (string + Char)

#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 modifique el tamaño de la matriz ([len +1], etc.) sin saberlo s tamaño exacto, puede dañar otros datos. alloc una matriz con el nuevo tamaño y poner los datos antiguos dentro, recuerde que, para una matriz de caracteres, el último valor debe ser \0; calloc() establece todos los valores en \0, que es excelente para las matrices char.

Espero que esto ayude.

Answer 8

El cartel original no tenía intención de escribir:

char* str = "blablabla"; 

pero

char str[128] = "blablabla"; 

Ahora, la adición de un solo carácter parecería más eficiente que la adición de toda una cadena con strcat. va por el camino strcat, podrías:

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

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

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

Answer 9

En mi caso, esta era la mejor solución he encontrado:

snprintf(str, sizeof str, "%s%c", str, c); 

Answer 10

en C++, sólo tiene que añadir un char a un string por:

int main() 
{ 
    std::string s = "Hello there"; 
    char c = '?'; 
    s = s+c; 
    std::cout << s << std::endl; 
    return 0; 
}