C 子串替换

我想实现一个c代码，这样它只替换精确匹配的字符串，而不是另一个字符串的一部分。 查看我的代码

#include <stdio.h>
#include <string.h>
int main ()
{
   char str[] ="This is a simpled simple string";
   char * pch;
   char str1[]= "simple";
   pch = strstr (str,str1);
   strncpy (pch,"sample",6);
   puts (str);
   return 0;
 }

#包括
#包括
int main（）
{
char str[]=“这是一个简化的简单字符串”；
char*pch；
字符str1[]=“简单”；
pch=strstr（str，str1）；
strncpy（pch，“样本”，6）；
put（str）；
返回0；
}

上面的代码给出了输出：这是一个简单的字符串

我希望输出为：这是简化的示例字符串

请帮忙

---

谢谢。

一个单词可以以空格开头，也可以位于字符串开头，也可以以空格、句号、逗号或字符串结尾。使用这些条件，您可以轻松识别字符串中的任何单词。下面的代码根据您的示例对其进行了描述

使用此代码，您可以将一个单词替换为任意大小的另一个单词。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
int main()
{
    char str[] = "simple This is a simpled simple simple. simple, string simple";
    char * pch;
    char * result = str;
    char * temp;

    char str1[] = "simple"; //string to be replaced
    char str2[] = "sample"; //string to be replaced with

    pch = strstr(result, str1);
    while(pch)
    {
        temp = result;
        if ((pch == str || *(pch - 1) == ' ') && (strlen(pch) == strlen(str1) || !isalpha(*(pch + strlen(str1)))))
        {
            result = (char*)malloc(strlen(temp)+(strlen(str2) - strlen(str1))+1); //allocate new memory, +1 for trailing null character
            strncpy(result, temp, pch - temp); // copy previous string till found word to new allocated memory
            strncpy(result + (pch - temp), str2, strlen(str2)); // replace previous word with new word
            strncpy(result + (pch - temp) + strlen(str2), pch + strlen(str1), strlen(pch + strlen(str1))); // place previous string after replaced word
            strncpy(result + strlen(temp) + (strlen(str2) - strlen(str1)), "\0", 1); // place null character at the end of string
            if (temp != str)
                free(temp); // free extra memory
        }
        pch = strstr(result + (pch - temp) + 1, str1); // search for another word in new string after the last word was replaced
    }

    puts(result);
    if (result != str)
        free(result);
    return 0;
}

#包括
#包括
#包括
#包括
int main（）
{
char str[]=“简单这是一个简单的简单。简单，字符串简单”；
char*pch；
char*result=str；
字符*温度；
char str1[]=“简单”；//要替换的字符串
char str2[]=“sample”；//要替换为的字符串
pch=strstr（结果，str1）；
while（pch）
{
温度=结果；
如果（（pch==str | |*（pch-1）=''和（&（strlen（pch）==strlen（str1）| |）！isalpha（*（pch+strlen（str1）'））
{
结果=（char*）malloc（strlen（temp）+（strlen（str2）-strlen（str1））+1）；//为尾部空字符分配新内存，+1
strncpy（result，temp，pch-temp）；//复制上一个字符串，直到找到的字被分配到新的内存中
strncpy（result+（pch-temp）、str2、strlen（str2））；//用新词替换上一个词
strncpy（result+（pch-temp）+strlen（str2）、pch+strlen（str1）、strlen（pch+strlen（str1））；//将上一个字符串放在替换的单词之后
strncpy（result+strlen（temp）+（strlen（str2）-strlen（str1）），“\0”，1）；//在字符串末尾放置空字符
如果（温度！=str）
空闲（临时）；//释放额外内存
}
pch=strstrstr（result+（pch-temp）+1，str1）；//在替换最后一个单词后，在新字符串中搜索另一个单词
}
放置（结果）；
如果（结果！=str）
自由（结果）；
返回0；
}

首先，需要连续搜索整个字符串，直到没有找到子字符串；其次，需要检查strstr返回的子字符串前后的字符，以确保找到的子字符串是完整的单词。检查单词边界时，如果单词位于较长字符串的开头或结尾，请特别小心。例如：

#include <stdio.h>
#include <string.h>
int main(void)
{
    char str[] ="simple simples is a simpled simple string simple";
    char *s = str;
    char *pch = str;
    char str1[]= "simple";
    int len = strlen(str1);
    int pos;
    while (1) {
        pch = strstr(s, str1);
        if (!pch)  // no more occurrences of str1, quit
            break;
        pos = pch - str;
        if (pos == 0) { // if it's the beginning
            if (!isalpha(pch[len])) {
                strncpy(pch, "sample", 6);
            }
        } else { // check two ends
            if (!isalpha(*(pch-1)) && !isalpha(*(pch+len))) {
                    strncpy(pch, "sample", 6);
            }
        }
        s = pch + len;
   }
   puts(str);
   return 0;
}

