开发者社区> 问答> 正文

[λ]你试过这样写C程序吗? 热:报错

摘要

面向对象风格和函数式编程风格是编写代码的两种风格,面向对象风格早为大众所认知,函数式风格也渐渐受到大家的关注。网上为其布道的文章不少,有人赞扬有人不屑,但鲜有展示一个完整例子的。例如很多人对函数式风格的印象只是“有人说它很好,但不清楚到底好在哪儿,更不知如何在实际的项目中获益”。

本文将采用C语言解决一个问题,围绕这个问题不断地变化需求、重构代码,分别展示两种风格如何从不同的侧面提高代码的可维护性。如果你没有耐心读完这篇长文章,可以参见下面的代码,但这篇文章会向你解释为什么代码会写成这样,以及写成这样的好处。

注:本文纯属个人观点,如有雷同,非常荣幸!因为文章有点长,所以我把完整的文章做成PDF并上传到“微盘”供大家下载:http://vdisk.weibo.com/s/vgdyUZmwZ2l4/1376725867

问题描述

作为贯穿全文的主线,这有一个问题需要你开发一个C程序来完成任务:有一个存有职员信息(姓名、年龄、工资)的文件“work.txt”,内容如下:

William 35 25000
Kishore 41 35000
Wallace 37 20000
Bruce 39 15000
  1. 要求从文件中读取这些信息,并输出到屏幕上;
  2. 为所有工资小于三万的员工涨3000元;
  3. 在屏幕上输出薪资调整后的结果;
  4. 把调整后的结果保存到原始文件。

即运行的结果是屏幕上要有八行输出,“work.txt”的内容将变成:

William 35 28000
Kishore 41 35000
Wallace 37 23000
Bruce 39 18000

最终代码


#include <stdlib.h>
#include <stdio.h>

typedef char String[32];
typedef FILE* File;

typedef struct _Employee {
  String name;
  int age;
  int salary;
  struct _Employee *next;
} *Employee;

typedef void (*Callback)(Employee);

/* High Order Functions  */
void foreach(Employee e, Callback fn) {
  Employee p;
  while (p = e) {
    e = e->next;                /* Avoid *next be changed in fn */
    fn(p);
  }
}

