:::info Repo地址
https://github.com/IsshikiHugh/C-Newbie-Helper :::

C Newbie Helper

简介 | Brief Intro

这是一个为 C 语言学习新手提供的一个日志打印工具，整体功能比较简单，目的是培养刚接触编程的同学学习和养成 Debug 正确方法和好习惯。
为了方便没有接触过多模块编程的同学的使用，该工具将全部通过预编译指令和宏实现，以便使用者也能够直接复制进代码文件使用。

1.0 版本

  1. #ifndef __C_NEWBIE_HELPER__
  2. #define __C_NEWBIE_HELPER__
  4. /****************************************************
  5.  * C Newbie Helper 1.0                              *
  6.  * ------------------------------------------------ *
  7.  * Github Repository Address:                       *
  8.  * - https://github.com/IsshikiHugh/C-Newbie-Helper *
  9.  ****************************************************/
  11. /*** Config Part ************************************/
  13. // MODE 0 : Logs will be write to 'CNH_log.txt' file.
  14. // MODE 1 : Logs will be print to console (colorful for normal terminal).
  15. // MODE 2 : Logs will be print to console (colorless but fine for CMD).
  16. #define CNH_MODE 1
  18. /*** Source Code Part *******************************/
  20. #include <stdio.h>
  22. /*** Show Setting Part ******************************/
  24. #define SHOW_LOGS CNH_SHOW_LOGS
  25. static int CNH_SHOW_LOGS = 1;
  27. // Be used to set whether the CNH will show or not.
  28. // CNH will show by default.
  29. #define SET_CNH_SHOW(CNH_SHOW_FLAG) \
  30. do{ \
  31.     CNH_SHOW_LOGS = CNH_SHOW_FLAG; \
  32. }while(0)
  34. /*** Mode Setting Part ******************************/
  36. #define CNH_BRIEF CNH_USE_BRIEF_MODE
  37. static int CNH_USE_BRIEF_MODE = 0;
  38. static int CNH_TMP_USE_BRIEF_MODE = 0;
  40. // Be used to set the default mode CNH will use while printing logs.
  41. // CNH will use normal mode by default.
  42. #define SET_CNH_BRIEF_MODE(CNH_BRIEF_FLAG) \
  43. do{ \
  44.     CNH_USE_BRIEF_MODE = CNH_TMP_USE_BRIEF_MODE = CNH_BRIEF_FLAG; \
  45. }while(0)
  47. // Force to use brief mode.
  48. #define BRIEF(...) \
  49. do{ \
  50.     CNH_USE_BRIEF_MODE = 1;\
  51.     __VA_ARGS__ \
  52.     CNH_USE_BRIEF_MODE = CNH_TMP_USE_BRIEF_MODE;\
  53. }while(0)
  55. // Force to use normal mode.
  56. #define NORMAL(...) \
  57. do{ \
  58.     CNH_USE_BRIEF_MODE = 0; \
  59.     __VA_ARGS__; \
  60.     CNH_USE_BRIEF_MODE = CNH_TMP_USE_BRIEF_MODE; \
  61. }while(0)
  63. // This part is used to customize the 'OUTPUT'.
  64. #if CNH_MODE == 0
  65.     #define CNH_BLACK         ""
  66.     #define CNH_RED           ""
  67.     #define CNH_GREEN         ""
  68.     #define CNH_YELLOW        ""
  69.     #define CNH_BLUE          ""
  70.     #define CNH_PURPLE        ""
  71.     #define CNH_CYAN          ""
  72.     #define CNH_WHITE         ""
  73.     #define CNH_DEFAULT_COLOR ""
  75.     #define OUTPUT(...) \
  76.     do{ \
  77.         if(1){ \
  78.             FILE * CNH_fp = fopen("CNH_log.txt", "a"); \
  79.             fprintf(CNH_fp, __VA_ARGS__); \
  80.             fclose(CNH_fp); \
  81.         } \
  82.     }while(0)
  83. #endif
  84. #if CNH_MODE == 1
  85.     #define CNH_BLACK           "\033[0;30m" 
  86.     #define CNH_RED             "\033[0;31m" 
  87.     #define CNH_GREEN           "\033[0;32m" 
  88.     #define CNH_YELLOW          "\033[0;33m" 
  89.     #define CNH_BLUE            "\033[0;34m" 
  90.     #define CNH_PURPLE          "\033[0;35m" 
  91.     #define CNH_CYAN            "\033[0;36m" 
  92.     #define CNH_WHITE           "\033[0;37m"
  93.     #define CNH_DEFAULT_COLOR   "\033[0m" 
  94.     #define OUTPUT(...) \
  95.     do{ \
  96.         if(1){ \
  97.             fprintf(stderr, __VA_ARGS__); \
  98.         } \
  99.     }while(0)
  100. #endif
  101. #if CNH_MODE == 2
  102.     #define CNH_BLACK           ""
  103.     #define CNH_RED             ""
  104.     #define CNH_GREEN           ""
  105.     #define CNH_YELLOW          ""
  106.     #define CNH_BLUE            ""
  107.     #define CNH_PURPLE          ""
  108.     #define CNH_CYAN            ""
  109.     #define CNH_WHITE           ""
  110.     #define CNH_DEFAULT_COLOR   "" 
  111.     #define OUTPUT(...) \
  112.     do{ \
  113.         if(1){ \
  114.             fprintf(stderr, __VA_ARGS__); \
  115.         } \
  116.     }while(0)
  117. #endif
  119. /*** Functional Part ********************************/
  121. // This part is used to print debug messages with a format like 'OUTPUT' needs.
  122. #define PRINT_LINE() \
  123. do{ \
  124.     if(!CNH_BRIEF){ \
  125.         OUTPUT(CNH_YELLOW "--------------------------------------------------------\n" CNH_DEFAULT_COLOR); \
  126.     } \
  127. }while(0)
  129. // This part is used to print the head of the logs message.
  130. #define PRINT_BEGAIN() \
  131. do{ \
  132.     if(!CNH_BRIEF){ \
  133.         OUTPUT(CNH_YELLOW "\n=== >>" CNH_BLUE " [:CNH:] " CNH_YELLOW ">> ======================================\n" CNH_DEFAULT_COLOR); \
  134.     } else { \
  135.         OUTPUT(CNH_YELLOW "[CNH]"); \
  136.     } \
  137. }while(0)
  139. // This part is used to print the location of the code printing the logs.
  140. #define PRINT_LOCATION() \
  141. do{ \
  142.     if(!CNH_BRIEF){ \
  143.         OUTPUT(CNH_YELLOW "+ +" CNH_BLUE " File @ [ " CNH_CYAN "%s" CNH_BLUE " ]\n" CNH_DEFAULT_COLOR, __FILE__); \
  144.         OUTPUT(CNH_YELLOW "+ +" CNH_BLUE " Func @ [ " CNH_CYAN "%s()" CNH_BLUE " ] & Line @ [ " CNH_CYAN "%d" CNH_BLUE " ]\n" CNH_DEFAULT_COLOR, __FUNCTION__, __LINE__); \
  145.         PRINT_LINE(); \
  146.     } else { \
  147.         OUTPUT(CNH_YELLOW " @ " CNH_BLUE "{" CNH_CYAN "%s" CNH_BLUE "}[" CNH_CYAN "%d" CNH_BLUE "]/" CNH_CYAN "%s()" CNH_BLUE " : ", __FILE__, __LINE__, __FUNCTION__); \
  148.     } \
  149. }while(0)
  152. // This part is used to print the content of the logs.
  153. #define PRINT_CONTENT(...) \
  154. do{ \
  155.     if(1){ \
  156.         OUTPUT(CNH_GREEN __VA_ARGS__); \
  157.         OUTPUT("\n" CNH_DEFAULT_COLOR); \
  158.     } \
  159. }while(0)
  161. // This part is used to print the tail of the logs.
  162. #define PRINT_END() \
  163. do{ \
  164.     if(!CNH_BRIEF){ \
  165.         OUTPUT(CNH_YELLOW "====================================== << " CNH_BLUE "[:CNH:]" CNH_YELLOW " << ===\n\n" CNH_DEFAULT_COLOR); \
  166.     } \
  167. }while(0)
  169. // The normal LOG macro function.
  170. #define LOG(...) \
  171. do{ \
  172.     if(SHOW_LOGS){ \
  173.         PRINT_BEGAIN(); \
  174.         PRINT_LOCATION(); \
  175.         PRINT_CONTENT(__VA_ARGS__); \
  176.         PRINT_END(); \
  177.     } \
  178. }while (0)
  180. // The LOG macro function specially for variable.
  181. #define SHOW_VAR(CNH_TYPE, CNH_VAR) \
  182. do{ \
  183.     if(SHOW_LOGS){ \
  184.         PRINT_BEGAIN(); \
  185.         PRINT_LOCATION(); \
  186.         if(!CNH_BRIEF) PRINT_CONTENT(CNH_BLUE "< Variable Monitor >" CNH_DEFAULT_COLOR); \
  187.         PRINT_CONTENT("%s" CNH_BLUE " = " CNH_GREEN CNH_TYPE, #CNH_VAR, CNH_VAR); \
  188.         PRINT_END(); \
  189.     } \
  190. }while(0)
  192. // This part is uesd to print 1-d array.
  193. #define PRINT_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_BEGIN, CNH_ARR_END) \
  194. do{ \
  195.     if(1){ \
  196.         int CNH_IT; \
  197.         OUTPUT(CNH_GREEN "%s" CNH_BLUE " = ", #CNH_ARR_NAME); \
  198.         OUTPUT(CNH_RED "[");\
  199.         for(CNH_IT = CNH_ARR_BEGIN; CNH_IT < CNH_ARR_END; ++CNH_IT){ \
  200.             if(CNH_IT == CNH_ARR_END -1 ){ \
  201.                 OUTPUT(CNH_GREEN CNH_TYPE, CNH_ARR_NAME[CNH_IT]); \
  202.                 break; \
  203.             } \
  204.             OUTPUT(CNH_GREEN CNH_TYPE ", ", CNH_ARR_NAME[CNH_IT]); \
  205.         } \
  206.         OUTPUT(CNH_RED "]\n"); \
  207.     } \
  208. }while(0)
  210. // This part is used to print N-d array.
  211. #define PRINT_N_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ELEMENT_SIZE, CNH_SIZE) \
  212. do{ \
  213.     if(1){ \
  214.         int CNH_IT; \
  215.         char* CNH_BEGIN = (char*)CNH_ARR_NAME; \
  216.         OUTPUT(CNH_GREEN "%s" CNH_BLUE " = ", #CNH_ARR_NAME); \
  217.         OUTPUT(CNH_RED "["); \
  218.         for(CNH_IT = 0; CNH_IT < CNH_SIZE; CNH_IT+=CNH_ELEMENT_SIZE){ \
  219.             if(CNH_IT == CNH_SIZE - CNH_ELEMENT_SIZE ) {OUTPUT(CNH_GREEN CNH_TYPE, CNH_BEGIN[CNH_IT]); break;} \
  220.             OUTPUT(CNH_GREEN CNH_TYPE ", ", CNH_BEGIN[CNH_IT]);} \
  221.         OUTPUT(CNH_RED "]\n"); \
  222.     } \
  223. }while(0)
  225. // This part is used to print 2-d array/
  226. #define PRINT_2_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_ROW_NUM, CNH_ARR_COL_NUM) \
  227. do{ \
  228.     if(1){ \
  229.         int CNH_IT_ROW; \
  230.         OUTPUT(CNH_GREEN "%s" CNH_BLUE " = \n", #CNH_ARR_NAME); \
  231.         OUTPUT(CNH_RED "[");\
  232.         for(CNH_IT_ROW = 0; CNH_IT_ROW < CNH_ARR_ROW_NUM; ++CNH_IT_ROW){             \
  233.             int CNH_IT_COL; \
  234.             if(CNH_IT_ROW == 0 ) OUTPUT(CNH_RED "["); \
  235.             else OUTPUT(CNH_RED " ["); \
  236.             for(CNH_IT_COL = 0; CNH_IT_COL < CNH_ARR_COL_NUM; ++CNH_IT_COL){ \
  237.                 if(CNH_IT_COL == CNH_ARR_COL_NUM - 1 ) {OUTPUT(CNH_GREEN CNH_TYPE, CNH_ARR_NAME[CNH_IT_ROW][CNH_IT_COL]); break;} \
  238.                 OUTPUT(CNH_GREEN CNH_TYPE ", ", CNH_ARR_NAME[CNH_IT_ROW][CNH_IT_COL]); \
  239.             } \
  240.             if(CNH_IT_ROW == CNH_ARR_ROW_NUM - 1 ) {OUTPUT(CNH_RED "]");break;} \
  241.             OUTPUT(CNH_RED "],\n"); \
  242.         } \
  243.         OUTPUT(CNH_RED "]\n"); \
  244.     } \
  245. }while(0)
  247. // The LOG macro function specially for 1-d array.
  248. #define SHOW_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_BEGIN, CNH_ARR_END) \
  249. do{ \
  250.     if(SHOW_LOGS){ \
  251.         PRINT_BEGAIN(); \
  252.         PRINT_LOCATION(); \
  253.         if(!CNH_BRIEF) PRINT_CONTENT(CNH_BLUE "< Array Monitor >" CNH_DEFAULT_COLOR); \
  254.         PRINT_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_BEGIN, CNH_ARR_END); \
  255.         PRINT_END(); \
  256.     } \
  257. }while(0)
  259. // The LOG macro function specially for N-d array.
  260. #define SHOW_N_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ELEMENT_SIZE, CNH_SIZE) \
  261. do{ \
  262.     if(SHOW_LOGS){ \
  263.         PRINT_BEGAIN(); \
  264.         PRINT_LOCATION(); \
  265.         if(!CNH_BRIEF) PRINT_CONTENT(CNH_BLUE "< Array Monitor >" CNH_DEFAULT_COLOR); \
  266.         PRINT_N_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ELEMENT_SIZE, CNH_SIZE); \
  267.         PRINT_END(); \
  268.     } \
  269. }while(0)
  271. // The LOG macro function specially for 2-d array.
  272. #define SHOW_2_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_ROW_NUM, CNH_ARR_COL_NUM) \
  273. do{ \
  274.     if(SHOW_LOGS){ \
  275.         PRINT_BEGAIN(); \
  276.         PRINT_LOCATION(); \
  277.         if(!CNH_BRIEF) PRINT_CONTENT(CNH_BLUE "< Array Monitor >" CNH_DEFAULT_COLOR); \
  278.         PRINT_2_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_ROW_NUM, CNH_ARR_COL_NUM); \
  279.         PRINT_END(); \
  280.     } \
  281. }while(0)
  283. #endif

C Newbie Helper

注意事项 | FYA

  • 如果您将日志输出到文件中，请注意本工具只会不断追加，不会主动清空日志文件。所以请您做好日志的手动清空或备份管理工作。
    • 换句话说，如果你不希望几次运行的日志全都在同一个文件里无法区分，那么请在每次运行完以后删除日志文件或者重命名它。

  • 该工具中的宏函数都需要在函数内使用，也就是说你不能把它写在函数外，当然我相信几乎没有人会这么做。

    使用之前的设置 | Config

    说明：

  • 该项内容需要您手动修改源代码中的对应部分，请放心，它被放在来代码的头部，很好找。

  • 如果您希望日志打印在屏幕上但没有颜色高亮，设置为2；
  • 如果您希望日志打印在屏幕上并且有颜色（CMD无法使用），设置为1；
  • 如果希望日志打印在文件中，设置为0:

设置为1时效果最佳，但对于不熟悉命令行的一般同学我们推荐使用2，在有特殊需求时可以使用0

  1. // MODE 0 : Logs will be write to 'CNH_log.txt' file.
  2. // MODE 1 : Logs will be print to console (colorful for normal terminal).
  3. // MODE 2 : Logs will be print to console (colorless but fine for CMD).
  4. #define CNH_MODE 2

此外，CNH 默认输出到 stderr 中，如果希望它在和 printf 一起使用且顺序不变时，请改为 stdout 。

使用 | Usage

导入 | Import

  • 对于尚在学习单文件编程的同学，我们建议您直接复制CNewbieHelper.h中的所有内容至你的代码的最前。
  • 如果您觉得这太过累赘，那么请在本地将CNewbieHelper.h文件与您正在编写的.c文件放在同一目录，并在代码的开头写上#include "CNewbieHelper.h"，但请注意，此时您无法直接将代码内容提交至在线评测工具（比如PTA）。解决方法请参考上一条。

  • 对于已经知道如何进行多模块编程的同学，我们建议您直接#include "CNewbieHelper.h"

    显示 | Show

    说明：在保留调试代码的情况下，控制是否显示日志内容。

  • 默认情况下，该工具都会默认输出所有日志内容；

  • 您也可以通过调用SET_CNH_SHOW(0);来关闭显示；

  • 在关闭之后您也可以通过SET_CNH_SHOW(1);来启用显示；

    1. // Run 'demo1.c' to see more!
    2. int main(){
    3.   SET_CNH_SHOW(1);
    4.   LOG("(QWQ) I can be seen!");
    5.   SET_CNH_SHOW(0);
    6.   LOG("(QAQ) I can't be seen!");
    7. }

    简化 | Simplify

    说明：如果您认为正常的输出过于花哨，CNH提供了两套方案来调整输出的格式。
    使用如下方法可以全局性地更改输出格式：

  • 使用SET_CNH_BRIEF_MODE(1);来启用简化模式；

  • 使用SET_CNH_BRIEF_MODE(0);来关闭简化模式；

使用BRIEF();和NORMAL();可以局部性地修改输出格式：

  1. // Run 'demo2.c' to see more!
  2. int main(){
  3.     SET_CNH_BRIEF_MODE(0);
  4.     LOG("Normal mode here!");
  5.     BRIEF(
  6.         LOG("Brief mode here!");
  7.         LOG("Multiline is ok!");
  8.     );
  9.     LOG("Normal mode here!");
  11.     SET_CNH_BRIEF_MODE(1);
  12.     LOG("Brief mode here!");
  13.     NORMAL(
  14.         LOG("Normal mode here!");
  15.         LOG("Multiline is ok!");
  16.     );
  17.     LOG("Brief mode here!");
  18. }

预览：
正常输出模式：
🗂 C 语言初学者辅助工具 | C-Newbie-Helper - 图1
简化输出模式：
🗂 C 语言初学者辅助工具 | C-Newbie-Helper - 图2

一般日志 | Log

使用LOG(...)来输出一般日志。

  • LOG()的使用方法和printf()基本一致，只需要把printf()语句中的函数名换成LOG即可。

举个例子：
如果您想在某一处输出一条日志语句：

  1.     char myCharArr[] = "It's OK!";
  2.     LOG("This is a log message. %s", myCharArr);

监控变量 | Variable Monitor

使用SHOW_VAR(CNH_TYPE, CNH_VAR)来监控变量。

  • 其中CNH_TYPE指对应变量在printf()的 format 中所使用的占位符，例如int对应的CNH_TYPE为"%d"，double对应的CNH_TYPE为"%lf"；
    • 当然，由于该宏函数的底层使用的是printf()，所以实际上相关的扩展语法都是支持的。比如"%.2lf"
  • CNH_VAR指对应变量；

举个例子：
如果您想在某一处监控int类型变量x，则在该位置写上：

  1.     SHOW_VAR("%d", x);

监控数组 | Array Monitor

一维数组

使用SHOW_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_BEGIN, CNH_ARR_END)来监控数组。

  • 其中CNH_TYPE指对应变量在printf()的 format 中所使用的占位符，同上；
  • CNH_ARR_NAME指数组名，例如int a[10];中的a；
  • CNH_ARR_BEGIN和CNH_ARR_END分别为需要监控的数组的始末下表，且左闭右开；
    • 具体来说，比如为想监控a[0] a[1] a[2] a[3] … a[9]，那么对应的CNH_ARR_BEGIN为0，CNH_ARR_END为10；
    • 换句话来说，这个宏函数只能用来监控一维数组的连续段；

