Question

现在，我试图通过编写一个函数来熟悉自己，该函数给定一个字符串，将用新的子字符串替换目标子字符串的所有实例。但是，我遇到了重新分配char*数组的问题。在我看来，似乎我能够在主循环结束时成功地将数组string重新分配到所需的新大小，然后执行strcpy以填充它更新字符串。但是，它在以下情况下失败：

字符串的原始输入：＆＃34;使用洗手间。然后我需要＆＃34;
目标是取代：＆＃34;＆＃34; （不区分大小写）
期望的替代价值：＆＃34;＆＃39;＆＃34;

在循环结束时，行printf("result: %s\n ",string);打印出正确的短语＆＃34;使用＆＃39;卫生间。然后我需要＆＃34;。但是，string似乎会自行重置：strcasestr语句中对while()的调用成功，循环开头printf("string: %s \n",string);处的行打印原始输入字符串，循环继续无限期。

我们非常感谢任何想法（我为我的诽谤调试printf语句提前道歉）。谢谢！

该功能的代码如下：

int replaceSubstring(char *string, int strLen, char*oldSubstring,
    int oldSublen, char*newSubstring, int newSublen )
{
    printf("Starting replace\n");
    char* strLoc;

    while((strLoc = strcasestr(string, oldSubstring)) != NULL )
    {
        printf("string: %s \n",string);
        printf("%d",newSublen);
        char *newBuf = (char *) malloc((size_t)(strLen +
            (newSublen - oldSublen)));
        printf("got newbuf\n");
        int stringIndex = 0;
        int newBufIndex = 0;
        char c;
        while(true)
        {
            if(stringIndex > 500)
                break;
            if(&string[stringIndex] == strLoc)
            {
                int j;
                for(j=0; j < newSublen; j++)
                {

                    printf("new index: %d  %c --> %c\n",
                        j+newBufIndex, newBuf[newBufIndex+j], newSubstring[j]);
                    newBuf[newBufIndex+j] = newSubstring[j];
                }
                stringIndex += oldSublen;
                newBufIndex += newSublen;
            }
            else
            {
                printf("old index: %d  %c --> %c\n", stringIndex,
                    newBuf[newBufIndex], string[stringIndex]);
                newBuf[newBufIndex] = string[stringIndex];
                if(string[stringIndex] == '\0')
                    break;
                newBufIndex++;
                stringIndex++;
            }
        }
        int length = (size_t)(strLen + (newSublen - oldSublen));
        string = (char*)realloc(string,
            (size_t)(strLen + (newSublen - oldSublen)));
        strcpy(string, newBuf);
        printf("result: %s\n ",string);
        free(newBuf);
    }
    printf("end result: %s ",string);
}

Answer 1

首先，应该澄清有关所需行为和界面的任务。

主题“Char数组......”尚不清楚。您提供strLen，oldSublen newSublen，因此您确实希望只使用具有给定长度的批量内存缓冲区。但是，您使用strcasestr，strcpy和string[stringIndex] == '\0'并提及printf("result: %s\n ",string);。所以我假设你想使用“ null终止字符串”，它可以被调用者作为字符串文字传递：“abc”。不需要将所有这些长度传递给函数。

看起来您正在尝试实现递归字符串替换。每次更换后，您都从头开始。让我们考虑更复杂的参数集，例如，在aba中将ab替换为abaaba。

案例1：单次传递输入流

Each of both old substrings can be replaced: "abaaba" => "abab"

That is how the standard sed string replacement works:

> echo "abaaba" | sed 's/aba/ab/g'
abab

案例2：考虑可能重叠的递归替换

The first replacement: "abaaba" => "ababa"
The second replacement in already replaced result: "ababa" => "abba"

请注意，这种情况并不安全，例如将“loop”替换为“loop loop”。这是一个无限循环。

假设我们想要实现一个接受空终止字符串的函数，并且像sed那样在一次传递中完成替换。

通常，无法替换输入字符串（在同一存储器中）进行替换。请注意realloc可能会使用新地址分配新的内存块，因此您应该将该地址返回给调用者。

为简化实现，可以在内存分配之前计算结果所需的空间（案例1实现）。因此不需要重新分配：

#define _GNU_SOURCE

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

char* replaceSubstring(const char* string, const char* oldSubstring,
    const char* newSubstring)
{
    size_t strLen = strlen(string);
    size_t oldSublen = strlen(oldSubstring);
    size_t newSublen = strlen(newSubstring);

    const char* strLoc = string;
    size_t replacements = 0;

    /* count number of replacements */
    while ((strLoc = strcasestr(strLoc, oldSubstring)))
    {
        strLoc += oldSublen;
        ++replacements;
    }

    /* result size: initial size + replacement diff + sizeof('\0') */
    size_t result_size = strLen + (newSublen - oldSublen) * replacements + 1;

    char* result = malloc(result_size);

    if (!result)
        return NULL;

    char* resCurrent = result;
    const char* strCurrent = string;
    strLoc = string;

    while ((strLoc = strcasestr(strLoc, oldSubstring)))
    {
        memcpy(resCurrent, strCurrent, strLoc - strCurrent);
        resCurrent += strLoc - strCurrent;
        memcpy(resCurrent, newSubstring, newSublen);
        resCurrent += newSublen;
        strLoc += oldSublen;
        strCurrent = strLoc;
    }

    strcpy(resCurrent, strCurrent);

    return result;
}

int main()
{
    char* res;

    res = replaceSubstring("use the restroom. Then I need", "the", "th");
    printf("%s\n", res);
    free(res);

    res = replaceSubstring("abaaba", "aba", "ab");
    printf("%s\n", res);
    free(res);

    return 0;
}

C - 要复制的字符数组SEEMS，但仅限于循环范围

1 个答案: