使用有限状态自动机过滤掉java和c++中的注释

一个比较常见的题。这个题应该是要比看上去的难不少。如果用正则，可能会好一些。
使用FSM解答。
核心思想是向后看一步。
对于每次读入的字符，实际上我们不能立即判断出它是否是注释，只有向后多看一个，来判断前面读到的这个字符是代码还是注释。
例如:  te/st//comment
假设有个缓存，长度是2个字节，存储当前处理的字符和上一个字符。
第一次读到‘/’时，缓存中是“e/”,输出“e”.
读下一个，缓存中是“/s”,不匹配注释，“/”直接被输出
下一次读到‘/’时，缓存中是“t/”, 这时我们可以知道t不是注释中的一部分，直接输出。
下一步，缓存就为“//”,我们知道了这个和一个注释开始符匹配，剩下的就当做注释处理。

同样的，在判断注释结束时，我们依然要多向后看一部。

下面给出一个示意的有限状态自动机。用queue代表缓存，然后使用一个flag comments来标记是否是注释。
这里仅仅是一个示意图，表示了关键的一部分。实际还有很多缺失的细节。
1.注释有//和/* */两种，因此开始注释和结束注释的判断都不一样。
2.要考虑转义字符的问题。
3.处理结束后，要将缓存中剩余的2个char根据状态输出。
具体细节可以参考下面的代码。（未经完全测试）

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. char* filter(const char* input){
   
4.     if(input == NULL) return NULL;
   
5. 
   
6.     int len = strlen(input) +1;
   
7. 
   
8.     char* ret = (char*)malloc(len);
   
9.     int index = 0;
   
10.     int r = 0;
    
11.     int comments = 0;
    
12.     char cache[3];
    
13.     cache[0] = '\0';
    
14.     cache[1] = '\0';
    
15.     cache[2] = '\0';
    
16.     for(;r<len;r++){
    
17.         cache[strlen(cache)] = input[r];
    
18.         if(strlen(cache)!=2)
    
19.             continue;
    
20.         if(comments>0){
    
21.             if(comments == 1 && cache[1] == '\n'){
    
22.                 cache[0] = '\0';
    
23.                 cache[1] = '\0';
    
24.                 comments = 0;
    
25.                 continue;
    
26.             }
    
27.             if(comments == 1 && cache[1] != '\n'){
    
28.                 cache[0] = cache[1];
    
29.                 cache[1] = '\0';
    
30.                 continue;
    
31.             }
    
32.             if(comments == 2 && cache[0] == '*'&& cache[1] == '/'){
    
33.                 cache[0] = '\0';
    
34.                 cache[1] = '\0';
    
35.                 comments = 0;
    
36.                 continue;
    
37.             }
    
38.             if(comments == 2 && !(cache[0] == '*'&& cache[1] == '/')){
    
39.                 cache[0] = cache[1];
    
40.                 cache[1] = '\0';
    
41.                 continue;
    
42.             }
    
43.                 
    
44.         }
    
45.         else{
    
46.                         //escape char
    
47.             if(cache[0] =='\\'){
    
48.                 ret[index++] = cache[0];
    
49.                 ret[index++] = cache[1];
    
50.                 cache[0] = '\0';
    
51.                 cache[1] = '\0';
    
52.                 continue;
    
53.             }
    
54.             if(cache[0] =='/' && cache[1] == '/'){
    
55.                 comments = 1;
    
56.                 cache[0] = '\0';
    
57.                 cache[1] = '\0';
    
58.                 continue;
    
59.             }
    
60.             if(cache[0] =='/' && cache[1] == '*'){
    
61.                 comments = 2;
    
62.                 cache[0] = '\0';
    
63.                 cache[1] = '\0';
    
64.                 continue;
    
65.             }
    
66.             ret[index++] = cache[0];
    
67.             cache[0]=cache[1];
    
68.             cache[1]='\0';
    
69.             
    
70.         }
    
71.     }
    
72.     if(comments == 0){
    
73.         ret[index++] = cache[0];
    
74.         ret[index++] = cache[1];
    
75. 
    
76.     }
    
77.     ret[index] = '\0';
    
78.     return ret;    
    
79. }
    
80. 
    
81. int main(){
    
82.     char* test = "I just for test /*test*/ test";
    
83.     char* test1 = "I just for test //comments \ntest";
    
84.     char* test2 = "I just for test \\///comments";
    
85.     printf("%s \n", filter(test));
    
86.     printf("%s \n", filter(test1));
    
87.     printf("%s \n", filter(test2));
    
88. }