举个例子：
如果您想在某一处监控int类型数组a[]，范围是a[0]到a[10]，则在该位置写上：

  1.     SHOW_ARR("%d", a, 0, 10);

二维数组

使用SHOW_2_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ARR_ROW_NUM, CNH_ARR_COL_NUM)来监控数组。

  • 其中CNH_TYPE指对应变量在printf()的 format 中所使用的占位符，同上；
  • CNH_ARR_NAME指数组名，例如int a[10][10];中的a；

  • CNH_ARR_ROW_NUM和CNH_ARR_COL_NUM分别为需要监控的二维数组的行数和列数；

    • 具体来说，比如为想监控这样一个二维数组：
      1. int a[3][4] = {...};

  • 那么对应的CNH_ARR_ROW_NUM为3，CNH_ARR_COL_NUM为4；

  • 换句话来说，这个宏函数只能用来监控二维数组从( 0 , 0 )到( CNH_ARR_ROW_NUM-1 , CNH_ARR_COL_NUM-1 )的矩阵。

举个例子：
如果您想在某一处监控上面那个二维数组a[][]，则在该位置写上：

  1.     SHOW_2_ARR("%d", a, 3, 4);

任意维数组

使用SHOW_N_ARR(CNH_TYPE, CNH_ARR_NAME, CNH_ELEMENT_SIZE, CNH_SIZE)来监控任意维数组。

  • 其中CNH_TYPE指对应变量在printf()的 format 中所使用的占位符，同上；
  • CNH_ARR_NAME指数组名，例如int a[10][10];中的a；
  • CNH_ELEMENT_SIZE和CNH_SIZE分别为需要监控的数组的每一个元素的大小和整个数组的大小，一般推荐直接写成sizeof(<EleType>)和sizeof(<ArrName>)；
    • 具体来说，比如有一个三维double类数组a[11][45][14]，则：
    • CNH_ELEMENT_SIZE为sizeof(double)；
    • CNH_SIZE为sizeof(a)；
      举个例子：

如果您想在某一处监控上面那个三维数组a[][]，则在该位置写上：

  1.     SHOW_2_ARR("%lf", a, sizeof(double), sizeof(a));