Jak połączyć łańcuchy stałe / literalne w C?

Pracuję w C i muszę połączyć kilka rzeczy.

Teraz mam to:

message = strcat("TEXT ", var);

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

Teraz, jeśli masz doświadczenie w C, jestem pewien, że zdajesz sobie sprawę, że to powoduje błąd segmentacji, gdy próbujesz go uruchomić. Jak mam to obejść?

W C „ciągi” są zwykłymi chartablicami. Dlatego nie można bezpośrednio łączyć ich z innymi „ciągami”.

Możesz użyć strcatfunkcji, która dodaje ciąg wskazany przez srcna końcu ciągu wskazanego przez dest:

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

Oto przykład z cplusplus.com :

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

W przypadku pierwszego parametru musisz podać sam bufor docelowy. Bufor docelowy musi być buforem tablicy znaków. Na przykład:char buffer[1024];

Upewnij się, że pierwszy parametr ma wystarczającą ilość miejsca do zapisania w nim tego, co próbujesz skopiować. Jeśli jest to dostępne, bezpieczniej jest używać funkcji takich jak: strcpy_si strcat_sgdzie wyraźnie musisz określić rozmiar bufora docelowego.

Uwaga : Literału łańcuchowego nie można użyć jako bufora, ponieważ jest on stałą. Dlatego zawsze musisz przydzielić tablicę char dla bufora.

Zwracaną wartość strcatmożna po prostu zignorować, po prostu zwraca ten sam wskaźnik, który został przekazany jako pierwszy argument. Jest tam dla wygody i pozwala łączyć połączenia w jedną linię kodu:

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

Twój problem można rozwiązać w następujący sposób:

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

Unikaj używania strcatw kodzie C. Najczystszym i, co najważniejsze, najbezpieczniejszym sposobem jest użycie snprintf:

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

Niektórzy komentatorzy podnieśli problem, że liczba argumentów może nie pasować do ciągu formatu, a kod nadal będzie się kompilował, ale większość kompilatorów już wydaje ostrzeżenie, jeśli tak jest.

Ludzie, użyj str n cpy (), str n cat () lub s n printf ().
Przekroczenie przestrzeni bufora spowoduje usunięcie wszystkiego, co nastąpi w pamięci!
(I pamiętaj, aby pozostawić miejsce na końcowy znak zerowy „\ 0”!)

Ciągi można także łączyć w czasie kompilacji.

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

Również malloc i realloc są przydatne, jeśli nie wiesz z góry, ile łańcuchów jest konkatenowanych.

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

Nie zapomnij zainicjować bufora wyjściowego. Pierwszym argumentem dla strcat musi być łańcuch zakończony znakiem null z wystarczającą ilością miejsca przeznaczonego dla łańcucha wynikowego:

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

Jak zauważyli ludzie, znacznie poprawiła się obsługa łańcuchów. Możesz więc chcieć nauczyć się korzystać z biblioteki ciągów C ++ zamiast ciągów w stylu C. Jednak tutaj jest rozwiązanie w czystym 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;
}

Nie jestem pewien, czy jest to poprawne / bezpieczne, ale w tej chwili nie mogłem znaleźć lepszego sposobu na zrobienie tego w ANSI C.

Niezdefiniowanym zachowaniem jest próba modyfikacji literałów łańcuchowych, co jest coś takiego:

strcat ("Hello, ", name);

spróbuje to zrobić. Spróbuje przyczepić nameciąg do końca dosłownego ciągu "Hello, ", który nie jest dobrze zdefiniowany.

Spróbuj czegoś takiego. Osiąga to, co próbujesz zrobić:

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

To tworzy obszar buforowy, który jest dozwolony zostać zmodyfikowane, a następnie kopiuje zarówno ciągiem znaków i inne teksty do niego. Uważaj tylko na przepełnienia bufora. Jeśli kontrolujesz dane wejściowe (lub sprawdzasz je wcześniej), możesz użyć buforów o stałej długości, takich jak ja.

W przeciwnym razie należy zastosować strategie ograniczania ryzyka, takie jak przydzielenie wystarczającej ilości pamięci ze sterty, aby mieć pewność, że można ją obsłużyć. Innymi słowy, coś takiego:

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.

