您可以构建自己的替换函数，使用strstr查找子字符串，并使用strncpy将部分内容复制到新的缓冲区中。

除非您想要 replace_with 的长度与您想要 replace 的长度相同，否则最好使用新的缓冲区将新字符串复制到其中。

根本就没有。

你需要使用像 strstr 和strcat或strcpy这样的东西来编写你自己的代码。

这在标准C库中没有提供，因为如果替换字符串比被替换字符串更长，那么只给出一个char*，就不能增加分配给该字符串的内存。

您可以使用std::string更轻松地完成此操作，但即使这样，也没有一个单独的函数可以为您完成此操作。

由于C中的字符串不能动态增长，因此替换通常不起作用。因此，您需要为具有足够替换空间的新字符串分配空间，然后将原始字符串中的部分加上替换部分复制到新字符串中。要复制这些部分，您可以使用 strncpy 。

优化器应该消除大多数局部变量。tmp指针用于确保strcpy不必遍历字符串来查找null。tmp在每次调用后指向结果的末尾。(请参阅 Shlemiel the painter's algorithm ，了解为什么strcpy会令人讨厌。)

// You must free the result if result is non-NULL.
char *str_replace(char *orig, char *rep, char *with) {
    char *result; // the return string
    char *ins;    // the next insert point
    char *tmp;    // varies
    int len_rep;  // length of rep (the string to remove)
    int len_with; // length of with (the string to replace rep with)
    int len_front; // distance between rep and end of last rep
    int count;    // number of replacements
    // sanity checks and initialization
    if (!orig || !rep)
        return NULL;
    len_rep = strlen(rep);
    if (len_rep == 0)
        return NULL; // empty rep causes infinite loop during count
    if (!with)
        with = "";
    len_with = strlen(with);
    // count the number of replacements needed
    ins = orig;
    for (count = 0; tmp = strstr(ins, rep); ++count) {
        ins = tmp + len_rep;
    tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
    if (!result)
        return NULL;
    // first time through the loop, all the variable are set correctly
    // from here on,
    //    tmp points to the end of the result string
    //    ins points to the next occurrence of rep in orig
    //    orig points to the remainder of orig after "end of rep"
    while (count--) {
        ins = strstr(orig, rep);
        len_front = ins - orig;
        tmp = strncpy(tmp, orig, len_front) + len_front;
        tmp = strcpy(tmp, with) + len_with;
        orig += len_front + len_rep; // move to next "end of rep"
    strcpy(tmp, orig);
    return result;
}

以下是完成此操作的一些示例代码。

#include <string.h>
#include <stdlib.h>
char * replace(
    char const * const original, 
    char const * const pattern, 
    char const * const replacement
  size_t const replen = strlen(replacement);
  size_t const patlen = strlen(pattern);
  size_t const orilen = strlen(original);
  size_t patcnt = 0;
  const char * oriptr;
  const char * patloc;
  // find how many times the pattern occurs in the original string
  for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
    patcnt++;
    // allocate memory for the new string
    size_t const retlen = orilen + patcnt * (replen - patlen);
    char * const returned = (char *) malloc( sizeof(char) * (retlen + 1) );
    if (returned != NULL)
      // copy the original string, 
      // replacing all the instances of the pattern
      char * retptr = returned;
      for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
        size_t const skplen = patloc - oriptr;
        // copy the section until the occurence of the pattern
        strncpy(retptr, oriptr, skplen);
        retptr += skplen;
        // copy the replacement 
        strncpy(retptr, replacement, replen);
        retptr += replen;
      // copy the rest of the string.
      strcpy(retptr, oriptr);
    return returned;
#include <stdio.h>
int main(int argc, char * argv[])
  if (argc != 4)
    fprintf(stderr,"usage: %s <original text> <pattern> <replacement>\n", argv[0]);
    exit(-1);
    char * const newstr = replace(argv[1], argv[2], argv[3]);
    if (newstr)
      printf("%s\n", newstr);
      free(newstr);
      fprintf(stderr,"allocation error\n");
      exit(-2);
  return 0;
}

creativeandcritical.net上的 repl_str() 函数快速可靠。该页面还包括一个宽字符串变体 repl_wcs() ，它可以通过助手函数与Unicode字符串一起使用，包括那些以UTF-8编码的字符串-演示代码从页面链接。迟来的全面披露:我是该页面及其功能的作者。

我发现大多数提议的函数都很难理解-所以我想出了这个：

static char *dull_replace(const char *in, const char *pattern, const char *by)
    size_t outsize = strlen(in) + 1;
    // TODO maybe avoid reallocing by counting the non-overlapping occurences of pattern
    char *res = malloc(outsize);
    // use this to iterate over the output
    size_t resoffset = 0;
    char *needle;
    while (needle = strstr(in, pattern)) {
        // copy everything up to the pattern
        memcpy(res + resoffset, in, needle - in);
        resoffset += needle - in;
        // skip the pattern in the input-string
        in = needle + strlen(pattern);
        // adjust space for replacement
        outsize = outsize - strlen(pattern) + strlen(by);
        res = realloc(res, outsize);
        // copy the pattern
        memcpy(res + resoffset, by, strlen(by));
        resoffset += strlen(by);
    // copy the remaining input
    strcpy(res + resoffset, in);
    return res;
}

输出必须是空闲的

修复了fann95的响应，使用字符串的就地修改，并假设line指向的缓冲区足够大，可以容纳结果字符串。

static void replacestr(char *line, const char *search, const char *replace)
     char *sp;
     if ((sp = strstr(line, search)) == NULL) {
         return;
     int search_len = strlen(search);
     int replace_len = strlen(replace);
     int tail_len = strlen(sp+search_len);
     memmove(sp+replace_len,sp+search_len,tail_len+1);
     memcpy(sp, replace, replace_len);
}

您可以使用go....this函数将字符串 str 中出现的所有 char x 替换为 char y

char *zStrrep(char *str, char x, char y){
    char *tmp=str;
    while(*tmp)
        if(*tmp == x)
            *tmp++ = y; /* assign first, then incement */
            *tmp++;
    *tmp='\0';
    return str;
}

一个用法示例可以是

  Exmaple Usage
        char s[]="this is a trial string to test the function.";
        char x=' ', y='_';
        printf("%s\n",zStrrep(s,x,y));
  Example Output
        this_is_a_trial_string_to_test_the_function.

该函数来自 string library I maintain on Github ，非常欢迎您查看其他可用函数，甚至对代码做出贡献:)

https://github.com/fnoyanisi/zString

编辑：@siride是对的，上面的函数只替换字符。我刚写了这个，它取代了字符串。

#include <stdio.h>
#include <stdlib.h>
/* replace every occurance of string x with string y */
char *zstring_replace_str(char *str, const char *x, const char *y){
    char *tmp_str = str, *tmp_x = x, *dummy_ptr = tmp_x, *tmp_y = y;
    int len_str=0, len_y=0, len_x=0;
    /* string length */
    for(; *tmp_y; ++len_y, ++tmp_y)
    for(; *tmp_str; ++len_str, ++tmp_str)
    for(; *tmp_x; ++len_x, ++tmp_x)
    /* Bounds check */
    if (len_y >= len_str)
        return str;
    /* reset tmp pointers */
    tmp_y = y;
    tmp_x = x;
    for (tmp_str = str ; *tmp_str; ++tmp_str)
        if(*tmp_str == *tmp_x) {
            /* save tmp_str */
            for (dummy_ptr=tmp_str; *dummy_ptr == *tmp_x; ++tmp_x, ++dummy_ptr)
                if (*(tmp_x+1) == '\0' && ((dummy_ptr-str+len_y) < len_str)){
                /* Reached end of x, we got something to replace then!
                * Copy y only if there is enough room for it
                    for(tmp_y=y; *tmp_y; ++tmp_y, ++tmp_str)
                        *tmp_str = *tmp_y;
        /* reset tmp_x */
        tmp_x = x;
    return str;
int main()
    char s[]="Free software is a matter of liberty, not price.\n"
             "To understand the concept, you should think of 'free' \n"
             "as in 'free speech', not as in 'free beer'";
    printf("%s\n\n",s);
    printf("%s\n",zstring_replace_str(s,"ree","XYZ"));
    return 0;
}

下面是输出

Free software is a matter of liberty, not price.
To understand the concept, you should think of 'free' 
as in 'free speech', not as in 'free beer'
FXYZ software is a matter of liberty, not price.
To understand the concept, you should think of 'fXYZ' 
as in 'fXYZ speech', not as in 'fXYZ beer'

您可以使用此函数(注释解释了它的工作原理)：

void strreplace(char *string, const char *find, const char *replaceWith){
    if(strstr(string, replaceWith) != NULL){
        char *temporaryString = malloc(strlen(strstr(string, find) + strlen(find)) + 1);
        strcpy(temporaryString, strstr(string, find) + strlen(find));    //Create a string with what's after the replaced part
        *strstr(string, find) = '\0';    //Take away the part to replace and the part after it in the initial string
        strcat(string, replaceWith);    //Concat the first part of the string with the part to replace with
        strcat(string, temporaryString);    //Concat the first part of the string with the part after the replaced part
        free(temporaryString);    //Free the memory to avoid memory leaks
}

此函数仅在您的字符串有额外空间可容纳新长度时才起作用

void replace_str(char *str,char *org,char *rep)
    char *ToRep = strstr(str,org);
    char *Rest = (char*)malloc(strlen(ToRep));
    strcpy(Rest,((ToRep)+strlen(org)));
    strcpy(ToRep,rep);
    strcat(ToRep,Rest);
    free(Rest);
}

这只会替换第一个匹配项

这就是我的，它是自包含的，多功能的，以及高效的，它在每次递归中根据需要增加或缩小缓冲区

void strreplace(char *src, char *str, char *rep)
    char *p = strstr(src, str);
    if (p)
        int len = strlen(src)+strlen(rep)-strlen(str);
        char r[len];
        memset(r, 0, len);
        if ( p >= src ){
            strncpy(r, src, p-src);
            r[p-src]='\0';
            strncat(r, rep, strlen(rep));
            strncat(r, p+strlen(str), p+strlen(str)-src+strlen(src));
            strcpy(src, r);
            strreplace(p+strlen(rep), str, rep);
}

这是我的，让它们都是char*，这使得呼叫更容易……

char *strrpc(char *str,char *oldstr,char *newstr){
    char bstr[strlen(str)];
    memset(bstr,0,sizeof(bstr));
    int i;
    for(i = 0;i < strlen(str);i++){
        if(!strncmp(str+i,oldstr,strlen(oldstr))){
            strcat(bstr,newstr);
            i += strlen(oldstr) - 1;
        }else{
                strncat(bstr,str + i,1);
    strcpy(str,bstr);
    return str;
}

仅使用string.h .h中的strlen

对不起，我的英语

char * str_replace(char * text,char * rep, char * repw){//text -> to replace in it | rep -> replace | repw -> replace with
    int replen = strlen(rep),repwlen = strlen(repw),count;//some constant variables
    for(int i=0;i<strlen(text);i++){//search for the first character from rep in text
        if(text[i] == rep[0]){//if it found it
            count = 1;//start searching from the next character to avoid repetition
            for(int j=1;j<replen;j++){
                if(text[i+j] == rep[j]){//see if the next character in text is the same as the next in the rep if not break
                    count++;
                }else{
                    break;
            if(count == replen){//if count equals to the lenght of the rep then we found the word that we want to replace in the text
                if(replen < repwlen){
                    for(int l = strlen(text);l>i;l--){//cuz repwlen greater than replen we need to shift characters to the right to make space for the replacement to fit
                        text[l+repwlen-replen] = text[l];//shift by repwlen-replen
                if(replen > repwlen){
                    for(int l=i+replen-repwlen;l<strlen(text);l++){//cuz replen greater than repwlen we need to shift the characters to the left
                        text[l-(replen-repwlen)] = text[l];//shift by replen-repwlen
                    text[strlen(text)-(replen-repwlen)] = '\0';//get rid of the last unwanted characters
                for(int l=0;l<repwlen;l++){//replace rep with repwlen
                    text[i+l] = repw[l];
                if(replen != repwlen){
                    i+=repwlen-1;//pass to the next character | try text "y" ,rep "y",repw "yy" without this line to understand
    return text;
}

如果您希望strlen代码避免调用string.h .h

int strlen(char * string){//use this code to avoid calling string.h