0x0E-单线程备份(下)

写在最前方

  • 按部就班的完成一件事情,是十分美妙的感觉。
  • 在这里并没有使用Makefile系列的构造工具,而是使用集成开发环境直接一站式的完成所有的工作,而我们只需要专注于编写有用的代码即可。
  • 但是对于这些构造工具的功能还是需要了解的,到了性能瓶颈期,往往是需要这些东西的微调来进行提升,就像算法为什么有那么多的排序算法,看上去复杂度都是一样的,但是快速排序却往往比堆排序要快?不就是因为局部性快速排序要优于堆排序吗?换句话说就是缓存的命中率高
  • 不了解底层,永远也无法理解这个解释,但是前方已经有提到过什么叫做空间局部性时间局部性,至少能有些理解了。
  • 构造工具也是如此,例如,编译了源文件生成了库文件,当我们在某个函数中通过该库调用这个库中的某些函数,这个库会在在一开始就加载进我们的程序。当我们的程序十分庞大的时候,也许我们希望在使用的时候才使用它,那么就需要延迟加载这个编译器技术。如果没有了解过构造工具,这些根本不会懂,并且某些情况下UnixLinuxWindows对于库的加载方式是不同的,这些都是需要了解的,但是我们现在的确没有必要,这个程序满打满算也就是四五百行的代码,不太需要考虑这些。

