ฉันจะต่อสตริง const / literal ใน C ได้อย่างไร

ฉันทำงานใน C และฉันต้องต่อสิ่งเล็ก ๆ น้อย ๆ

ตอนนี้ฉันมีสิ่งนี้:

message = strcat("TEXT ", var);

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

ตอนนี้ถ้าคุณมีประสบการณ์ใน C ฉันมั่นใจว่าคุณรู้ว่านี่เป็นข้อผิดพลาดในการแบ่งส่วนเมื่อคุณพยายามเรียกใช้ ดังนั้นฉันจะแก้ไขได้อย่างไร

ใน C "strings" เป็นเพียง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ในรหัส C วิธีที่ปลอดภัยที่สุดและที่สำคัญที่สุดคือวิธีใช้ที่ปลอดภัยที่สุดsnprintf:

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

ผู้แสดงความคิดเห็นบางคนหยิบยกปัญหาที่จำนวนข้อโต้แย้งอาจไม่ตรงกับสตริงรูปแบบและรหัสจะยังคงรวบรวม แต่คอมไพเลอร์ส่วนใหญ่ออกคำเตือนแล้วถ้าเป็นกรณีนี้

คนใช้ STR n cpy (), STR nแมว () หรือ s n printf ()
การเกินพื้นที่บัฟเฟอร์ของคุณจะทำลายสิ่งอื่นใดในหน่วยความจำ!
(และอย่าลืมเว้นช่องว่างสำหรับตัวอักษร "\ 0" ที่ต่อท้าย!)

สตริงสามารถต่อกันได้ในเวลาคอมไพล์

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

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

อย่าลืมเตรียมใช้งานบัฟเฟอร์ผลลัพธ์ อาร์กิวเมนต์แรกของ strcat ต้องเป็นสตริงที่สิ้นสุดด้วยค่า null ซึ่งมีพื้นที่พิเศษเพียงพอที่จัดสรรให้กับสตริงผลลัพธ์:

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

ในขณะที่ผู้คนชี้ให้เห็นการจัดการสตริงที่ดีขึ้น ดังนั้นคุณอาจต้องการเรียนรู้วิธีใช้ไลบรารีสตริง 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

มันเป็นพฤติกรรมที่ไม่ได้กำหนดเพื่อพยายามแก้ไขตัวอักษรสตริงซึ่งเป็นสิ่งที่ชอบ:

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 ที่ส่งคืนเป็นเพียงอาร์กิวเมนต์แรกนี้และเพื่อความสะดวกของคุณเท่านั้น

คุณไม่ได้รับสตริงที่จัดสรรใหม่โดยมีอาร์กิวเมนต์ตัวแรกและตัวที่สองมาต่อกันซึ่งฉันเดาว่าคุณคาดหวังตามรหัสของคุณ

วิธีที่ดีที่สุดในการทำโดยไม่มีขนาดบัฟเฟอร์ที่ จำกัด คือใช้ asprintf ()

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

หากคุณมีประสบการณ์ใน C คุณจะสังเกตเห็นว่าสายอักขระเป็นเพียงอาร์เรย์ถ่านที่ตัวละครตัวสุดท้ายเป็นตัวละคร null

ตอนนี้มันค่อนข้างไม่สะดวกเท่าที่คุณต้องหาตัวละครตัวสุดท้ายเพื่อที่จะต่อท้ายบางอย่าง strcatจะทำเพื่อคุณ

ดังนั้น strcat ค้นหาอาร์กิวเมนต์แรกสำหรับอักขระ null จากนั้นจะแทนที่สิ่งนี้ด้วยเนื้อหาของอาร์กิวเมนต์ที่สอง (จนกว่าจะสิ้นสุดลงในค่า null)

ตอนนี้เรามาดูโค้ดของคุณกัน:

message = strcat("TEXT " + var);

ที่นี่คุณกำลังเพิ่มบางสิ่งในตัวชี้ไปยังข้อความ "TEXT" (ประเภทของ "TEXT" คือ const char *. ตัวชี้)

ที่มักจะไม่ทำงาน การแก้ไขอาเรย์ของ "TEXT" จะไม่ทำงานเนื่องจากมันมักจะอยู่ในเซ็กเมนต์ค่าคงที่

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

สิ่งนี้อาจทำงานได้ดีขึ้นยกเว้นคุณพยายามแก้ไขข้อความคงที่อีกครั้ง strcat ไม่ได้จัดสรรหน่วยความจำใหม่สำหรับผลลัพธ์

ฉันจะเสนอให้ทำสิ่งนี้แทน:

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

อ่านเอกสารของsprintfเพื่อตรวจสอบตัวเลือก

และตอนนี้จุดสำคัญ:

ตรวจสอบให้แน่ใจว่าบัฟเฟอร์มีพื้นที่เพียงพอที่จะเก็บข้อความและอักขระ null มีฟังก์ชั่นสองสามอย่างที่สามารถช่วยคุณได้เช่น strncat และ printf รุ่นพิเศษที่จัดสรรบัฟเฟอร์ให้คุณ การไม่มั่นใจขนาดบัฟเฟอร์จะนำไปสู่ความเสียหายของหน่วยความจำและบั๊กที่หาประโยชน์ได้จากระยะไกล

คุณสามารถเขียนฟังก์ชั่นของคุณเองที่ทำสิ่งเดียวกัน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;
}

หากทั้งสองสายรวมกันมีความยาวมากกว่า 1,000 ตัวอักษรก็จะตัดสายที่ 1,000 ตัว คุณสามารถเปลี่ยนค่าของMAX_STRING_LENGTHให้เหมาะกับความต้องการของคุณ

สมมติว่าคุณมีอักขระ [fixed_size] แทนที่จะเป็น char * คุณสามารถใช้มาโครเดียวที่สร้างสรรค์เพื่อทำสิ่งทั้งหมดพร้อมกันด้วยการ<<cout<<likeสั่งซื้อ ("แทนที่จะเป็น% s ผู้ที่แยก% s \ n", "มากกว่า", "printf รูปแบบสไตล์ ") หากคุณกำลังทำงานกับระบบฝังตัววิธีนี้จะช่วยให้คุณสามารถละ malloc และ*printfฟังก์ชั่นมากมายเช่นsnprintf()(ซึ่งจะช่วยลดความอ้วน Dietlibc จากบ่นเกี่ยวกับ * 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 คุณสามารถใช้ฟังก์ชันใด ๆ ที่ส่งออกอักขระ char * รวมถึงฟังก์ชันที่ไม่เป็นมาตรฐานเช่น itoa () สำหรับการแปลงจำนวนเต็มเป็นชนิดสตริง
• หมายเหตุ 3 หากคุณใช้ printf อยู่แล้วในโปรแกรมของคุณไม่มีเหตุผลที่จะไม่ใช้ snprintf () เนื่องจากโค้ดที่คอมไพล์จะมีขนาดใหญ่กว่า (แต่ถูกแทรกและเร็วกว่ามาก)

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

คุณพยายามคัดลอกสตริงไปยังที่อยู่ที่ได้รับการจัดสรรแบบคงที่ คุณต้อง cat เป็นบัฟเฟอร์

โดยเฉพาะ:

... บุคคลที่ไม่สำคัญ ...

ปลายทาง

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

มีตัวอย่างที่นี่เช่นกัน

นี่คือทางออกของฉัน

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

ลองทำสิ่งที่คล้ายกับสิ่งนี้:

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