Bagaimana cara menggabungkan string const / literal dalam C?

Saya bekerja di C, dan saya harus menggabungkan beberapa hal.

Sekarang saya punya ini:

message = strcat("TEXT ", var);

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

Sekarang jika Anda memiliki pengalaman dalam C Saya yakin Anda menyadari bahwa ini memberi Anda kesalahan segmentasi ketika Anda mencoba menjalankannya. Jadi bagaimana saya mengatasinya?

Dalam C, "string" hanyalah chararray biasa . Oleh karena itu, Anda tidak dapat langsung menyatukannya dengan "string" lainnya.

Anda dapat menggunakan strcatfungsi, yang menambahkan string yang ditunjuk oleh srchingga akhir string yang ditunjuk oleh dest:

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

Berikut ini contoh dari cplusplus.com :

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

Untuk parameter pertama, Anda perlu menyediakan buffer tujuan itu sendiri. Buffer tujuan harus berupa buffer array char. Misalnya:char buffer[1024];

Pastikan parameter pertama memiliki cukup ruang untuk menyimpan apa yang Anda coba salin ke dalamnya. Jika tersedia untuk Anda, lebih aman untuk menggunakan fungsi-fungsi seperti: strcpy_sdan di strcat_smana Anda secara eksplisit harus menentukan ukuran buffer tujuan.

Catatan : String literal tidak dapat digunakan sebagai buffer, karena itu adalah konstanta. Dengan demikian, Anda selalu harus mengalokasikan array char untuk buffer.

Nilai kembalian dari strcathanya bisa diabaikan, itu hanya mengembalikan pointer yang sama seperti yang diteruskan sebagai argumen pertama. Itu ada untuk kenyamanan, dan memungkinkan Anda untuk menghubungkan panggilan menjadi satu baris kode:

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

Jadi masalah Anda bisa diselesaikan sebagai berikut:

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

Hindari penggunaan strcatdalam kode C. Cara paling bersih dan yang paling penting, paling aman adalah menggunakan snprintf:

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

Beberapa komentator mengajukan masalah bahwa jumlah argumen mungkin tidak cocok dengan format string dan kode masih akan dikompilasi, tetapi sebagian besar kompiler sudah mengeluarkan peringatan jika ini masalahnya.

Teman-teman, gunakan str n cpy (), str n cat (), atau s n printf ().
Melebihi ruang buffer Anda akan membuang apa pun yang mengikuti di memori!
(Dan ingatlah untuk memberikan ruang untuk karakter nol '\ 0' yang tertinggal!)

String juga dapat digabungkan pada waktu kompilasi.

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

Juga malloc dan realloc berguna jika Anda tidak tahu sebelumnya berapa banyak string yang digabungkan.

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

Jangan lupa untuk menginisialisasi buffer output. Argumen pertama untuk strcat harus berupa string yang diakhiri dengan nol dengan cukup ruang tambahan yang dialokasikan untuk string yang dihasilkan:

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

Seperti yang ditunjukkan orang, penanganan string meningkat pesat. Jadi, Anda mungkin ingin mempelajari cara menggunakan pustaka string C ++ alih-alih string gaya-C. Namun di sini ada solusi dalam C murni

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

Saya tidak yakin apakah itu benar / aman tetapi saat ini saya tidak dapat menemukan cara yang lebih baik untuk melakukan ini di ANSI C.

Ini adalah perilaku yang tidak terdefinisi untuk mencoba memodifikasi string literal, yang merupakan sesuatu seperti:

strcat ("Hello, ", name);

akan berusaha melakukan. Ini akan mencoba untuk menempelkan namestring ke akhir string literal "Hello, ", yang tidak didefinisikan dengan baik.

Coba sesuatu ini. Ini mencapai apa yang Anda coba lakukan:

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

Hal ini menciptakan daerah penyangga yang sudah diperbolehkan untuk dimodifikasi dan kemudian salinan kedua literal tali dan teks lain untuk itu. Berhati-hatilah dengan buffer overflows. Jika Anda mengontrol data input (atau mengeceknya sebelumnya), boleh saja menggunakan buffer dengan panjang tetap seperti yang saya miliki.

Jika tidak, Anda harus menggunakan strategi mitigasi seperti mengalokasikan cukup memori dari heap untuk memastikan Anda bisa mengatasinya. Dengan kata lain, sesuatu seperti:

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.

