Windows系统下使用C语言编写单线程的文件备份程序

 do{
   puts("-------------------------------------------------");
   fprintf(stdout, "The Default Path is : %s \n", DEFAULT_TO_PATH);
   fprintf(stdout, "Now The Path is   : %s \n", get_backup_topath());
   puts("-------------------------------------------------");
   puts("That is a System Back Up Software for Windows! ");
   puts("List of the software function : ");
   puts("1. Back Up ");
   puts("2. Set Back Up TO-PATH ");
   puts("3. Show TO-PATH History");
   puts("4. Read Me ");
   puts("5. Exit ");
   puts("-------------------------------------------------");

  #include <stdio.h> /* size_t */
   #include <stdlib.h>
   #include <setjmp.h>
   #define TRY_TIMES 3

   typedef struct _input_para{
     char * file; /* 待打开或创建的文件名 */
     char * mode; /* 打开的模式 */
   }params;

   jmp_buf malc_jmp; /*Malloc_s*/
   jmp_buf fopn_jmp; /*Fopen*/

   /**
    * @version 1.0 2015/10/01
    * @author wushengixin
    * @param  ... 参看结构体说明
         可传入任意的个数的，形式为 .file = "xxx", .mode = "x" 的参数
    * function 用于使用默认参数，并调用函数 Fopen 进行打开操作
    */
   #define Fopen_s(...) Fopen((params){.file = NULL, .mode = "r", __VA_ARGS__})
   FILE* Fopen(const params file_open)；

   /**
    * @version 1.0 2015/10/01
    * @author wushengxin
    * param  sizes 输入需要分配的大小
    * function 用于隐藏一些对错误的处理，并调用malloc库函数分配空间
    */
   void * Malloc_s(size_t sizes);

   /**
    * @version 1.0 2015/10/01
    * @author wushengxin
    * @param  input 外部传入的等待释放的指针
    * function 用于隐藏一些对错误的处理，并调用free库函数进行释放指针
    */
   void Free_s(void * input);

   FILE* Fopen(const params file_open)
   {
     int times = 0;
     FILE* ret_p = NULL;
     if (file_open.file == NULL)
     {
       fputs("The File Name is EMPTY! Comfirm it and Try Again", stderr);
       return ret_p;
     }
     setjmp(fopn_jmp); /* fopn_jmp To there */
     ret_p = fopen(file_open.file, file_open.mode);
     if (ret_p == NULL)
     {
       if (times++ < TRY_TIMES) 
       longjmp(fopn_jmp, 0); /* fopn_jmp From here */
       fprintf(stderr, "The File : %s Open with Mode (%s) Fail!\n", file_open.file, file_open.mode);
     }
     return ret_p;
   }

   void * Malloc_s(size_t sizes)
   {
     int times = 0;
     void * ret_p = NULL;
     if (sizes == 0)
       return NULL;
     setjmp(malc_jmp); /* malc_jmp To There */
     ret_p = malloc(sizes);
     if (ret_p == NULL)
     {
       if (times++ < TRY_TIMES) /* malc_jmp From Here */
         longjmp(malc_jmp, 0);
       fputs("Allocate Memory Fail!", stderr);
     }
     return ret_p;
   }

   void Free_s(void * input)
   {
     if (input == NULL)
     {
   #if !defined(NOT_DEBUG_AT_ALL)
       fputs("Sent A NULL pointer to the Free_s Function!"， stderr);
   #endif
       return;
     }
     free(input);
     input = NULL;
   }

   #include "safeFunc.h"

   #define SELF_LOAD_DEFAULT_PATH "C:/"
   #define MIN_PATH_NAME _MAX_PATH /* 最小的限制 */
   #define LARGEST_PATH_NAME 32767 /* 路径的最大限制 */

   /*
    * @version 1.0 2015/10/02
    * @author  wushengxin
    * @function 用于返回当前使用的目的路径
    */
   const char * get_backup_topath();

   /**
   * @version 1.0 2015/09/28
   * @author wushengxin
   * @param  src 外部传入的，用于调整
   * @function 用于替换路径中的 / 为 \ 的
   */
   void repl_str(char * src);

   #include "setPath.h"

   static char to_path_buf[LARGEST_PATH_NAME] = SELF_LOAD_DEFAULT_PATH;
   const char * DEFAULT_TO_PATH = SELF_LOAD_DEFAULT_PATH;
   const int LARGEST_PATH = LARGEST_PATH_NAME;

   const char * get_backup_topath()
   {
     return to_path_buf;
   }

   void repl_str(char * src)
   {
     size_t length = strlen(src);
     for (size_t i = 0; i <= length; ++i)
     {
       if (src[i] == '/')
         src[i] = '\\';
     }
     return;
   }

    #include <time.h>
    /**
     * @version 1.0 2015/10/02
     * @version wushengxin
     * @param  path 需要存储的路径
     * @function 用于存储路径到本地文件 "show_hist" 和 "use_hist" 
     */
    void store_hist_path(const char * path);
setPath.c

    void store_hist_path(const char * path)
    {
      time_t ctimes; 
      time(&ctimes); /* 获取时间 */
      FILE* input_use = Fopen_s(.file = "LastPath.conf", .mode = "w"); /* 每次写入覆盖 */
      FILE* input_show = Fopen_s(.file = "PathHistory.txt", .mode = "a");
      if (!input_show || !input_use)
      {
    #if !defined(NOT_DEBUG_AT_ALL)
        fputs("Open/Create the File Fail!", stderr);
    #endif
        return;
      }
      fprintf(input_use, "%s\n", path); /* 写入 */
      fprintf(input_show, "%s %s", path, ctime(&ctimes));
      fclose(input_show);
      fclose(input_use);
      return;
    }

    #include <string.h>
    #include <io.h> /* _access */
    enum {NOT_EXIST = 0, EXIST = 1};
    /**
     * @version 1.0 2015/10/02
     * @author  wushengxin
     * @function 用于读取从键盘输入的路径并将之设置为默认路径，并存储。
     */
    void set_enter_path();

    /**
     * @version 1.0 2015/10/02
     * @author  wushengxin
     * @param  path 用于检查的路径
     * @function 用于检查用户输入的路径是否是有效的
     */
    int is_valid_path(const char * path);

    int is_valid_path(const char * path)
    {/* _access 后方有解释 */
      if (_access(path, 0) == 0) /* 是否存在 */
        return EXIST;
      else
        return NOT_EXIST;
    }

    void set_enter_path()
    {
      int intJudge = 0; /* 用来判断是否决定完成输入 */
      char tmpBuf[LARGEST_PATH_NAME]; /** 临时缓冲区 **/
      while (1)
      {
        printf("Enter The Path You want!\n");
        fgets(tmpBuf, LARGEST_PATH_NAME*sizeof(char), stdin); /* 获取输入的路径 */
        sscanf(tmpBuf, "%s", to_path_buf);
        if (is_valid_path(to_path_buf) == NOT_EXIST)
        {
          fprintf(stderr, "Your Enter is Empty, So Load the Default Path\n");
          fprintf(stderr, "%s \n", SELF_LOAD_DEFAULT_PATH);
          strcpy(to_path_buf, SELF_LOAD_DEFAULT_PATH);
        }
        fprintf(stdout, "Your Enter is \" %s \" ?(1 for yes, 0 for no) \n", to_path_buf);

        fgets(tmpBuf, LARGEST_PATH_NAME*sizeof(char), stdin);
        sscanf(tmpBuf, "%d", &intJudge); /* 获取判断数的输入 */
        if (intJudge != 0)
        {
          if (to_path_buf[strlen(to_path_buf) - 1] != '/')
            strcat(to_path_buf, "/");/* 如果最后一个字符不是'/'，则添加，这里没考虑是否越界 */
          store_hist_path(to_path_buf);
          break;
        } /* if(intJudge) */
      }/* while (1) */
      return;
    }/* set_enter_path */

    /**
     * @version 1.0 2015/10/02
     * author  wushengxin
     * function 用于在窗口显示所有的历史路径
     */
    void show_hist_path();

    void show_hist_path()
    {
      system("cls");
      char outBufName[LARGEST_PATH_NAME] = {'\0'};
      FILE* reading = Fopen_s(.file = "PathHistory.txt", .mode = "r");
      if (!reading)
      return;

      for (int i = 1; i <= 10 && (!feof(reading)); ++i)  
      {
        fgets(outBufName, LARGEST_PATH_NAME*sizeof(char), reading);
        fprintf(stdout, "%2d. %s", i, outBufName);
      }
      fclose(reading);
      system("pause");
      return;
    }

    /**
     * @versions 1.0 2015/10/02
     * @author  wushengxin
     * @function 用于每次程序启动时初始化目的路径
     */
    void init_path();

    void init_path()
    {
      int len = 0;
      char last_path[LARGEST_PATH_NAME] = { '\0' };
      FILE* hist_file = Fopen_s(.file = "LastPath.conf", .mode = "r");
      if (!hist_file) /* 打开失败则不初始化 */
        return;
      fgets(last_path, LARGEST_PATH_NAME, hist_file);
      len = strlen(last_path);
      if (len > 1)
      {
        last_path[len - 1] = '\0'; /* 消除一个多余的 ‘\n' */
        strcpy(to_path_buf, last_path);
      }
      return;
    }

  typedef struct _vector_queue queue;
  typedef struct _combine combine;

      |  返回值  | | 函数类型名 ||  参数类型  |
  typedef int       (*fpPushBack)(queue * __restrict, const char * __restrict, const char * __restrict);
  typedef const combine * (*fpPopFront)(queue *);
  typedef void      (*fpDelete)(queue *);

  struct _combine{
  char * src_from_path; /* 源路径 */
  char * dst_to_path;  /* 目的路径 */
  };

  struct _vector_queue{
    combine **   path_contain; /* 存储路径的容器主体 */
    unsigned int  rear;     /* 队尾坐标 */
    unsigned int  front;    /* 队首坐标 */
    int       empty;    /* 是否为空 */
    unsigned int  capcity;   /* 容器的容量 */
    fpPushBack   PushBack; /* 将元素压入队尾 */
    fpPopFront   PopFront; /* 将队首出队 */
    fpDelete    Delete;  /* 析构释放整个队列空间 */
  };

  /**
   * @version 1.0 2015/10/03
   * @author  wushengxin
   * @param  object 外部传入的对象指针，相当于 this
   * @function 初始化队列模型，建立队列实体，分配空间，以及设置属性。
   */
  int newQueue(queue* object);

 int newQueue(queue * object)
 {
   queue*   loc_que = object;
   combine**  loc_arr = NULL;

   loc_arr = (combine**)Malloc_s(CAPCITY * sizeof(combine*));
   if (!loc_arr)
     return 1;

   loc_que->capcity = CAPCITY; /* 容量 */
   loc_que->front = 0;    /* 队首 */
   loc_que->rear = 0;    /* 队尾 */

   loc_que->path_contain = loc_arr; /* 将分配好的空间，放进对象中 */
   loc_que->PushBack = push_back;
   loc_que->PopFront = pop_front;
   loc_que->Delete  = del_queue;

   return 0;
 }

 /**
  * @version 1.0 2015/10/03
  * @author  wushengxin 
  * @param  object 外部传入的对象指针 相当于 this
  * @function 释放整个队列实体的空间
  */
 static void del_queue(queue * object)
 {
   Free_s(object->path_contain);
   return;
 }

 /**
  * @version 1.0 2015/10/03
  * @author  wushengxin
  * @param  object 外部传入的对象指针 相当于 this
        src  源路径
        dst  目的路径
  * @function 将外部传入的<源路径，目的路径> 存入队列中
  */
 static int push_back(queue * __restrict object, const char * __restrict src, const char * __restrict dst)
 {
   int times = 0;
   char*  loc_src = NULL; /* 本地变量，尽量利用寄存器以及缓存 */
   char*  loc_dst = NULL;
   combine* loc_com = NULL;
   queue*  loc_que = object;

   size_t  len_src = strlen(src); /* 获取路径长度 */
   size_t  len_dst = strlen(dst);
   size_t  rear = loc_que->rear;  /*获取队尾*/
   size_t  front = loc_que->front; /*获取队首*/

   loc_src = Malloc_s(len_src + 1); /* 分配空间 */
   if (!loc_src)
     return 1;

   loc_dst = Malloc_s(len_dst + 1);
   if (!loc_dst)
     return 2;
   strcpy(loc_src, src);
   strcpy(loc_dst, dst);

   loc_com = Malloc_s(sizeof(combine));
   if (!loc_com)
     return 3;
   loc_com->dst_to_path = loc_dst; 
   loc_com->src_from_path = loc_src;

   loc_que->path_contain[rear++] = loc_com; /* 将本地路径加入实体 */
   loc_que->rear = (rear % CAPCITY);   /* 用数组实现循环队列的步骤 */

   if (loc_que->rear == loc_que->front) 
     loc_que->empty = 0;
   return 0;
 }

 /**
  * @version 1.0 2015/10/03
  * @author  wushengxin
  * @param  object 外部传入的对象指针
  */
 static const combine * pop_front(queue* object)
 {
   size_t  loc_front = object->front;          /*获取当前队首*/
   combine* loc_com  = object->path_contain[loc_front]; /*获取当前文件名*/
   object->path_contain[loc_front] = NULL;   /*出队操作*/
   object->front = ((object->front) + 1) % 20; /*完成出队*/

   if (object->front == object->rear)
     object->empty = 1;
   else
     object->empty = 0;
   return loc_com;
 }

  /**
   * @version 1.0 2015/10/03
   * @author  wushengxin
   * function 显示二级界面
   */
  void sec_main_windows();
backup.c

  void sec_main_windows()
  {
    char tmpBuf[256];
    int selects;
    do{
      setjmp(select_jmp);
      system("cls");
      puts("-------------------1. Back Up------------------ ");
      puts(" For This Select, You can choose Two Options: ");
      puts(" 1. Start Back up (The Directory Path That You Enter LATER) ");
      puts(" 2. Back To last level ");
      puts("----------------------------------------------- ");
      fprintf(stdout, "Enter Your Selection: ");
      fgets(tmpBuf, 256, stdin);
      sscanf(tmpBuf, "%d", &selects);
      if (selects != 1 && selects != 2 )
      {
        fprintf(stdout, "\n Your Select \" %s \" is Invalid!\n Try Again \n", tmpBuf);
        longjmp(select_jmp, 1);
      }

      switch (selects)
      {
        jmp_buf enter_path_jmp; 
      case 1:
      {
        char tmpBuf[LARGEST_PATH], tmpPath[LARGEST_PATH]; /* 使用栈分配空间，因为只用分配一次 */
        setjmp(enter_path_jmp);     /* enter jump to there */
        puts(" Enter the Full Path You want to BackUp(e.g: C:/Programing/)");
        fprintf(stdout, " Or Enter q to back to select\nYour Enter : ");
        fgets(tmpBuf, LARGEST_PATH, stdin);
        sscanf(tmpBuf, "%s", tmpPath);
        if (_access(tmpPath, 0) != 0)  /*检查路径是否存在，有效*/
        {
          if (tmpPath[0] == 'q' || tmpPath[0] == 'Q') 
            longjmp(select_jmp, 0); /* 回到可以选择返回的界面 */
          fprintf(stderr, "The Path You Enter is Not Exit! \n Try Again : ");
          longjmp(enter_path_jmp, 0); /* enter jump from here */
        }
      }
        break;
      case 2:
        return;
      default:
        break;
      }/* switch */
    } while (1);
    return;
  }