void with_open_file(String filename, String mode, Callback fn, Employee e) {
  File file = freopen(filename, mode, (mode[0] == 'r'? stdin: stdout));
  if (file == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  fn(e);
  fclose(file);
}

/* Destructor */
static void employee_free_node(Employee e) {
  if (e != NULL) {
    free(e);
  }
}

void employee_free(Employee e) {
  foreach(e, employee_free_node);
}

/* Input */
static void employee_read_node(Employee node) {
  Employee e = NULL, *head = (Employee*) node;
  e = *head = (Employee)calloc(1, sizeof(struct _Employee));
  if (e != NULL && scanf("%s%d%d", e->name, &e->age, &e->salary) != 3) {
    employee_free(e);
    *head = NULL;
  }
}

void employee_read(Employee list) {
  Employee e = NULL, *head = (Employee*) list, tail = NULL;

  *head = NULL;
  while (employee_read_node((Employee)&e), e) {
    if (*head != NULL) {
      tail->next = e;
      tail = e;
    } else {
      *head = tail = e;
    }
  }
}

/* Output */
static void employee_print_node(Employee e) {
  printf("%s %d %d\n", e->name, e->age, e->salary);
}

void employee_print(Employee e) {
  foreach(e, employee_print_node);
}

/* Business Logic */
static void employee_adjust_salary_node(Employee e) {
  if (e->salary < 30000) {
    e->salary += 3000;
  }
}

void employee_adjust_salary(Employee e) {
  foreach(e, employee_adjust_salary_node);
}

int main(void) {
  Employee e = NULL;

  with_open_file("work.txt", "r", employee_read, (Employee)&e);
  employee_print(e);

  employee_adjust_salary(e);
  employee_print(e);
  with_open_file("work.txt", "w", employee_print, e);

  employee_free(e);

  return EXIT_SUCCESS;
}


展开
收起
kun坤 2020-06-09 22:08:47 829 0
1 条回答
写回答
取消 提交回答
  • 楼主这是节点遍历时,通过函数指针动态加载节点处理函数的设计方法。这个几年前写过,后来不这么写了。主要有以下几个问题。

    1、每个节点被访问时,操作可能不一样,通用的函数指针的入口参数,要么可变参,要么多套,入口指针,都是很繁琐的事情,把代码逻辑结构搞的会更复杂。

    2、操作函数和操作对象没有绑定,这个在规模开发时,很容易引起混乱。这样设计的代码,我自己到后面都觉得混乱,更别说基于我的架子让别人开发,楼主你的例子不够复杂可能感觉不到。

    3、上面两个问题,也导致,代码复用率不高。

    现在我的设计思想,如果是基础的数据结构,如同你这个例子中就是个线形表,我都全部独立成模版,在头文件中。

    特定数据的处理不会和处理方法绑定,而是调用不同通用模块来处理,这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联,处理时,也是一类整体处理的,同时一批数据再怎么复合,总可以拆成不同大部分串联处理(例如,读取、处理、写出,通过增加cache的方式可以分批分步骤完成,而不是读、处理、写 、一个完整操作周期,仅针对一个单元)。所以这类数据的整体处理落在通用模块里,通过数据和处理的紧耦合的提升效率。

    ######

    另外,补充说一下,楼主的函数式风格,和我的函数式风格理解相差颇大。我的理解如下,所谓函数式风格,是将一批数据的若干处理,分解为正交串接的多个子步骤,每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理,可以挂接不同的操作方法。

    我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作,可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块,实现数据处理。当然差异的模块调用顺序和不同处理模块的组合,可以有不同的效果。

    但无论如何,都是函数与数据松耦合的设计。这个和面向对象是反过来的。

    ######相互嵌套耦合,牵一发动全身######楼主的代码有很浓重的其他语言的味道######楼主文章不错,我看现在的C模块基本就是你所说的面向对象风格,其实就是用数据结构组织起来。######

    引用来自“中山野鬼”的答案

    楼主这是节点遍历时,通过函数指针动态加载节点处理函数的设计方法。这个几年前写过,后来不这么写了。主要有以下几个问题。

    1、每个节点被访问时,操作可能不一样,通用的函数指针的入口参数,要么可变参,要么多套,入口指针,都是很繁琐的事情,把代码逻辑结构搞的会更复杂。

    2、操作函数和操作对象没有绑定,这个在规模开发时,很容易引起混乱。这样设计的代码,我自己到后面都觉得混乱,更别说基于我的架子让别人开发,楼主你的例子不够复杂可能感觉不到。

    3、上面两个问题,也导致,代码复用率不高。

    现在我的设计思想,如果是基础的数据结构,如同你这个例子中就是个线形表,我都全部独立成模版,在头文件中。

    特定数据的处理不会和处理方法绑定,而是调用不同通用模块来处理,这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联,处理时,也是一类整体处理的,同时一批数据再怎么复合,总可以拆成不同大部分串联处理(例如,读取、处理、写出,通过增加cache的方式可以分批分步骤完成,而不是读、处理、写 、一个完整操作周期,仅针对一个单元)。所以这类数据的整体处理落在通用模块里,通过数据和处理的紧耦合的提升效率。

    你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的,说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好;同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”,并且支持灵活的可变个数参数等特性,都是为了辅助函数式风格的编码。

    #2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起,但通过规范地命令提供隐喻,比如代码中,所有操作Employee对象的函数都以employee_前缀开头。而且,这些接口之间也有层级关系,符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里,然后头文件里只放置公开的接口信息,这样就变得简洁多了。

    最高层:使用API的程序 main
    基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary
    基于最底层的C,对象Employee的最基础的操作,包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file
    C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc...

    例如C语言自带的操作文件的接口同样符合这样的抽象屏障:我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口,无需关心FILE结构体里有些什么内容,表示什么意思,以及各个接口是怎么实现的。

    #3的确是一个问题,而且我在文章里也可以没有提及,因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言,例如Java的java.util.*容器、C++的STL容器,都符合你的设计,将容器这个单一职责抽象出来。当然,我自己实际的工作也是这样做的。


    ######

    引用来自“中山野鬼”的答案

    另外,补充说一下,楼主的函数式风格,和我的函数式风格理解相差颇大。我的理解如下,所谓函数式风格,是将一批数据的若干处理,分解为正交串接的多个子步骤,每个步骤都是对整体数据的某个操作的实现。楼主的方案实质是对一个处理,可以挂接不同的操作方法。

    我的理解函数式的风格在于每个独立模块处理极少的有逻辑关联的操作,可以看作针对一个数据池的原子操作。依次将数据池的数据灌入不同的独立模块,实现数据处理。当然差异的模块调用顺序和不同处理模块的组合,可以有不同的效果。

    但无论如何,都是函数与数据松耦合的设计。这个和面向对象是反过来的。

    我认为你说的是“责任单一原则”,让每个函数、每个模块责任都尽可能地单一,然后通过类似搭积木一样的灵活组合,完成不同的任务。就像UNIX下的命令,每个单独命令都只完成一件事情,通过管道等把这些功能单一的命令组织在一起,协作完成一个复杂的任务!

    我个人认为这是一种设计思想,和源自Lambda演算的函数式风格并没有太大关系。

    ######

    引用来自“杨同学”的答案

    楼主的代码有很浓重的其他语言的味道
    因为其他语言也能写“面向对象风格”和“函数式风格”的代码,并且看起来比C更“专业”。
    ######

    引用来自“优游幻世”的答案

    楼主文章不错,我看现在的C模块基本就是你所说的面向对象风格,其实就是用数据结构组织起来。

    嗯,将数据和操作数据的方法集中在一起会让代码更容易维护。

    就像我在六楼回复里提到的,很多C模块往往还会更进一步,把容器和对象也分离开来。这样容器能容纳各种不同的对象,对象则只保留数据本身,不关心和其他对象是以什么形式组织在一起的。

    ######

    引用来自“redraiment”的答案

    引用来自“中山野鬼”的答案

    楼主这是节点遍历时,通过函数指针动态加载节点处理函数的设计方法。这个几年前写过,后来不这么写了。主要有以下几个问题。

    1、每个节点被访问时,操作可能不一样,通用的函数指针的入口参数,要么可变参,要么多套,入口指针,都是很繁琐的事情,把代码逻辑结构搞的会更复杂。

    2、操作函数和操作对象没有绑定,这个在规模开发时,很容易引起混乱。这样设计的代码,我自己到后面都觉得混乱,更别说基于我的架子让别人开发,楼主你的例子不够复杂可能感觉不到。

    3、上面两个问题,也导致,代码复用率不高。

    现在我的设计思想,如果是基础的数据结构,如同你这个例子中就是个线形表,我都全部独立成模版,在头文件中。

    特定数据的处理不会和处理方法绑定,而是调用不同通用模块来处理,这样是尽可能的让数据和处理松耦合。而关联数据再怎么关联,处理时,也是一类整体处理的,同时一批数据再怎么复合,总可以拆成不同大部分串联处理(例如,读取、处理、写出,通过增加cache的方式可以分批分步骤完成,而不是读、处理、写 、一个完整操作周期,仅针对一个单元)。所以这类数据的整体处理落在通用模块里,通过数据和处理的紧耦合的提升效率。

    你说的问题#1和文章中函数式风格一节抱怨employee_read无法和Callback兼容的问题是类似的,说到底就是因为C语言静态类型等语法特性导致了对函数式风格支持不好;同时也反向说明了为什么大多数支持函数式风格的语言会选择“动态类型”,并且支持灵活的可变个数参数等特性,都是为了辅助函数式风格的编码。

    #2这一点我不太同意。C语言里虽然没有类的概念把数据和函数在语法层次上绑定在一起,但通过规范地命令提供隐喻,比如代码中,所有操作Employee对象的函数都以employee_前缀开头。而且,这些接口之间也有层级关系,符合下表描述的抽象屏障。如果你把Employee相关的声明、操作独立出来放在一个文件里,然后头文件里只放置公开的接口信息,这样就变得简洁多了。

    最高层:使用API的程序 main
    基于Employee的接口实现的高级操作 employee_print, employee_adjust_salary
    基于最底层的C,对象Employee的最基础的操作,包括读入、释放、遍历等 employee_read, employee_free, foreach, with_open_file
    C语言本身提供的最底层的工具 struct Empoloyee, for, free, calloc...

    例如C语言自带的操作文件的接口同样符合这样的抽象屏障:我们只需要使用fopen、fclose、fread、fwrite等一系列操作FILE对象的接口,无需关心FILE结构体里有些什么内容,表示什么意思,以及各个接口是怎么实现的。

    #3的确是一个问题,而且我在文章里也可以没有提及,因为这不是这篇文章要表达的重点。它最本质的问题在于将集合的数据结构和单个对象的信息保存在同一个地方。其他语言,例如Java的java.util.*容器、C++的STL容器,都符合你的设计,将容器这个单一职责抽象出来。当然,我自己实际的工作也是这样做的。


    第二个问题其实是不同设计思想的核心问题。你举的例子只能说是些简单的系统中的模块。如果是个大系统中的底层模块特别是引擎方面(会产生数据加工的),这种方法最终组合出来的系统,会比面向对象出来的类套类更复杂。说实话,还不如用面相对象实现。

    面向对象,是将数据和操作,进行耦合,并且封装在类里面。这种做法是有它的好处的。这样不会导致数据和操作之间出现问题。而c如果这么写,说实话还不如用c++的类进行实现,因为类描述这些逻辑更为清晰,而且语法和编译器可以帮你做大量的事情。

    而相反面向数据,是一批数据(不是一个具体数据单元),存在一批不同操作。如何分析数据之间的无关性和前后操作的无关性是重点,这两个分析清楚,那么并发计算,和分步骤计算就得以实现。并发计算不谈,分步骤计算的思想就是原子操作,或者微指令集管道设计思想。这样设计,可以令复杂的数据处理,根据流程细分到步骤,每个步骤细分到子步骤单元,而每个子步骤单元只负责处理,不负责数据的格式问题。

    上面这段的设计思想和面向对象是反过来的,数据和操作松耦合。数据的特殊性导致的操作,是通过各种操作模块组合调用实现(这些操作模块可以看作上面独立的子步骤单元和外部特定数据结构无关的)。

    这样做的好处是,模块的设计,可以独立进行,让外部数据格式依赖自身,而不是操作对应数据格式(面向对象是后者,成员变量类型决定了成员函数的实际操作),模块复用率高,同时是整批数据处理,只要数据流程(调用不同模块的系统设计良好),运行效率会很高。而且便于并发操作。

    并发操作并不单单是一批数据,分层几组让同一个操作的多个进程处理。流水线技术的使用,一样可以实现。

    这里顺带喷下hadoop。貌似hadoop的map reduce并没有在流水线方面有什么突破的思路,这块需要考虑到不同计算单元之间数据流动的费用, hadoop整天扯分布计算,根本不考虑数据整体计算周期内的相关性的问题,基本上都是推给用户自己处理,而用户应该无法控制具体计算硬件设备,最后能有好效果就扯淡了。


    2020-06-09 22:08:58
    赞同 展开评论 打赏
问答分类:
问答地址:
问答排行榜
最热
最新

相关电子书

更多
15分钟打造你自己的小程序 立即下载
小程序 大世界 立即下载
《15分钟打造你自己的小程序》 立即下载