C字符串字符串

Question

內的多個替代可以說我有一個字符串：

"(aaa and bbb or (aaa or aaa or bbb))" 

**爲了簡單起見，這將永遠是字符串的格式，總是3 A的後面有一個空格或「 ）'或3b的後面跟一個空格或'）'。

這將是與「1」和everyoccurrence的「BBB」與「0」 C.取代「AAA」的每一次出現結束字符串應該像最好的辦法：

"(1 and 0 or (1 or 1 or 0))" 

編輯讓我更具體：

char* blah = (char *) malloc (8); 
sprintf(blah, "%s", "aaa bbb"); 

blah = replace(blah); 

我怎麼能寫替代，使其分配空間和存儲新的字符串

"1 0" 

Answer 1

最有效的方法是使用POSIX的正則表達式系列。一些實現將爲這些模式構建適當的自動機。另一種方法是反覆使用KMP或Boyer-Moore搜索，但必須多次掃描字符串，效率較低。另外，你想要什麼結果給出這樣的輸入：aa = 1，ab = 2，bb = 3在字符串「aabb」上？

順便說一下，當你實現這個功能時，更簡潔的解決方案是分配一個新的動態C字符串，而不是在替換時修改原始字符串。您可以實施就地更換，但這會更復雜。

regex_t r; regmatch_t match[2]; int last = 0; 
regcomp(&r, "(aaa|bbb)", REG_EXTENDED); 
insert(hashtable, "aaa", "0"); insert(hashtable, "bbb", "1"); 
while (regexec(&r, oristr, 1, match, 0) != REG_NOMATCH) { 
    char *val; 
    strncat(newstr, oristr + last, match->rm_so); 
    lookup(hashtable, oristr + match->rm_so, match->rm_eo - match->rm_so, &val); 
    last = match->rm_eo; 
    strncat(newstr, val); 
} 
strcat(newstr, oristr + last); 
oristr = realloc(oristr, strlen(newstr)); 
strcpy(oristr, newstr); free(newstr); regfree(&r); 

在實際實現中，應該動態改變newstr的大小。你應該記錄newstr的結束，而不是使用strcat/strlen。源代碼可能是越野車，因爲我沒有真正嘗試過。但是這個想法就在那裏。這是我能想到的最有效的實現。

Answer 2

對於這個特定的情況，一個簡單的while/for循環可以做到這一點。但它看起來像一個家庭作業問題，所以我不會爲你明確寫出它。如果需要更多的通用字符串操作，我會使用pcre。

Answer 3

您可以使用函數std::find和std::replace爲每個替換嘗試循環。 你會發現更多關於std :: string here的信息。

Answer 4

這絕不是世界上最優雅的解決方案，它也假定結尾字符串總是比原始字體小，哦，我對轉換進行了硬編碼，但希望它能指出您或多或少在正確的方向或者給你一個想法，從跳下：

char* replace(char *string) { 
    char *aaa = NULL; 
    char *bbb = NULL; 
    char *buffer = malloc(strlen(string)); 
    int length = 0; 
    aaa = strstr(string, "aaa"); 
    bbb = strstr(string, "bbb"); 
    while (aaa || bbb) { 
     if (aaa && (bbb || aaa < bbb)) { 
      char startToHere = aaa - string; 
      strncpy(buffer, string, startToHere); 
      string += startToHere; 
      length += startToHere; 
      buffer[length] = '1'; 
     } 
     else if (bbb) { 
      char startToHere = aaa - string; 
      strncpy(buffer, string, startToHere); 
      string += startToHere; 
      length += startTohere; 
      buffer[length] = '0'; 
     } 
     aaa = strstr(string, "aaa"); 
     bbb = strstr(string, "bbb"); 
    } 
    buffer[length] = '\0'; 
    string = realloc(string, length); 
    strcpy(string, buffer); 
    free(buffer); 

    return string; 
} 

聲明，我甚至沒有對此進行測試，但它應該是在你想要的方向上至少半。

Answer 5

這是FSM的工作！

#include <assert.h> 
#include <stdio.h> 
#include <string.h> 

/* 
//  | 0   | 1    | 2    | 3    | 4    | 
// ----+------------+---------------+----------------+---------------+----------------+ 
// 'a' | 1   | 2    | ('1') 0  | ('b') 1  | ('bb') 1  | 
// 'b' | 3   | ('a') 3  | ('aa') 3  | 4    | ('0') 0  | 
// NUL | (NUL) halt | ('a'NUL) halt | ('aa'NUL) halt | ('b'NUL) halt | ('bb'NUL) halt | 
// (*) | (*) 0  | ('a'*) 0  | ('aa'*) 0  | ('b'*) 0  | ('bb'*) 0  | 
*/ 

