C dilinde const / literal dizeleri nasıl birleştirebilirim?

C ile çalışıyorum ve birkaç şeyi birleştirmem gerekiyor.

Şu anda bu var:

message = strcat("TEXT ", var);

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

Şimdi C tecrübeniz varsa, eminim çalıştırmaya çalıştığınızda bunun size bir segmentasyon hatası verdiğini anlıyorsunuz. Öyleyse nasıl çalışacağım?

C'de "dizeler" sadece düz chardizilerdir. Bu nedenle, bunları doğrudan diğer "dizelerle" birleştiremezsiniz.

Sen kullanabilirsiniz strcattarafından işaret dizesini ekler işlevi, srctarafından işaret dizisinin sonuna dest:

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

İşte cplusplus.com'dan bir örnek :

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

İlk parametre için, hedef arabelleğinin kendisini sağlamanız gerekir. Hedef arabelleği bir char dizi arabelleği olmalıdır. Örneğin:char buffer[1024];

İlk parametrenin, kopyalamaya çalıştığınız şeyi depolamak için yeterli alana sahip olduğundan emin olun . Size sunulan, bu gibi işlevleri kullanmak güvenlidir: strcpy_sve strcat_saçıkça hedef tampon boyutunu belirtmek zorunda nerede.

Not : Bir dize hazır bilgisi, sabit olduğu için tampon olarak kullanılamaz. Bu nedenle, her zaman arabellek için bir char dizisi ayırmanız gerekir.

Dönüş değeri strcatyok sayılabilir, yalnızca ilk argümanla aynı işaretçiyi döndürür. Kolaylık sağlamak için oradadır ve aramaları bir kod satırında zincirlemenizi sağlar:

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

Böylece probleminiz şu şekilde çözülebilir:

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

strcatC kodunda kullanmaktan kaçının . En temiz ve en önemlisi, en güvenli yol snprintf:

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

Bazı yorumcular, argüman sayısının biçim dizesiyle eşleşmeyebileceği ve kodun hala derleneceği konusunda bir sorun ortaya koydu, ancak bu durumda çoğu derleyici zaten bir uyarı verir.

Millet, str n cpy (), str n cat () veya s n printf () kullanın.
Arabellek alanınızı aşmanız, bellekte takip edenleri çöpe atacaktır!
(Ve sonunda boş '\ 0' karakteri için yer bırakmayı unutmayın!)

Dizeler derleme zamanında birleştirilebilir.

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

Ayrıca, kaç dizenin birleştirildiğini önceden bilmiyorsanız, malloc ve realloc yararlıdır.

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

Çıktı tamponunu başlatmayı unutmayın. Strcat için ilk argüman, sonuçta elde edilen dize için yeterli fazladan boşluk bırakılmış boş bir sonlandırılmış dize olmalıdır:

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

İnsanlar işaret ettikleri gibi ip kullanımı çok gelişti. Bu nedenle, C stili dizeler yerine C ++ dize kitaplığını nasıl kullanacağınızı öğrenmek isteyebilirsiniz. Ancak burada saf 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;
}

Doğru / güvenli olup olmadığından emin değilim ama şu anda bunu ANSI C'de yapmanın daha iyi bir yolunu bulamadım.

Dize değişmezlerini değiştirmeye çalışmak tanımlanmamış bir davranıştır;

strcat ("Hello, ", name);

yapmaya çalışır. nameDize "Hello, ", iyi tanımlanmamış dize hazır bilgisinin sonuna kadar tutturmaya çalışacaktır .

Bunu bir şey deneyin. Yapmaya çalıştığınız şeyi başarır:

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

Bu bir tampon alanı oluşturur edilir daha sonra dize ve ona diğer metinleri hem kopya değiştirilmiş ve izin. Sadece arabellek taşmalarına dikkat edin. Giriş verilerini kontrol ederseniz (veya önceden kontrol ederseniz), benim gibi sabit uzunluklu tamponlar kullanmakta fayda var.

Aksi takdirde, işleyebilmeniz için yığından yeterli bellek ayırma gibi azaltma stratejilerini kullanmalısınız. Başka bir deyişle, şöyle bir şey:

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 () yönteminin ilk argümanı, birleştirilmiş dize için yeterli alan tutabilmelidir. Sonuç almak için yeterli alana sahip bir tampon tahsis edin.

