Как мне объединить константные / буквальные строки в C?

В C «строки» - это просто массивы char. Следовательно, вы не можете напрямую связать их с другими «строками».

Вы можете использовать функцию strcat, которая добавляет строку, на которую указывает src, в конец строки, на которую указывает dest:

char *strcat(char *dest, const char *src);

Вот пример с cplusplus.com:

char str[80];
strcpy(str, "these ");
strcat(str, "strings ");
strcat(str, "are ");
strcat(str, "concatenated.");

Для первого параметра вам необходимо указать сам буфер назначения. Целевой буфер должен быть буфером массива символов. Например: char buffer[1024];

Убедись, что у первого параметра достаточно места для хранения того, что вы пытаетесь скопировать в него. Если это возможно, безопаснее использовать такие функции, как strcpy_s и strcat_s, где вы должны явно указать размер целевого буфера.

Примечание: строковый литерал нельзя использовать в качестве буфера, поскольку он является константой. Таким образом, вам всегда нужно выделять массив символов для буфера.

Возвращаемое значение strcat можно просто игнорировать, оно просто возвращает тот же указатель, который был передан в качестве первого аргумента. Это сделано для удобства и позволяет объединить вызовы в одну строку кода:

strcat(strcat(str, foo), bar);

Итак, ваша проблема может быть решена следующим образом:

char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);

Попытка изменить строковые литералы является неопределенным поведением, что примерно так:

strcat ("Hello, ", name);

постараюсь сделать. Он попытается прикрепить строку name к концу строкового литерала "Hello, ", который не определен должным образом.

Попробуйте что-нибудь вот это. Он достигает того, что вы пытаетесь сделать:

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

Это создает буферную область, которую разрешено изменять является, а затем копирует в нее строковый литерал и другой текст. Только будьте осторожны с переполнением буфера. Если вы контролируете входные данные (или проверяете их заранее), можно использовать буферы фиксированной длины, как у меня.

В противном случае вам следует использовать стратегии смягчения, такие как выделение достаточного количества памяти из кучи, чтобы гарантировать, что вы сможете справиться с этим. Другими словами, что-то вроде:

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.

Первый аргумент strcat () должен иметь достаточно места для объединенной строки. Итак, выделите буфер с достаточным пространством для получения результата.

char bigEnough[64] = "";

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

/* and so on */

strcat () объединит второй аргумент с первым аргументом и сохранит результат в первом аргументе, возвращаемый char * - это просто этот первый аргумент и только для вашего удобства.

Вы не получаете вновь выделенную строку с объединенными первым и вторым аргументами, чего, как я полагаю, вы ожидали, основываясь на своем коде.

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

Конкретно:

... отрезать ...

назначения

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

... отрезать ...

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

Здесь тоже есть пример.

Избегайте использования strcat в коде C. Самый чистый и, главное, безопасный способ - использовать snprintf:

char buf[256];
snprintf(buf, sizeof buf, "%s%s%s%s", str1, str2, str3, str4);

Некоторые комментаторы подняли вопрос о том, что количество аргументов может не соответствовать строке формата, и код все равно будет компилироваться, но большинство компиляторов уже выдают предупреждение, если это так.

Если у вас есть опыт работы с C, вы заметите, что строки представляют собой только массивы символов, в которых последний символ является нулевым символом.

Это довольно неудобно, так как вам нужно найти последний символ, чтобы что-то добавить. strcat сделает это за вас.

Таким образом, strcat ищет в первом аргументе нулевой символ. Затем он заменит это содержимым второго аргумента (до тех пор, пока это не закончится нулевым значением).

Теперь пройдемся по вашему коду:

message = strcat("TEXT " + var);

Здесь вы что-то добавляете к указателю на текст «ТЕКСТ» (тип «ТЕКСТ» - const char *. Указатель.).

Обычно это не работает. Также не сработает изменение массива «ТЕКСТ», поскольку он обычно помещается в постоянный сегмент.

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

Это может сработать лучше, за исключением того, что вы снова пытаетесь изменить статические тексты. strcat не выделяет новую память для результата.

Я бы предложил вместо этого сделать что-то вроде этого:

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

Прочтите документацию sprintf, чтобы проверить его возможности.

А теперь важный момент:

Убедитесь, что в буфере достаточно места для хранения текста И нулевого символа. Есть несколько функций, которые могут вам помочь, например, strncat и специальные версии printf, которые выделяют буфер для вас. Необеспечение размера буфера приведет к повреждению памяти и ошибкам, которые можно использовать удаленно.

Друзья, используйте strпcpy (), strпcat () или sпprintf ().
Превышение вашего буферного пространства приведет к удалению всего остального в памяти!
(И не забудьте оставить место для завершающего нулевого символа '\ 0'!)

Не забудьте инициализировать выходной буфер. Первым аргументом strcat должна быть строка с завершающим нулем и достаточным дополнительным пространством, выделенным для результирующей строки:

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

Также malloc и realloc полезны, если вы заранее не знаете, сколько строк объединяется.

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

Как отмечали люди, обработка строк значительно улучшилась. Так что вы можете узнать, как использовать строковую библиотеку C++ вместо строк в стиле C. Однако вот решение в чистом 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;
}

Я не уверен, правильно ли это / безопасно, но сейчас я не мог найти лучшего способа сделать это в ANSI C.

Лучший способ сделать это без ограниченного размера буфера - использовать asprintf ()

char* concat(const char* str1, const char* str2)
{
    char* result;
    asprintf(&result, "%s%s", str1, str2);
    return result;
}

Попробуйте что-нибудь подобное:

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

Предполагая, что у вас есть char [fixed_size], а не char *, вы можете использовать один творческий макрос, чтобы сделать все сразу с упорядочением <<cout<<like («скорее% s несвязный% s \ n», «чем», » формат стиля printf "). Если вы работаете со встроенными системами, этот метод также позволит вам исключить malloc и большое семейство функций *printf, например, snprintf() (это также не позволяет диетической библиотеке жаловаться на * printf)

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

• Примечание 1, вы обычно не используете argv [0] в таком виде - просто пример
• Примечание 2, вы можете использовать любую функцию, которая выводит символ *, включая нестандартные функции, такие как itoa (), для преобразования целых чисел в строковые типы.
• Примечание 3: если вы уже используете printf где-либо в своей программе, нет причин не использовать snprintf (), поскольку скомпилированный код будет больше (но встроен и значительно быстрее)

Строки также могут быть объединены во время компиляции.

#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 */ 
                ;

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

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

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

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

Это было мое решение

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

но вам нужно указать, сколько строк вы собираетесь объединить

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