Argumen pertama dari strcat () harus dapat menampung ruang yang cukup untuk string bersambung. Jadi alokasikan buffer dengan ruang yang cukup untuk menerima hasilnya.

char bigEnough[64] = "";

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

/* and so on */

strcat () akan menggabungkan argumen kedua dengan argumen pertama, dan menyimpan hasilnya dalam argumen pertama, char * yang dikembalikan hanyalah argumen pertama ini, dan hanya untuk kenyamanan Anda.

Anda tidak mendapatkan string yang baru dialokasikan dengan argumen pertama dan kedua, yang saya kira Anda harapkan berdasarkan kode Anda.

Cara terbaik untuk melakukannya tanpa memiliki ukuran buffer terbatas adalah dengan menggunakan asprintf ()

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

Jika Anda memiliki pengalaman dalam C, Anda akan melihat bahwa string hanya array char di mana karakter terakhir adalah karakter nol.

Sekarang itu cukup merepotkan karena Anda harus menemukan karakter terakhir untuk menambahkan sesuatu. strcatakan melakukannya untuk Anda.

Jadi strcat mencari argumen pertama untuk karakter null. Maka itu akan menggantikan ini dengan konten argumen kedua (sampai berakhir pada nol).

Sekarang mari kita telusuri kode Anda:

message = strcat("TEXT " + var);

Di sini Anda menambahkan sesuatu ke pointer ke teks "TEXT" (tipe "TEXT" adalah const char *. Sebuah pointer.).

Itu biasanya tidak akan berhasil. Juga memodifikasi array "TEXT" tidak akan berfungsi karena biasanya ditempatkan di segmen konstan.

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

Itu mungkin bekerja lebih baik, kecuali bahwa Anda lagi mencoba mengubah teks statis. strcat tidak mengalokasikan memori baru untuk hasilnya.

Saya akan mengusulkan untuk melakukan sesuatu seperti ini sebagai gantinya:

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

Baca dokumentasi sprintf untuk memeriksa opsi itu.

Dan sekarang poin penting:

Pastikan buffer memiliki cukup ruang untuk menampung teks DAN karakter nol. Ada beberapa fungsi yang dapat membantu Anda, misalnya, strncat dan versi khusus printf yang mengalokasikan buffer untuk Anda. Tidak memastikan ukuran buffer akan menyebabkan kerusakan memori dan bug yang dapat dieksploitasi dari jarak jauh.

Anda dapat menulis fungsi Anda sendiri yang melakukan hal yang sama strcat()tetapi tidak mengubah apa pun:

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

Jika kedua string bersama lebih dari 1000 karakter, itu akan memotong string pada 1000 karakter. Anda dapat mengubah nilai MAX_STRING_LENGTHsesuai dengan kebutuhan Anda.

Dengan anggapan Anda memiliki char [fix_size] daripada char *, Anda dapat menggunakan makro kreatif tunggal untuk melakukan semuanya sekaligus dengan <<cout<<likepemesanan ("bukan% s% s yang terputus-putus", "daripada", "printf format gaya "). Jika Anda bekerja dengan sistem embedded, metode ini juga akan memungkinkan Anda untuk meninggalkan malloc dan *printfkeluarga besar fungsi seperti snprintf()(Ini menjaga dietlibc dari mengeluh tentang * printf juga)

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

• Catatan 1, Anda biasanya tidak akan menggunakan argv [0] seperti ini - hanya sebuah contoh
• Catatan 2, Anda dapat menggunakan fungsi apa pun yang menghasilkan karakter *, termasuk fungsi tidak standar seperti itoa () untuk mengubah bilangan bulat menjadi tipe string.
• Catatan 3, jika Anda sudah menggunakan printf di mana saja dalam program Anda, tidak ada alasan untuk tidak menggunakan snprintf (), karena kode yang dikompilasi akan lebih besar (tetapi sebaris dan secara signifikan lebih cepat)

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

Anda mencoba menyalin string ke alamat yang dialokasikan secara statis. Anda harus memasukkan buffer ke dalam buffer.

Secara khusus:

...menggunting...

tujuan

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

...menggunting...

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

Ada contoh di sini juga.

Ini solusi saya

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

tetapi Anda perlu menentukan berapa banyak string yang akan Anda gabungkan

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

Coba sesuatu yang mirip dengan ini:

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