注释转换 续 (C++注释转换为C注释)

注释转换 续

关于注释转换的问题  ，这里就不提了 。之前就已经   说明过是什么意思了 

如果你你要是不知道  ，就点击这里   看看吧   注释转换

今天  要说的是将  C++注释转换为C语言注释  ，大家都知道  C++注释的风格 是  //.......注释一行 ，然后以\n作为

结束标志的，所以要将注释转换 ，   也同样要考虑多种  用问题  ，

下面是我写的一些实例  

[html]  view plain  copy

1. /* 1.一般情况*/  
2. // int i = 0;  
3.   
4. /* 2.换行问题*/  
5. //int i = 0;   
6. int j = 0;  
7. /* int i = 0; */  
8. int j = 0;  
9.   
10. //3.遇到*/问题  
11. //int i = 0;xxxxx*///  
12.   
13.   
14. /*4.多行注释问题*/  
15. //  
16. //int i=0;  
17. //int j = 0;  
18. //int k = 0;  
19. int k = 0;  

代码实现  

~~~~~~~~~~头文件 .h~~~~~~~~~~~~

[html]  view plain  copy

1. #pragma once   
2.   
3. #include<stdio.h>  
4. #include<stdlib.h>  
5.   
6. enum STATE //定义一个枚举类型  表示   此时代码的状态  
7. {  
8.     NUL,//无注释状态   
9.     C,//C语言注释状态  
10.     CPP,//C++注释状态  
11.     END//代码结束状态  
12. };  
13. //执行转换函数  
14. void CommentConvert(FILE *pfin,FILE * pfout);//pfin 表示的是要读取的文件 ，pfout表示转换后输出的文件  
15. //无状态转换  
16. void DoNULConvert(FILE *pfin,FILE * pfout,enum STATE * state);  
17. //c状态转换  
18. void DoCConvert(FILE *pfin,FILE * pfout,enum STATE * state);  
19. //c++状态转换  
20. void DoCPPConvert(FILE *pfin,FILE * pfout,enum STATE * state);  

~~~~~~~~~~~源文件.c~~~~~~~~~~~

[html]  view plain  copy

