Добавить символ к строке в C?

Чтобы добавить символ char к строке в C, сначала необходимо убедиться, что буфер памяти, содержащий строку, достаточно велик, чтобы вместить дополнительный символ. В вашем примере программы вам придется выделить новый, дополнительный блок памяти, потому что данная литеральная строка не может быть изменена.

Вот пример:

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

Во-первых, используйте malloc чтобы выделить новый кусок памяти, достаточно большой, чтобы вместить все символы входной строки, необходимо добавить дополнительный символ - и последний ноль. Тогда звони strcpy чтобы скопировать входную строку в новый буфер. Наконец, измените последние два байта в новом буфере, чтобы прикрепить символ для добавления, а также конечный ноль.

Я не думаю, что вы можете объявить такую строку в c. Вы можете сделать это только для const char* и, конечно, вы не можете изменить const char*, поскольку это const.

Вы можете использовать динамический массив символов, но вам придется позаботиться о перераспределении.

EDIT: фактически этот синтаксис компилируется правильно. Тем не менее, вы не можете изменить то, на что указывает str, если он инициализирован так, как вы это делаете (из строкового литерала)

Самый простой способ добавить две строки:

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

Оригинальный плакат не собирался писать:

  char* str = "blablabla";

Но

  char str[128] = "blablabla";

Теперь добавление одного символа кажется более эффективным, чем добавление целой строки с помощью strcat. Идя по пути strcat, вы можете:

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

Но вы также можете легко написать свою собственную функцию (как некоторые делали до меня):

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

Создайте новую строку (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]

Не изменяйте размер массива ([len +1] и т. д.) не зная его точного размера, он может повредить другие данные. alloc массив с новым размером и поместите вместо него старые данные, помните, что для массива char последнее значение должно быть \0; calloc() устанавливает все значения в \0, что отлично подходит для массивов char.

Надеюсь, это поможет.

C не имеет строк как таковых - у вас есть указатель char, указывающий на некоторую память только для чтения, содержащую символы "blablabla\0". Чтобы добавить туда символ, вам потребуется а) доступная для записи память и Б) достаточно места для строки в ее новом виде. Строковый литерал "blablabla\0" не имеет ни того, ни другого.

Решения следующие:

1) Использовать malloc() и др. для динамического выделения памяти. (Не забудьте free() потом.)
2) Используйте массив символов.

При работе с строки, рассмотрите возможность использования strn* вариантов функций str* - они помогут вам оставаться в пределах памяти.

В моем случае это было лучшее решение, которое я нашел:

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

Вот оно, работает 100%

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

{

int len = strlen(cArr);

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

cArr[len] = c;

return cArr;


}

В C++ вы можете просто добавить char к string с помощью:

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