#包括
#包括
内部主（空）
{
char str[]=“simple simples是一个简单字符串simple”；
char*s=str；
char*pch=str；
字符str1[]=“简单”；
int len=strlen（str1）；
int pos；
而(1){
pch=strstr（s，str1）；
如果（！pch）//不再出现str1，则退出
打破
pos=pch-str；
如果（pos==0）{//如果它是开始
if（！isalpha（pch[len]））{
strncpy（pch，“样本”，6）；
}
}否则{//检查两端
如果（！isalpha（*（pch-1））和（&！isalpha（*（pch+len）））{
strncpy（pch，“样本”，6）；
}
}
s=pch+len；
}
put（str）；
返回0；
}
处理这些类型问题的最好方法是逐一考虑<强>每一个<强>字。然后检查
模式
（我们正在寻找的？）是否存在于给定字符串中，如果是，则将其替换为替换
单词

下面是我的代码。（我知道这可能看起来有点奇怪，但相信我，它可以解决任何模式匹配和替换问题）。它将根据给定的
模式
字及其相应的
替换
字减少和扩展最终输出

#包括
#包括
#包括
int main（）{
/*此程序将“演示”替换为“程序”*/
char input[]=“isdemo您好这是演示。用演示替换演示其他演示”；
字符模式[]=“演示”；
char replace[]=“程序”；
字符输出[105]；
int指数=0；
/*逐字阅读输入行的内容，
如果单词==模式[]，则替换它，否则不执行任何操作*/
对于（inti=0；i我更新了我的代码。这将处理您想要的替换

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

void replace(char *buf, size_t bufSize, const char *word_to_replace, const char *replacement_word);

int main(void)
{
    char str[100] = "simple Asimple simpleB This is a simpled simple string and simple is good sometimes!, simple";
    replace(str, sizeof(str), "simple", "sample");
    printf("%s\n", str);
    return 0;
}

void replace(char *buf, size_t bufSize, const char *word_to_replace, const char *replacement_word)
{
    size_t buf_len = strlen(buf), word_len = strlen(word_to_replace);
    char *ptr = strstr(buf, word_to_replace);
    if (ptr == NULL) {
        fprintf(stderr, "Could not find matches.\n");
        return;
    }
    bool _G = 0;
    char *tmp = (char *)malloc(bufSize);

    // Deal with begining of line
    if (ptr == buf) {
        if (ptr[word_len] == ' ' || ptr[word_len] == '\0') {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    else {
        if (*(ptr - 1) == ' ' && (ptr[word_len] == ' ' || ptr[word_len] == '\0')) {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    // deal with the rest
    while (ptr = strstr(ptr + 1, word_to_replace))
    {
        if (*(ptr - 1) == ' ' && (ptr[word_len] == ' ' || ptr[word_len] == '\0')) {
            _G = 1;
        }
        if (_G) {
            strcpy_s(tmp, bufSize, ptr + word_len);
            *ptr = 0;
            strcat_s(buf, bufSize, replacement_word);
            strcat_s(buf, bufSize, tmp);
            _G = 0;
        }
    }
    free(tmp);
}

#包括
#包括
#包括
无效替换（字符*buf，大小*bufSize，常量字符*字到替换，常量字符*替换字）；
内部主（空）
{
char str[100]=“simple-Asimple-simpleB这是一个简单的字符串，simple有时很好，simple”；
替换（str，sizeof（str），“简单”，“样本”）；
printf（“%s\n”，str）；
返回0；
}
无效替换（字符*buf，大小*bufSize，常量字符*字到替换，常量字符*替换字）
{
字号=strlen（buf），单词=strlen（要替换的单词）；
char*ptr=strstrstr（buf，字要替换）；
如果（ptr==NULL）{
fprintf（stderr，“找不到匹配项。\n”）；
返回；
}
bool _G=0；
char*tmp=（char*）malloc（bufSize）；
//处理线的起点
如果（ptr==buf）{
如果（ptr[word_len]=''ptr[word_len]='\0'）{
_G=1；
}
如果（_G）{
结构图（tmp、bufSize、ptr+文字）；
*ptr=0；
标准尺寸（基本尺寸、基本尺寸、替换字）；
标准集装箱（buf、bufSize、tmp）；
_G=0；
}
}
否则{
如果（*（ptr-1）=''&（ptr[word|len]=''ptr[word|len]='\0'））{
_G=1；
}
如果（_G）{
结构图（tmp、bufSize、ptr+文字）；
*ptr=0；
标准尺寸（基本尺寸、基本尺寸、替换字）；
标准集装箱（buf、bufSize、tmp）；