仅用<stdio.h>实现字符串子串反转替换：main无法获取反转函数输出的问题

问题概述 #

需实现手动输入或预设句子与单词，完成单词查找、反转及替换功能，但编译通过后无任何输出，main()函数无法获取reversing函数的输出结果，且仅允许使用<stdio.h>库。

核心错误分析 #

1. reversing函数参数与返回值错误 #

• 参数定义为char *givenWord[]（指针数组），但实际传入的是字符串数组（退化为char*），类型不匹配
• 返回类型为char，但需要返回整个字符串的指针，应改为char*
• 指针操作错误：*givenWord[i]和givenWord[j]写法错误，直接通过数组索引访问字符即可，无需多余解引用

2. main函数逻辑错误 #

• 连续调用两次reversing(change_what)，导致字符串被反转两次后恢复原状
• char into_what = ("%s", word);是错误的逗号表达式用法，将指针强制转为char类型，完全不符合字符串赋值逻辑
• 替换时使用已被反转的change_what作为查找目标，无法匹配原句子中的单词

3. substring函数匹配逻辑缺陷 #

原匹配逻辑仅在子串后是空格或结束符时才返回，且循环匹配的判断条件有误，导致无法正确定位目标单词

4. 替换函数死循环问题 #

原replace_string_add和replace_string_remove中，替换后会重复查找已替换内容，导致程序死循环无输出

修复方案 #

1. 修正reversing函数 #

调整参数和返回值类型，修正指针操作：

char* reversing(char *givenWord) {
    int i = 0, j = stringLength(givenWord) - 1;
    char temp;
    while (i < j) {
        temp = givenWord[i];
        givenWord[i] = givenWord[j];
        givenWord[j] = temp;
        i++;
        j--;
    }
    return givenWord;
}

2. 修正main函数逻辑 #

• 仅调用一次反转函数，保存原查找单词避免被修改
• 直接使用反转后的字符串指针作为替换目标：

int main() {
    char s[] = "This is the input sentence", change_what[] = "input";
    // 保存原单词，避免反转后无法查找
    char original_change[100];
    int len = stringLength(change_what);
    for(int i = 0; i <= len; i++) {
        original_change[i] = change_what[i];
    }
    // 反转目标单词
    char *word = reversing(change_what);
    // 用原单词查找，替换为反转后的单词
    replace_string(s, original_change, word);
    printf("\"%s\"", s);
    return 0;
}

3. 修正substring函数匹配逻辑 #

确保能正确匹配句子中的完整单词：

char *substring(char *main_string, char *substring) {
    int sub_len = lenght(substring);
    if (sub_len == 0) return main_string;
    while (*main_string != '\0') {
        char *p = main_string;
        char *q = substring;
        // 完整匹配子串
        while (*q != '\0' && *p == *q) {
            p++;
            q++;
        }
        // 匹配成功，检查是否是完整单词
        if (*q == '\0') {
            if ((main_string == main_string || *(main_string - 1) == ' ') && (*p == ' ' || *p == '\0')) {
                return main_string;
            }
        }
        main_string++;
    }
    return NULL;
}

4. 修正替换函数的循环逻辑 #

调整查找起始位置，避免死循环：

void replace_string_add(char *s, char *change_what, char *into_what, int shift)
{
    char *i_pointer = into_what;
    char *c_pointer = change_what;
    char *position = substring(s, change_what);
    while (position != NULL) {
        char *end = position;
        while (*end != '\0') {
            end++;
        }
        // 移动字符腾出空间
        while (end >= position) {
            *(end + shift) = *end;
            end--;
        }
        // 写入替换内容
        char *pos_copy = position;
        while (*into_what != '\0') {
            *pos_copy++ = *into_what++;
        }
        // 从替换后的位置继续查找，避免死循环
        position = substring(pos_copy, change_what);
        into_what = i_pointer;
        change_what = c_pointer;
    }
}