char bigEnough[64] = "";

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

/* and so on */

strcat (), ikinci argümanı ilk argümanla birleştirir ve sonucu ilk argümanda saklar, döndürülen char * sadece bu ilk argümandır ve sadece sizin rahatınız içindir.

İlk ve ikinci argüman birleştirilmiş yeni bir dize alamazsınız, ki bu sizin kodunuza göre beklediğiniz tahmin ediyorum.

Sınırlı bir arabellek boyutu olmadan yapmanın en iyi yolu asprintf () kullanmaktır

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

C'de deneyiminiz varsa, dizelerin yalnızca son karakterin boş karakter olduğu karakter dizileri olduğunu fark edeceksiniz.

Şimdi bir şey eklemek için son karakteri bulmak zorunda oldukça rahatsız edici. strcatbunu sizin için yapacak.

Böylece strcat ilk argümanda boş bir karakter arar. Daha sonra bunu ikinci argümanın içeriği ile değiştirir (bu bir null ile bitene kadar).

Şimdi kodunuzu inceleyelim:

message = strcat("TEXT " + var);

Burada işaretçiye "TEXT" metnine bir şey ekliyorsunuz ("TEXT" tipi const char *. Bir işaretçi.).

Bu genellikle işe yaramaz. Ayrıca "TEXT" dizisini değiştirmek genellikle sabit bir segmente yerleştirildiği için çalışmaz.

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

Statik metinleri tekrar değiştirmeye çalışmanız dışında bu daha iyi sonuç verebilir. strcat sonuç için yeni bellek ayırmıyor.

Bunun yerine böyle bir şey yapmayı öneriyorum:

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

sprintfSeçeneklerini kontrol etmek için dokümanlarını okuyun .

Ve şimdi önemli bir nokta:

Arabellek metni VE null karakteri tutmak için yeterli alana sahip olduğundan emin olun. Size yardımcı olabilecek birkaç işlev vardır, örneğin strncat ve tamponu sizin için ayıran özel printf sürümleri. Arabellek boyutunun sağlanmaması bellek bozulmasına ve uzaktan istismar edilebilir hatalara yol açacaktır.

Aynı şeyi yapan strcat()ama hiçbir şeyi değiştirmeyen kendi fonksiyonunuzu yazabilirsiniz :

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

Her iki dize birlikte 1000 karakterden uzunsa, dizeyi 1000 karakterden keser. Değerini MAX_STRING_LENGTHihtiyaçlarınıza göre değiştirebilirsiniz.

Char * yerine char [fixed_size] karakteriniz olduğunu varsayarsak, hepsini bir <<cout<<likesiparişle yapmak için tek bir, yaratıcı makro kullanabilirsiniz ("," printf yerine "% s ayrık% s \ n", " biçem biçimi "). Gömülü sistemlerle çalışıyorsanız, bu yöntem ayrıca malloc ve geniş *printfişlev ailesini dışarıda bırakmanıza izin verecektir snprintf()(Bu, dietlibc'nin * printf hakkında da şikayet etmesini engeller)

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

• Not 1, genellikle böyle bir argv [0] kullanmazsınız - sadece bir örnek
• Not 2'de, tam sayıları dize türlerine dönüştürmek için itoa () gibi standart olmayan işlevler de dahil olmak üzere bir char * çıkaran herhangi bir işlevi kullanabilirsiniz.
• Not 3, zaten programınızda herhangi bir yerde printf kullanıyorsanız, derlenmiş kod daha büyük (ancak satır içi ve çok daha hızlı) olacağından snprintf () kullanmamanın bir nedeni yoktur.

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

Bir dizeyi statik olarak ayrılmış bir adrese kopyalamaya çalışıyorsunuz. Bir tampon içine kedi gerekir.

özellikle:

... kesik ...

hedef

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

... kesik ...

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

Burada da bir örnek var.

Bu benim çözümümdü

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

ancak kaç dizeyi birleştireceğinizi belirtmeniz gerekir

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

Buna benzer bir şey deneyin:

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