1. #define  _CRT_SECURE_NO_WARNINGS   
2.   
3. #include "CommentConvert.h"  
4.   
5. void CommentConvert(FILE *pfin,FILE * pfout)  
6. {  
7.     enum STATE state = NUL;//初始化状态 为   无注释状态  
8.     while(state != END)//代码结束时跳出循环  
9.     {  
10.         switch(state)  
11.         {  
12.         case NUL://状态为无注释状态  
13.             {  
14.             DoNULConvert(pfin,pfout,&state);  
15.             }  
16.             break;  
17.         case C://状态为C注释状态  
18.             {  
19.             DoCConvert(pfin,pfout,&state);  
20.             }  
21.             break;  
22.         case CPP://状态为C++注释状态  
23.             {  
24.             DoCPPConvert(pfin,pfout,&state);  
25.             }  
26.             break;  
27.         default:  
28.             break;  
29.         }  
30.     }  
31. }  
32.   
33. //无状态转换  
34. void DoNULConvert(FILE *pfin,FILE * pfout,enum STATE * state)  
35. {  
36.     int start = 0;  
37.     int next = 0;  
38.     start = fgetc(pfin);//从文件中读取一个字符 来判断  
39.     switch( start)  
40.     {  
41.         case '/'://表示要进入注释状态   
42.         {  
43.             next = fgetc(pfin);//再从文件中读取一个字符  判断  
44.             switch(next)  
45.             {  
46.             case '*'://表示代码是 /*  表示进入C语言注释状态  
47.                 {  
48.                     fputc(start,pfout);//将注释输出到文件  
49.                     fputc(next,pfout);  
50.                     *state = C;//状态转换为  C注释状态  
51.                 }  
52.                 break;  
53.             case '/'://表示代码是 //  表示进入C++注释状态  
54.                 {  
55.                 fputc('/',pfout);//j将它改为C注释 输出到文件  
56.                 fputc('*',pfout);  
57.                 *state  = CPP;  //状态转换为  C++注释状态  
58.                 }  
59.                 break;  
60.             default:   //表示这个'/ '是字符   
61.                 {  
62.                 fputc(start,pfout); //将读取到的字符输出到文件  
63.                 ungetc(next,pfin);  
64.                 }  
65.                 break;  
66.             }  
67.         }  
68.         break;  
69.         case EOF://遇到EOF表示代码结束  
70.         {  
71.             fputc(start,pfout);//将EOF输到文件  
72.             *state = END;//状态改为 END  
73.         }  
74.         break;  
75.         default://表示遇到的不是注释  ，状态不变   
76.         {  
77.             fputc(start,pfout); //将读取的字符输出到文件  
78.         }  
79.         break ;  
80.     }  
81. }  
82. //c++状态转换  
83. void DoCPPConvert(FILE *pfin,FILE * pfout,enum STATE * state)  
84. {  
85.     int start = 0;  
86.     int next = 0;  
87.     int then = 0;  
88.     start = fgetc(pfin);//从文件中读取一个字符 来判断  
89.     switch(start)  
90.     {  
91.     case '\n' ://表示 C++一行注释结束   
92.         {  
93.             next = fgetc(pfin);  
94.             switch(next)//判断 下行 是不是也是注释  
95.             {  
96.             case '/':  
97.                 {         
98.                     then =  fgetc(pfin);  
99.                     if(then =='*')  
100.                     {     
101.                         fputc('*',pfout);  
102.                         fputc('/',pfout);  
103.                         fputc(start,pfout);  
104.                         fputc(next,pfout);  
105.                         fputc(then,pfout);  
106.                         *state = C;  
107.                     }  
108.                     else if(then =='/')  
109.                     {  
110.                         fputc(start,pfout);  
111.                     }  
112.                 }  
113.                 break;  
114.             case EOF:  
115.                 fputc('*',pfout);  
116.                 fputc('/',pfout);  
117.                 fputc(start,pfout);  
118.                 fputc(next,pfout);  
119.                 *state = END;  
120.                 break;  
121.             default:  
122.                 fputc('*',pfout);  
123.                 fputc('/',pfout);  
124.                 fputc(start,pfout);  
125.                 fputc(next,pfout);  
126.                 *state = NUL;  
127.                 break;  
128.             }  
129.         }  
130.         break;  
131.     case '*':  
132.         {  
133.             next = fgetc(pfin);  
134.             if(next == '/')  
135.             {;}  
136.             else  
137.             {  
138.             ungetc(next,pfin);  
139.             fputc(start,pfout);           
140.             }  
141.           
142.         }  
143.         break;  
144.     default:  
145.         fputc(start,pfout);  
146.         break;  
147.     }  
148. }  
149. //c状态转换  
150. void DoCConvert(FILE *pfin,FILE * pfout,enum STATE * state)  
151. {  
152.     int start = 0;  
153.     int next = 0;  
154.     int then = 0;  
155.     start = fgetc(pfin);//从文件中读取一个字符 来判断  
156.     switch(start)//c注释状态  不会直接转换为END状态  
157.     {  
158.     case '*'://遇到'*'表示C语言注释状态  可能会结束  
159.         {  
160.             next = fgetc(pfin); //再重新 读取 一个字符   
161.             switch(next)//判断  
162.             {  
163.             case '/'://表示  C语言注释  结束    
164.                 {  
165.                     fputc(start,pfout);  
166.                     fputc(next,pfout);  
167.                     *state = NUL;//状态装换为无注释状态  
168.                 }  
169.                 break;  
170.             default :  
171.                 {  
172.                 fputc(start,pfout);  
173.                 ungetc(next,pfin);//将多余用来判断的字符撤销   
174.                 }  
175.             break;  
176.             }  
177.         }  
178.         break;    
179.     default:  
180.         fputc(start,pfout); //否则直接输出  
181.         break;  
182.     }  
183. }  

~~~~~~~~~~~测试代码 .c~~~~~~~~~~~~

[html]  view plain  copy

1. #define  _CRT_SECURE_NO_WARNINGS   
2.   
3. #include "CommentConvert.h"  
4.   
5.   
6. int main()  
7. {  
8.     FILE *pfin = NULL;//定义两文件指针  
9.     FILE *pfout= NULL;  
10.     pfin = fopen("input.c","r");//打开 读取 的文件   
11.     if(pfin == NULL )  
12.     {  
13.         perror("input file open:");//读取失败  
14.         exit(EXIT_FAILURE);  
15.     }  
16.     pfout = fopen("output.c","w");//打开 要写入 的文件   
17.     if(pfout ==NULL)  
18.     {  
19.         perror("output file open:");//读取失败  
20.         fclose(pfin);//要将读文件关闭取的  
21.         exit(EXIT_FAILURE);  
22.     }  
23.     CommentConvert(pfin,pfout);  
24.     printf("转换成功\n");  
25.     fclose(pfin);//关闭两文件  
26.     fclose(pfout);  
27.     system("pause");  
28.     return  0;  
29. }<strong>  
30. </strong>  

转自：http://blog.csdn.net/wx_east/article/details/52194778