D 语言高效字符串替换：原生实现及大小写敏感性

以下是使用原生方式实现字符串替换的代码，可以指定大小写敏感性：

import core.stdc.string;
import core.stdc.stdlib;

void replaceString(char[] str, char[] oldStr, char[] newStr, bool caseSensitive) {
    if (str.length == 0 || oldStr.length == 0) {
        return;
    }
    size_t oldLen = oldStr.length;
    size_t newLen = newStr.length;
    size_t count = 0;
    char* p = str.ptr;
    char* pos = strstr(p, oldStr.ptr);
    while (pos != null) {
        count++;
        pos += oldLen;
        pos = strstr(pos, oldStr.ptr);
    }
    if (count == 0) {
        return;
    }
    size_t newLenDiff = newLen - oldLen;
    size_t newStrLen = str.length + count * newLenDiff;
    char* newStrPtr = cast(char*) malloc(newStrLen + 1);
    char* dest = newStrPtr;
    pos = strstr(p, oldStr.ptr);
    while (pos != null) {
        size_t len = pos - p;
        memcpy(dest, p, len);
        dest += len;
        if (caseSensitive) {
            memcpy(dest, newStr.ptr, newLen);
        } else {
            for (size_t i = 0; i < newLen; i++) {
                dest[i] = tolower(newStr.ptr[i]);
            }
        }
        dest += newLen;
        p = pos + oldLen;
        pos = strstr(p, oldStr.ptr);
    }
    strcpy(dest, p);
    memcpy(str.ptr, newStrPtr, newStrLen);
    str[newStrLen] = '\0';
    free(newStrPtr);
}

void main() {
    char[] str = 'The quick brown fox jumps over the lazy dog.';
    char[] oldStr = 'the';
    char[] newStr = 'a';
    replaceString(str, oldStr, newStr, false);
    writeln(str); // Output: 'a quick brown fox jumps over a lazy dog.'
}

该代码首先计算出需要替换的字符串数量，然后根据数量计算出新字符串的长度，并分配新字符串的内存空间。接着，使用 strstr 函数在原字符串中查找需要替换的字符串，并将其替换为新字符串。最后，将新字符串复制回原字符串中，并释放新字符串的内存空间。在替换时，可以根据 caseSensitive 参数指定是否大小写敏感。如果不敏感，则将新字符串转换为小写字母。

注意：

• 该代码使用 C 标准库中的 strstr 和 malloc 函数，因此需要在 D 代码中包含 core.stdc.string 和 core.stdc.stdlib 库。
• betterc 模式可能可以提高代码效率，但需要进行测试和比较才能确定最佳实现方式。