您的位置: 首页  >  文章  >  注释转换 （将C注释转换为C++注释）

注释转换 （将C注释转换为C++注释）

分类: 文章 • 2025-01-26 20:56:40

注释转换 

注释转换 》  就是将代码中的注释转换为同一类的  ， 比如是 C 语言 或者C++ 
C语言中  ，编译器默认的注释风格是    /*  .........*/   
C++中  ，编译器默认的注释风格是  // .......      注释一行  
要将 注释转化为 一致
这是一个很大的工程 ，因为你要将  其中的坑都要  考虑全面  。情况所有的j问题都要解决。 
否则 ，得到的代码会是 很乱 的。
下面是我自己画的   不同注释的转换关系  》》》
注释转换 （将C注释转换为C++注释）
下面是 
常见的一些C语言注释 
[html] view plain copy
  1. // 1.一般情况  
  2. /* int i = 0; */  
  3. // 2.换行问题  
  4. /* int i = 0; */int j = 0;  
  5. /* int i = 0; */  
  6. int j = 0;  
  7. // 3.匹配问题  
  8. /*int i = 0;/*xxxxx*/  
  9. // 4.多行注释问题  
  10. /*  
  11. int i=0;  
  12. int j = 0;  
  13. int k = 0;  
  14. */int k = 0;  
  15. // 5.连续注释问题  
  16. /**//**/  
  17. // 6.连续的**/问题  
  18. /***/  
  19. // 7.C++注释问题  
  20. // /*xxxxxxxxxxxx*/  
要想做到 ，就要做到精益求精 ，将所有情况都考虑好    。
我已经做到了  ，相信 你也不例外  注释转换 （将C注释转换为C++注释）
代码附录
~~~~~~~~~~~头文件   .h~~~~~~~~~~~~~~~
[html] view plain copy
  1. #pragma  once//表示头文件被调用一次  
  2.   
  3. #include <stdio.h>  
  4. #include <stdlib.h>  
  5.   
  6.   
  7. enum STATE //定义一个枚举类型  表示   此时代码的状态  
  8. {  
  9.     NUL,//无注释状态   
  10.     C,//C语言注释状态  
  11.     CPP,//C++注释状态  
  12.     END//代码结束状态  
  13. };  
  14. //执行转换函数  
  15. void CommentConvert(FILE *pfin,FILE * pfout);//pfin 表示的是要读取的文件 ，pfout表示转换后输出的文件  
  16. //无状态转换  
  17. void DoNULConvert(FILE *pfin,FILE * pfout,enum STATE * state);  
  18. //c状态转换  
  19. void DoCConvert(FILE *pfin,FILE * pfout,enum STATE * state);  
  20. //c++状态转换  
  21. 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. void DoNULConvert(FILE *pfin,FILE * pfout,enum STATE * state)  
  34. {  
  35.     int start = 0;  
  36.     int next = 0;  
  37.     start = fgetc(pfin);//从文件中读取一个字符 来判断  
  38.     switch( start)  
  39.     {  
  40.         case '/'://表示要进入注释状态   
  41.         {  
  42.             next = fgetc(pfin);//再从文件中读取一个字符  判断  
  43.             switch(next)  
  44.             {  
  45.             case '*'://表示代码是 /*  表示进入C语言注释状态  
  46.                 {  
  47.                     fputc('/',pfout);//j将它改为C++注释 输出到文件  
  48.                     fputc('/',pfout);  
  49.                     *state = C;//状态转换为  C注释状态  
  50.                 }  
  51.                 break;  
  52.             case '/'://表示代码是 //  表示进入C++注释状态  
  53.                 {  
  54.                 fputc(start,pfout);//将注释输出到文件  
  55.                 fputc(next,pfout);  
  56.                 *state  = CPP;  //状态转换为  C++注释状态  
  57.                 }  
  58.                 break;  
  59.             default:   //表示这个'/ '是字符   
  60.                 {  
  61.                 fputc(start,pfout); //将读取到的字符输出到文件  
  62.                 fputc(next,pfout);  
  63.                 }  
  64.                 break;  
  65.             }  
  66.         }  
  67.         break;  
  68.         case EOF://遇到EOF表示代码结束  
  69.         {  
  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 DoCConvert(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)//c注释状态  不会直接转换为END状态  
  90.     {  
  91.     case '*'://遇到'*'表示C语言注释状态  可能会结束  
  92.         {  
  93.             next = fgetc(pfin); //再重新 读取 一个字符   
  94.             switch(next)//判断  
  95.             {  
  96.             case '/'://表示  C语言注释  结束  但要判断之后是不是'\n',因为C++注释是以换行结束的  
  97.                 {  
  98.                     then =fgetc(pfin);//再重新 读取 一个字符   
  99.                     if(then == '\n')//如果是'\n'  
  100.                     {  
  101.                         fputc(then,pfout);//输出  
  102.                     }  
  103.                     else  
  104.                     {  
  105.                         fputc('\n',pfout);//如果不是 ，我们要帮他换行  
  106.                         ungetc(then,pfin);//并且要将用来判断的字符 从读取流中的撤销  ，防止下次判断时  少判断一个字符  
  107.                     }  
  108.                     *state = NUL;//状态装换为无注释状态  
  109.                 }  
  110.                 break;  
  111.             default :  
  112.                 {  
  113.                 fputc(start,pfout);  
  114.                 ungetc(next,pfin);//将多余用来判断的字符撤销   
  115.                 }  
  116.             break;  
  117.             }  
  118.         }  
  119.         break;    
  120.       
  121.     case '\n'://换行之后要加上 // 因为C++只注释能一行  
  122.         {  
  123.             fputc(start,pfout);  
  124.             fputc('/',pfout);  
  125.             fputc('/',pfout);  
  126.         }  
  127.         break;  
  128.     default:  
  129.         fputc(start,pfout); //否则直接输出  
  130.         break;  
  131.     }  
  132. }  
  133. //c++状态转换  
  134. void DoCPPConvert(FILE *pfin,FILE * pfout,enum STATE * state)  
  135. {  
  136.     int start = 0;  
  137.     int next = 0;  
  138.     int then = 0;  
  139.     start = fgetc(pfin);//从文件中读取一个字符 来判断  
  140.     switch(start)  
  141.     {  
  142.     case '\n' ://表示 C++一行注释结束   
  143.         {  
  144.             fputc(start,pfout);  
  145.             *state = NUL;//状态改为无注释状态  
  146.         }  
  147.         break;  
  148.     default :  
  149.         fputc(start,pfout);  
  150.         break;  
  151.     }  
  152. }  

如果要是不明白  ungetc  函数    可以    点击看看  I/O系列函数



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

函数写的我好累  啊， 下午写一下     转化为   C语言注释的代码 有兴趣的  c++注释转为C注释
 可以看看

转自： http://blog.****.net/wx_east/article/details/52180432

相关推荐