写一个cpp代码，利用bf或者kmp算法在一串字符串里找到所有子串，并返回下标

在C++中，我们可以使用KMP（Knuth-Morris-Pratt）算法来在一个字符串中查找所有的子串。KMP算法是一种高效的模式匹配算法，它避免了回溯过程，提高了搜索效率。以下是一个简单的KMP算法实现，用于查找主串中给定模式的所有非空子串及其起始位置：

#include <iostream>
#include <vector>

// KMP辅助函数，计算next数组
std::vector<int> computeNext(const std::string& pattern) {
    int len = pattern.length();
    std::vector<int> next(len);
    int j = -1;
    for (int i = 1; i < len; ++i) {
        while (j != -1 && pattern[i] != pattern[j + 1]) {
            j = next[j];
        }
        if (pattern[i] == pattern[j + 1]) {
            ++j;
        }
        next[i] = j;
    }
    return next;
}

// 主函数，查找子串并返回下标
void findAllSubstrings(const std::string& text, const std::string& pattern,
                      std::vector<std::pair<int, int>>& substrings) {
    int text_len = text.size(), pattern_len = pattern.size();
    std::vector<int> next = computeNext(pattern);

    substrings.clear(); // 清空上一轮结果
    int i = 0, j = 0; // 文本索引，模式索引
    while (i < text_len) {
        if (text[i] == pattern[j]) {
            ++i;
            ++j;
        } else if (j != 0) {
            j = next[j - 1]; // 如果当前字符不匹配，根据next数组跳转
        } else {
            ++i; // 如果模式的第一个字符也不匹配，移动到下一个文本字符
        }

        if (j == pattern_len) { // 找到一个匹配
            substrings.push_back({i - pattern_len, i - 1}); // 存储子串的开始和结束下标
            j = next[j - 1]; // 继续从模式的下一个字符开始匹配
        }
    }
}

int main() {
    std::string text = "ABABCABABC";
    std::string pattern = "ABC";
    std::vector<std::pair<int, int>> substrings;
    findAllSubstrings(text, pattern, substrings);

    if (!substrings.empty()) {
        std::cout << "Substring(s) found at index pairs: ";
        for (const auto &substring : substrings) {
            std::cout << "(" << substring.first << ", " << substring.second << ") ";
        }
    } else {
        std::cout << "No matching substring found.\n";
    }

    return 0;
}

当你运行这个程序时，它会在`text`字符串中查找模式`pattern`的所有非空子串，并打印出它们的起始和结束下标。