写在中间

  • 上回完成了界面的大部分功能,剩下的便是备份这个主要功能。
  • 在完成备份之前,首先想想要如何构造这个备份模型

    • 既然是备份,如果不想扩展为多线程的形式,参考第一次写的遍历函数(show_structure)直接找到文件便调用Windows API(稍后介绍)进行复制即可,不需要讲待备份的文件路径保存下来。
    • 如果要考虑多线程扩展,我们就需要从长计议。
    • 对于一个备份模型,最好的莫过于使用一个队列,依旧实行的是遍历模式,但是将找到的文件路径保存,并放入一个先进先出队列中,这样我们就能够保证在扩展成多线程的时候,可以有一个很清晰的模型参考。
    • 那么现在的任务就是实现这个用于备份的队列模型。
  • 队列模型

    • 应该有一个容器空间:用于存放路径
    • 有队首队尾标志
    • O(1)复杂度的检查队列是否为空的接口或标志
    • O(1)复杂度的返回容器容量的接口或标志,容器容量应该固定不变
    • 使用一些面向对象的黑魔法,保存一些操作函数防止代码混乱。
      • 初始化函数
      • 释放函数
      • 弹出操作函数
      • 压入操作函数
  • 队列实体

    • 考虑到要存储的是字符串,并且由于Windows API的参数需求,对于一个文件,我们需要存储的路径有两个<源路径,目的路径>,对此应该再使用一个路径模型结构体包裹他们,则空间的类型就相应改变一下
  • 新建 Queue.h Queue.c

    • Queue.h

      1. typedef struct _vector_queue queue;
      2. typedef struct _combine combine;
      3. | 返回值 | | 函数类型名 || 参数类型 |
      4. typedef int (*fpPushBack)(queue * __restrict, const char * __restrict, const char * __restrict);
      5. typedef const combine * (*fpPopFront)(queue *);
      6. typedef void (*fpDelete)(queue *);

      五个typedef不知道有没有眼前一懵。,希望能够很好的理解

      前两个是结构体的声明,分别对应着 队列模型 和 路径模型。

      后两个是函数指针,作用是放在结构体里,使C语言的结构体也能够拥有一些简单的面向对象功能,例如成员函数功能,原理就是可以给这些函数指针类型的变量赋值。稍后例子更加明显。试着解读一下,很简单的。

  1. struct _combine{
  2. char * src_from_path; /* 源路径 */
  3. char * dst_to_path; /* 目的路径 */
  4. };
  5. struct _vector_queue{
  6. combine ** path_contain; /* 存储路径的容器主体 */
  7. unsigned int rear; /* 队尾坐标 */
  8. unsigned int front; /* 队首坐标 */
  9. int empty; /* 是否为空 */
  10. unsigned int capcity; /* 容器的容量 */
  11. fpPushBack PushBack; /* 将元素压入队尾 */
  12. fpPopFront PopFront; /* 将队首出队 */
  13. fpDelete Delete; /* 析构释放整个队列空间 */
  14. };
  15. /**
  16. * @version 1.0 2015/10/03
  17. * @author wushengxin
  18. * @param object 外部传入的对象指针,相当于 this
  19. * @function 初始化队列模型,建立队列实体,分配空间,以及设置属性。
  20. */
  21. int newQueue(queue* object);
  22. 可以看到,上方的函数指针类型,被用在了结构体内,此处少了一个**初始化函数**,是因为不打算把他当作**成员函数(借用面向对象术语)**
  23. 在使用的时候可以直接`obj_name.PushBack(..., ..., ...);`
  24. 更详细的可以看后面的实现部分。成为成员函数的三个函数,将被实现为 `static` 函数,不被外界访问。
  • queue.c

    1. int newQueue(queue * object)
    2. {
    3. queue* loc_que = object;
    4. combine** loc_arr = NULL;
    5. loc_arr = (combine**)Malloc_s(CAPCITY * sizeof(combine*));
    6. if (!loc_arr)
    7. return 1;
    8. loc_que->capcity = CAPCITY; /* 容量 */
    9. loc_que->front = 0; /* 队首 */
    10. loc_que->rear = 0; /* 队尾 */
    11. loc_que->path_contain = loc_arr; /* 将分配好的空间,放进对象中 */
    12. loc_que->PushBack = push_back;
    13. loc_que->PopFront = pop_front;
    14. loc_que->Delete = del_queue;
    15. return 0;
    16. }

    在初始化函数中,可以看到,设置了队首队尾以及容量,分配了容器空间,配置了成员函数。

    最后三句配置函数的语句中,push_back, pop_front, del_queue在后方以static 函数实现。

    但是由于没有声明,所以切记要将三个static函数的实现放在newQueue的前方

    1. /**
    2. * @version 1.0 2015/10/03
    3. * @author wushengxin
    4. * @param object 外部传入的对象指针 相当于 this
    5. * @function 释放整个队列实体的空间
    6. */
    7. static void del_queue(queue * object)
    8. {
    9. Free_s(object->path_contain);
    10. return;
    11. }
    12. /**
    13. * @version 1.0 2015/10/03
    14. * @author wushengxin
    15. * @param object 外部传入的对象指针 相当于 this
    16. src 源路径
    17. dst 目的路径
    18. * @function 将外部传入的<源路径,目的路径> 存入队列中
    19. */
    20. static int push_back(queue * __restrict object, const char * __restrict src, const char * __restrict dst)
    21. {
    22. int times = 0;
    23. char* loc_src = NULL; /* 本地变量,尽量利用寄存器以及缓存 */
    24. char* loc_dst = NULL;
    25. combine* loc_com = NULL;
    26. queue* loc_que = object;
    27. size_t len_src = strlen(src); /* 获取路径长度 */
    28. size_t len_dst = strlen(dst);
    29. size_t rear = loc_que->rear; /*获取队尾*/
    30. size_t front = loc_que->front; /*获取队首*/
    31. loc_src = Malloc_s(len_src + 1); /* 分配空间 */
    32. if (!loc_src)
    33. return 1;
    34. loc_dst = Malloc_s(len_dst + 1);
    35. if (!loc_dst)
    36. return 2;
    37. strcpy(loc_src, src);
    38. strcpy(loc_dst, dst);
    39. loc_com = Malloc_s(sizeof(combine));
    40. if (!loc_com)
    41. return 3;
    42. loc_com->dst_to_path = loc_dst;
    43. loc_com->src_from_path = loc_src;
    44. loc_que->path_contain[rear++] = loc_com; /* 将本地路径加入实体 */
    45. loc_que->rear = (rear % CAPCITY); /* 用数组实现循环队列的步骤 */
    46. if (loc_que->rear == loc_que->front)
    47. loc_que->empty = 0;
    48. return 0;
    49. }
    50. /**
    51. * @version 1.0 2015/10/03
    52. * @author wushengxin
    53. * @param object 外部传入的对象指针
    54. */
    55. static const combine * pop_front(queue* object)
    56. {
    57. size_t loc_front = object->front; /*获取当前队首*/
    58. combine* loc_com = object->path_contain[loc_front]; /*获取当前文件名*/
    59. object->path_contain[loc_front] = NULL; /*出队操作*/
    60. object->front = ((object->front) + 1) % 20; /*完成出队*/
    61. if (object->front == object->rear)
    62. object->empty = 1;
    63. else
    64. object->empty = 0;
    65. return loc_com;
    66. }

    一个一个的说这些函数

    del_queue:释放函数,直接调用Free_s

    push_back:压入函数,将外部传入的两个原始的没有组成的路径字符串,组合成一个combine,并压入路径,每次都判断并置是否为空标志位,实际上这个函数中有累赘代码的嫌疑,应该再分出一个函数,专门用来分配三个空间,防止这个函数过长(接近40行)

    pop_front:弹出函数,将队列的队首combine弹出,用于复制,但是这里有一个隐患,就是要将释放的工作交给外者,如果疏忽大意的话,隐患就是内存泄漏

    没有特地的提供一个接口,用来判断是否为空,因为当编译器一优化,也会将这种接口给优化成直接使用成员的形式,某种形式上的内联

  • 队列模型设计完毕,可以开始设计备份模型

  • 备份模型可以回想一下之前的遍历函数,大体的结构一样,只是此处为了扩展成多线程,需要添加一些多线程的调用函数,以及为了规格化,需要添加一个二级界面
  • 先设计一下二级界面

  • 二级界面

    • 思考一下,这个界面要做什么
      • 选择是否开始备份
      • 并且源路径需要在此处输入
      • 返回上一级
    • 新建 backup.h backup.c 文件
      • 在主界面选择 1 以后就会调用二级界面的函数
      • 列出二级界面的选项
        • 1 Start Back up
        • 2 Back To last level
    • backup.h

      1. /**
      2. * @version 1.0 2015/10/03
      3. * @author wushengxin
      4. * function 显示二级界面
      5. */
      6. void sec_main_windows();
    • backup.c

      1. void sec_main_windows()
      2. {
      3. char tmpBuf[256];
      4. int selects;
      5. do{
      6. setjmp(select_jmp);
      7. system("cls");
      8. puts("-------------------1. Back Up------------------ ");
      9. puts(" For This Select, You can choose Two Options: ");
      10. puts(" 1. Start Back up (The Directory Path That You Enter LATER) ");
      11. puts(" 2. Back To last level ");
      12. puts("----------------------------------------------- ");
      13. fprintf(stdout, "Enter Your Selection: ");
      14. fgets(tmpBuf, 256, stdin);
      15. sscanf(tmpBuf, "%d", &selects);
      16. if (selects != 1 && selects != 2 )
      17. {
      18. fprintf(stdout, "\n Your Select \" %s \" is Invalid!\n Try Again \n", tmpBuf);
      19. longjmp(select_jmp, 1);
      20. }
      21. switch (selects)
      22. {
      23. jmp_buf enter_path_jmp;
      24. case 1:
      25. {
      26. char tmpBuf[LARGEST_PATH], tmpPath[LARGEST_PATH]; /* 使用栈分配空间,因为只用分配一次 */
      27. setjmp(enter_path_jmp); /* enter jump to there */
      28. puts(" Enter the Full Path You want to BackUp(e.g: C:/Programing/)");
      29. fprintf(stdout, " Or Enter q to back to select\nYour Enter : ");
      30. fgets(tmpBuf, LARGEST_PATH, stdin);
      31. sscanf(tmpBuf, "%s", tmpPath);
      32. if (_access(tmpPath, 0) != 0) /*检查路径是否存在,有效*/
      33. {
      34. if (tmpPath[0] == 'q' || tmpPath[0] == 'Q')
      35. longjmp(select_jmp, 0); /* 回到可以选择返回的界面 */
      36. fprintf(stderr, "The Path You Enter is Not Exit! \n Try Again : ");
      37. longjmp(enter_path_jmp, 0); /* enter jump from here */
      38. }
      39. }
      40. break;
      41. case 2:
      42. return;
      43. default:
      44. break;
      45. }/* switch */
      46. } while (1);
      47. return;
      48. }

      这个函数只说几点,首先是switchcase 1,之所以用花括号包裹起来的原因是,这样才能在里面定义本地变量,直接在冒号后面定义是编译错误,这个特性可能比较少用,这里提一下,前面也有说过。

写在最后方

  • 剩下的就是编写主要的功能函数和线程调用函数了。