void chg_data(char *src) { 
    char *dst, ch; 
    int state = 0; 
    dst = src; 
    for (;;) { 
    ch = *src++; 
    if (ch == 'a' && state == 0) {state=1;} 
    else if (ch == 'a' && state == 1) {state=2;} 
    else if (ch == 'a' && state == 2) {state=0; *dst++='1';} 
    else if (ch == 'a' && state == 3) {state=1; *dst++='b';} 
    else if (ch == 'a' && state == 4) {state=1; *dst++='b'; *dst++='b';} 
    else if (ch == 'b' && state == 0) {state=3;} 
    else if (ch == 'b' && state == 1) {state=3; *dst++='a';} 
    else if (ch == 'b' && state == 2) {state=3; *dst++='a'; *dst++='a';} 
    else if (ch == 'b' && state == 3) {state=4;} 
    else if (ch == 'b' && state == 4) {state=0; *dst++='0';} 
    else if (ch == '\0' && state == 0) {*dst++='\0'; break;} 
    else if (ch == '\0' && state == 1) {*dst++='a'; *dst++='\0'; break;} 
    else if (ch == '\0' && state == 2) {*dst++='a'; *dst++='a'; *dst++='\0'; break;} 
    else if (ch == '\0' && state == 3) {*dst++='b'; *dst++='\0'; break;} 
    else if (ch == '\0' && state == 4) {*dst++='b'; *dst++='b'; *dst++='\0'; break;} 
    else if (state == 0) {state=0; *dst++=ch;} 
    else if (state == 1) {state=0; *dst++='a'; *dst++=ch;} 
    else if (state == 2) {state=0; *dst++='a'; *dst++='a'; *dst++=ch;} 
    else if (state == 3) {state=0; *dst++='b'; *dst++=ch;} 
    else if (state == 4) {state=0; *dst++='b'; *dst++='b'; *dst++=ch;} 
    else assert(0 && "this didn't happen!"); 
    } 
} 

int main(void) { 
    char data[] = "(aaa and bbb or (aaa or aaa or bbb))"; 
    printf("Before: %s\n", data); 
    chg_data(data); 
    printf(" After: %s\n", data); 
    return 0; 
} 

Answer 6

這是沒有內存限制：

#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 

/* --------------------------------------------------------------------------- 
    Name  : replace - Search & replace a substring by another one. 
    Creation : Thierry Husson, Sept 2010 
    Parameters : 
     str : Big string where we search 
     oldstr : Substring we are looking for 
     newstr : Substring we want to replace with 
     count : Optional pointer to int (input/output value). NULL to ignore. 
       Input: Maximum replacements to be done. NULL or < 1 to do all. 
       Output: Number of replacements done or -1 if not enough memory. 
    Returns : Pointer to the new string or NULL if error. 
    Notes  : 
    - Case sensitive - Otherwise, replace functions "strstr" by "strcasestr" 
    - Always allocate memory for the result. 
--------------------------------------------------------------------------- */ 
char* replace(const char *str, const char *oldstr, const char *newstr, int *count) 
{ 
    const char *tmp = str; 
    char *result; 
    int found = 0; 
    int length, reslen; 
    int oldlen = strlen(oldstr); 
    int newlen = strlen(newstr); 
    int limit = (count != NULL && *count > 0) ? *count : -1; 

    tmp = str; 
    while ((tmp = strstr(tmp, oldstr)) != NULL && found != limit) 
     found++, tmp += oldlen; 

    length = strlen(str) + found * (newlen - oldlen); 
    if ((result = (char *)malloc(length+1)) == NULL) { 
     fprintf(stderr, "Not enough memory\n"); 
     found = -1; 
    } else { 
     tmp = str; 
     limit = found; /* Countdown */ 
     reslen = 0; /* length of current result */ 
     /* Replace each old string found with new string */ 
     while ((limit-- > 0) && (tmp = strstr(tmp, oldstr)) != NULL) { 
     length = (tmp - str); /* Number of chars to keep intouched */ 
     strncpy(result + reslen, str, length); /* Original part keeped */ 
     strcpy(result + (reslen += length), newstr); /* Insert new string */ 
     reslen += newlen; 
     tmp += oldlen; 
     str = tmp; 
     } 
     strcpy(result + reslen, str); /* Copies last part and ending nul char */ 
    } 
    if (count != NULL) *count = found; 
    return result; 
} 


/* --------------------------------------------------------------------------- 
    Samples 
--------------------------------------------------------------------------- */ 
int main(void) 
{ 
    char *str, *str2; 
    int rpl; 

    /* ---------------------------------------------------------------------- */ 
    /* Simple sample */ 
    rpl = 0; /* Illimited replacements */ 
    str = replace("Hello World!", "World", "Canada", &rpl); 
    printf("Replacements: %d\tResult: [%s]\n\n", rpl, str); 
    /* Replacements: 1  Result: [Hello Canada!] */ 
    free(str); 

    /* ---------------------------------------------------------------------- */ 
    /* Sample with dynamic memory to clean */ 
    rpl = 0; /* Illimited replacements */ 
    str = strdup("abcdef"); 
    if ((str2 = replace(str, "cd", "1234", &rpl)) != NULL) { 
     free(str); 
     str = str2; 
    } 
    printf("Replacements: %d\tResult: [%s]\n\n", rpl, str); 
    /* Replacements: 1  Result: [ab1234ef] */ 
    free(str); 

    /* ---------------------------------------------------------------------- */ 
    /* Illimited replacements - Case sensitive & Smaller result */ 
    str = replace("XXXHello XXXX world XX salut xxx monde!XXX", "XXX", "-",NULL); 
    printf("Result: [%s]\n\n", str); 
    /* Result: [-Hello -X world XX salut xxx monde!-] */ 
    free(str); 

    /* ---------------------------------------------------------------------- */ 
    rpl = 3; /* Limited replacements */ 
    str = replace("AAAAAA", "A", "*", &rpl); 
    printf("Replacements: %d\tResult: [%s]\n\n", rpl, str); 
    /* Replacements: 3  Result: [***AAA] */ 
    free(str); 

    return 0; 
}