以下是一个简单的串的模式匹配算法实现，使用了朴素的字符串匹配算法（Naive String Matching Algorithm）：

1. #include <stdio.h>
2. #include <string.h>
4. void naive_string_matching(char* text, char* pattern) {
5.     int m = strlen(text);
6.     int n = strlen(pattern);
7.     for (int i = 0; i <= m - n; i++) {
8.         int j;
9.         for (j = 0; j < n; j++) {
10.             if (text[i + j] != pattern[j]) {
11.                 break;
12.             }
13.         }
14.         if (j == n) {
15.             printf("Pattern found at index %d\n", i);
16.         }
17.     }
18. }
20. int main() {
21.     char text[] = "ABAAABCDBBABCDDEBCABC";
22.     char pattern[] = "ABC";
23.     naive_string_matching(text, pattern);
24.     return 0;
25. }

在这个实现中，我们首先计算出文本串和模式串的长度，然后遍历文本串，对于每个位置，我们使用一个循环来检查该位置开始的子串是否匹配模式串。如果匹配成功，则输出该位置。这个算法的时间复杂度是$O((m-n+1)n)$，其中$m$和$n$分别是文本串和模式串的长度。

当然，我们可以进一步优化这个算法，使用更高效的字符串匹配算法，例如KMP算法。KMP算法可以在$O(n+m)$时间内完成匹配，其中$n$和$m$分别是文本串和模式串的长度。

以下是使用KMP算法实现的字符串匹配算法：

1. #include <stdio.h>
2. #include <string.h>
4. void compute_prefix_function(char* pattern) {
5.     int m = strlen(pattern);
6.     int* prefix_function = (int*)malloc(sizeof(int) * m);
7.     prefix_function[0] = -1;
8.     int len = 0;
9.     for (int i = 1; i < m; i++) {
10.         while (len > 0 && pattern[i] != pattern[len]) {
11.             len = prefix_function[len - 1];
12.         }
13.         if (pattern[i] == pattern[len]) {
14.             len++;
15.         }
16.         prefix_function[i] = len;
17.     }
18.     int* lps = (int*)malloc(sizeof(int) * m);
19.     for (int i = 0; i < m; i++) {
20.         lps[i] = prefix_function[i];
21.     }
22.     free(prefix_function);
23.     return lps;
24. }
26. void kmp_string_matching(char* text, char* pattern) {
27.     int m = strlen(text);
28.     int n = strlen(pattern);
29.     int* lps = compute_prefix_function(pattern);
30.     int i = 0; // index for text
31.     int j = 0; // index for pattern
32.     while (i < m) {
33.         while (j > 0 && text[i] != pattern[j]) {
34.             j = lps[j - 1];
35.         }
36.         if (text[i] == pattern[j]) {
37.             j++;
38.         }
39.         i++;
40.         if (j == n) {
41.             printf("Pattern found at index %d\n", i - j);
42.             j = lps[j - 1];
43.         }
44.     }
45.     free(lps);
46. }
48. int main() {
49.     char text[] = "ABAAABCDBBABCDDEBCABC";
50.     char pattern[] = "ABC";
51.     kmp_string_matching(text, pattern);
52.     return 0;
53. }