Pierwszy argument strcat () musi być w stanie pomieścić wystarczającą ilość miejsca na połączony ciąg. Przydziel więc bufor z wystarczającą ilością miejsca, aby otrzymać wynik.

char bigEnough[64] = "";

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

/* and so on */

strcat () połączy drugi argument z pierwszym argumentem i zapisze wynik w pierwszym argumencie, zwrócony char * jest po prostu pierwszym argumentem i tylko dla twojej wygody.

Nie otrzymujesz nowo przydzielonego ciągu z połączonym pierwszym i drugim argumentem, który, jak sądzę, oczekiwałeś na podstawie twojego kodu.

Najlepszym sposobem na to bez ograniczonego rozmiaru bufora jest użycie asprintf ()

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

Jeśli masz doświadczenie w C, zauważysz, że ciągi znaków są tylko tablicami znaków, w których ostatni znak jest znakiem pustym.

Jest to dość niewygodne, ponieważ musisz znaleźć ostatnią postać, aby coś dodać. strcatzrobi to za ciebie.

Zatem strcat przeszukuje pierwszy argument pod kątem znaku zerowego. Następnie zastąpi to treścią drugiego argumentu (dopóki nie zakończy się na null).

Teraz przejdźmy do twojego kodu:

message = strcat("TEXT " + var);

Tutaj dodajesz coś do wskaźnika do tekstu „TEKST” (typ „TEKST” to const char *. Wskaźnik.).

To zwykle nie zadziała. Również modyfikacja tablicy „TEKST” nie będzie działać, ponieważ zwykle jest umieszczana w stałym segmencie.

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

To może działać lepiej, z tym wyjątkiem, że ponownie próbujesz zmodyfikować teksty statyczne. strcat nie przydziela nowej pamięci dla wyniku.

Zamiast tego zaproponowałbym coś takiego:

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

Przeczytaj dokumentację, sprintfaby sprawdzić dostępne opcje.

A teraz ważny punkt:

Upewnij się, że bufor ma wystarczającą ilość miejsca do przechowywania tekstu ORAZ znaku null. Istnieje kilka funkcji, które mogą ci pomóc, np. Strncat i specjalne wersje printf, które przydzielają ci bufor. Brak zapewnienia rozmiaru bufora spowoduje uszkodzenie pamięci i zdalne błędy, które można wykorzystać.

Możesz napisać własną funkcję, która robi to samo, strcat()ale nic nie zmienia:

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

Jeśli oba łańcuchy razem mają więcej niż 1000 znaków, spowoduje to odcięcie łańcucha na 1000 znaków. Możesz zmienić wartość według MAX_STRING_LENGTHwłasnych potrzeb.

Zakładając, że masz char [fixed_size] zamiast char *, możesz użyć pojedynczego, kreatywnego makra, aby zrobić to wszystko jednocześnie z <<cout<<likezamówieniem („raczej% s rozłączony% s \ n”, „niż”, „printf format stylu ”). Jeśli pracujesz z systemami wbudowanymi, ta metoda pozwoli ci również pominąć malloc i dużą *printfrodzinę funkcji takich jak snprintf()(To powstrzymuje dietlibc przed narzekaniem na * printf też)

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

• Uwaga 1, zwykle nie używasz argv [0] w ten sposób - tylko przykład
• Uwaga 2, możesz użyć dowolnej funkcji, która wypisuje znak char *, w tym niestandardowych funkcji, takich jak itoa () do konwersji liczb całkowitych na typy łańcuchowe.
• Uwaga 3, jeśli już używasz printf w dowolnym miejscu w swoim programie, nie ma powodu, aby nie używać snprintf (), ponieważ skompilowany kod byłby większy (ale wstawiany i znacznie szybszy)

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

Próbujesz skopiować ciąg na adres przydzielony statycznie. Musisz kot w buforze.

Konkretnie:

...fantastyczna okazja...

Miejsce docelowe

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

...fantastyczna okazja...

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

Jest tu także przykład.

To było moje rozwiązanie

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

ale musisz określić, ile ciągów chcesz połączyć

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

Spróbuj czegoś podobnego do tego:

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