void replace_string_remove(char *s, char *change_what, char *into_what,
                           int shift)
{
    char *i_pointer = into_what;
    char *c_pointer = change_what;
    char *position = substring(s, change_what);
    while (position != NULL) {
        // 覆盖原单词
        char *temp = position;
        while (*(temp + shift) != '\0') {
            *temp = *(temp + shift);
            temp++;
        }
        *temp = '\0';
        // 写入替换内容
        char *pos_copy = position;
        while (*into_what != '\0') {
            *pos_copy++ = *into_what++;
        }
        // 从替换后的位置继续查找
        position = substring(pos_copy, change_what);
        into_what = i_pointer;
        change_what = c_pointer;
    }
}

完整修复代码 #

#include <stdio.h>

int stringLength(char string[100]) {
    int i, l = 0;
    for (i = 0; string[i] != '\0'; i++) {
        l++;
    }
    return l;
}

char* reversing(char *givenWord) {
    int i = 0, j = stringLength(givenWord) - 1;
    char temp;
    while (i < j) {
        temp = givenWord[i];
        givenWord[i] = givenWord[j];
        givenWord[j] = temp;
        i++;
        j--;
    }
    return givenWord;
}

int compare(char *x, char *y) {
    while (*x != '\0' || *y != '\0') {
        if (*x == *y) {
            x++;
            y++;
        } else if ((*x == '\0' && *y != '\0') || (*x != '\0' && *y == '\0') || *x != *y) {
            return 0;
        }
    }
    return 1;
}

int lenght(char *a) {
    char *b = a;
    while (*a) a++;
    return a - b;
}

char *substring(char *main_string, char *substring) {
    int sub_len = lenght(substring);
    if (sub_len == 0) return main_string;
    while (*main_string != '\0') {
        char *p = main_string;
        char *q = substring;
        while (*q != '\0' && *p == *q) {
            p++;
            q++;
        }
        if (*q == '\0') {
            if ((main_string == main_string || *(main_string - 1) == ' ') && (*p == ' ' || *p == '\0')) {
                return main_string;
            }
        }
        main_string++;
    }
    return NULL;
}

void replace_string_add(char *s, char *change_what, char *into_what, int shift)
{
    char *i_pointer = into_what;
    char *c_pointer = change_what;
    char *position = substring(s, change_what);
    while (position != NULL) {
        char *end = position;
        while (*end != '\0') {
            end++;
        }
        while (end >= position) {
            *(end + shift) = *end;
            end--;
        }
        char *pos_copy = position;
        while (*into_what != '\0') {
            *pos_copy++ = *into_what++;
        }
        position = substring(pos_copy, change_what);
        into_what = i_pointer;
        change_what = c_pointer;
    }
}

void replace_string_remove(char *s, char *change_what, char *into_what,
                           int shift)
{
    char *i_pointer = into_what;
    char *c_pointer = change_what;
    char *position = substring(s, change_what);
    while (position != NULL) {
        char *temp = position;
        while (*(temp + shift) != '\0') {
            *temp = *(temp + shift);
            temp++;
        }
        *temp = '\0';
        char *pos_copy = position;
        while (*into_what != '\0') {
            *pos_copy++ = *into_what++;
        }
        position = substring(pos_copy, change_what);
        into_what = i_pointer;
        change_what = c_pointer;
    }
}

void replace_string(char *s, char *change_what, char *into_what)
{
    int shift = lenght(into_what) - lenght(change_what);
    if (compare(change_what, into_what) == 0) {
        if (shift >= 0) {
            replace_string_add(s, change_what, into_what, shift);
        } else {
            replace_string_remove(s, change_what, into_what, -shift);
        }
    }
}

int main() {
    char s[] = "This is the input sentence", change_what[] = "input";
    char original_change[100];
    int len = stringLength(change_what);
    for(int i = 0; i <= len; i++) {
        original_change[i] = change_what[i];
    }
    char *word = reversing(change_what);
    replace_string(s, original_change, word);
    printf("\"%s\"", s);
    return 0;
}

运行结果 #

执行后输出："This is the tupni sentence"

内容的提问来源于stack exchange，提问作者basakcglyn