精华内容
下载资源
问答
  • C语言模块化编程

    2018-07-06 11:00:21
    C语言模块化编程
  • C语言模块化编程c语言模块化编程,为大学生量身定制python课程, 0基础轻松入门。
  • c语言编程规范 C语言模块化 c语言编程规范 C语言模块化 c语言编程规范 C语言模块化
  • C语言模块化

    2013-02-27 17:28:14
    C语言的应用领域,如通讯领域和嵌入式系统领域,一个的软件项目通常包含很多复杂的功能,实现这个项目不是一个程序员单枪匹马可以胜任的,往往需要一个团队的有效合作,另外,在一个以C代码为主的完整的项目中,...
     在C语言的应用领域,如通讯领域和嵌入式系统领域,一个的软件项目通常包含很多复杂的功能,实现这个项目不是一个程序员单枪匹马可以胜任的,往往需要一个团队的有效合作,另外,在一个以C代码为主的完整的项目中,经常也需要加入一些其他语言的代码,例如,C代码和汇编代码的混合使用,C文件和C++的同时使用。这些都增加了一个软件项目的复杂程度,为了提高软件质量,合理组织的各种代码和文件是非常重要的。      
    
           
        组织代码和文件的目的是为了使团队合作更加有效,使软件项目有良好的可扩展性、可维护性、可移植性、可裁减、可测试性,防止错误发生,提高软件的稳定性。通常情况下,软件项目采用层次化结构和模块化开发的方法,例如,一个嵌入式软件项目可能有驱动层,操作系统层,功能层,应用程序层,每一个层使用它的下层提供的接口,并为它的上层提供调用接口,模块则是每一个层中完成一个功能的单元,例如驱动层的每一个设备的驱动就是一个模块,应用层的每个应用程序就是一个模块,模块使用下层提供的接口和同层其他模块提供的接口,完成特定功能,为上层和同层的其他模块提供调用接口。      
           
        这里的接口是指一个功能模块暴露出来的,提供给其他模块的访问具体功能的方法。根据C语言的特点,使用*.c文件实现模块的功能,使用*.h文件暴露单元的接口,在*.h文件里声明外部其他模块可能是用的函数,数据类型,全局变量,类型定义,宏定义和常量定义.外部模块只需包含*.h文件就可以使用相应的功能.当然,模块可以在细化为子模块.虽然我们这里说的接口和COM(通用组件模型)里定义的接口不同,但是,根据COM里对接口的讨论,为了使软件在修改时,一个模块的修改不会影响到其他模块的一个模块的修改不会导致其他模块也需要修改,所以,接口第一次发布后,修改*.h文件不能导致使用这个接口的其他模块需要重新编写.      
           
        根据C语言的特点,并借鉴一些成熟软件项目代码,总结C项目中代码文件组织的基本建议:      
        1,使用层次化和模块化的软件开发模型.每一个模块只能使用所在层和下一层模块提供的接口.      
        2,每个模块的文件包存在独立的一个文件夹中.通常情况下,实现一个模块的文件不止一个,这些相关的文件应该保存在一个文件夹中.      
        3,用于模块裁减的条件编译宏保存在一个独立的文件里,便于软件裁减.      
        4,硬件相关代码和操作系统相关代码与纯C代码相对独立保存,以便于软件移植.      
        5,声明和定义分开,使用*.h文件暴露模块需要提供给外部的函数,宏,类型,常量,全局变量,尽量做到模块对外部透明,用户在使用模块功能时不需要了解具体的实现,文件一旦发布,要修改一定要很慎重,      
        6,文件夹和文件命名要能够反映出模块的功能.      
        7,正式版本和测试版本使用统一文件,使用宏控制是否产生测试输出。      
        8,必要的注释不可缺少。      
           
        理想的情况下,一个可执行的模块提供一个公开的接口,即使用一个*.h文件暴露接口,但是,有时候,一个模块需要提供不止一个接口,这时,就要为每个定义的接口提供一个公开的接口。在C语言的里,每个C文件是一个模块,头文件为使用这个模块的用户提供接口,用户只要包含相应的头文件就可以使用在这个头文件中暴露的接口。所有的头文件都建议参考以下的规则:      
           
        1,   头文件中不能有可执行代码,也不能有数据的定义,只能有宏、类型(typedef,struct,union,menu),数据和函数的声明。例如以下的代码可以包含在头文件里:      
        #define       NAMESTRING       “name”      
        typedef       unsign       long       word;      
        menu{      
        flag1;      
        flag2;      
        };      
        typedef       struct{      
        int       x;      
        int       y;      
        }       Piont;      
        extent       Fun(void);      
        extent       int       a;      
        全局变量和函数的定义不能出现在*.h文件里。例如下面的代码不能包含在头文件:      
        int       a;      
        void       Fun1(void)      
        {      
                        a++;      
        }      
           
        2,头文件中不能包本地数据(模块自己使用的数据或函数,不被其他模块使用)。这一点相当于面向对象程序设计里的私有成员,即只有模块自己使用的函数,数据,不要用extent在头文件里声明,只有模块自己使用的宏,常量,类型也不要在头文件里声明,应该在自己的*.c文件里声明。      
        3,含一些需要使用的声明。在头文件里声明外部需要使用的数据,函数,宏,类型。      
        4,防止被重复包含。使用下面的宏防止一个头文件被重复包含。      
        #ifndef       MY_INCLUDE_H      
        #define       MY_INCLUDE_H      
        <头文件内容 >      
        #endif      
        5,包含extern       "C",使的程序可以在C++编译器被编译      
        #ifdef       __cplusplus      
                        extern       "C"{      
        #endif      
        <函数声明 >      
        #ifdef       __cplusplus      
                        }      
        #enfif      
          被extern       "C"修饰的变量和函数是按照C语言方式编译和连接的;未加extern       “C”声明时的编译方式,作为一种面向对象的语言,C++支持函数重载,而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如,假设某个函数的原型为:          
        void       foo(       int       x,       int       y       );该函数被C编译器编译后在符号库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字(不同的编译器可能生成的名字不同,但是都采用了相同的机制,生成的新名字称为“mangled       name”)。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息,C++就是靠这种机制来实现函数重载的。例如,在C++中,函数void       foo(       int       x,       int       y       )与void       foo(       int       x,       float       y       )编译生成的符号是不相同的,后者为_foo_int_float。 同样地,C++中的变量除支持局部变量外,还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名,我们以"."来区分。而本质上,编译器在进行编译时,与函数的处理相似,也为类中的变量取了一个独一无二的名字,这个名字与用户程序中同名的全局变量名字不同。加extern       "C"声明后的编译和连接,强制C++连接器按照C编译器产生的符号_foo链接。      
        6,保证在使用这个头文件时,用户不用再包含使用此头文件的其他前提头文件,即要使用的头文件已经包含在此头文件里。例如:area.h头文件包含了面积相关的操作,要使用这个头文件不需同时包含了关于点操作的头文件piont.h。用户在使用area.h时不需要手动包含piont.h,因为我们已经在area.h中用#include       “point.h”包含了这个头文件。      
           
        有一些头文件是为用户提供调用接口,这种头文件中声明了模块中需要给其他模块使用的函数和数据,鉴于软件质量上的考虑,处理参考以上的规则,用来暴露接口的头文件还需要参考更多的规则:      
        1,一个模块一个接口,不能几个模块用一个接口。      
        2,文件名为和实现模块的c文件相同。abc.c--abc.h      
        3,尽量不要使用extern来声明一些共享的数据。因为这种做法是不安全的,外部其他模块的用户可能不能完全理解这些变量的含义,最好提供函数访问这些变量。      
        4,尽量避免包含其他的头文件,除非这些头文件是独立存在的。这一点的意思是,在作为接口的头文件中,尽量不要包含其他模块的那些暴露*.C文件中内容的头文件,但是可以包好一些不是用来暴露接口的头文件。      
        5,不要包含那些只有在可执行文件中才使用的头文件,这些头文件应该在*.c文件中包含。这一点如同上一点,为了提高接口的独立性和透明度。      
        6,接口文件要有面向用户的充足的注释。从应用角度描述个暴露的内容。      
        7,接口文件在发布后尽量避免修改,即使修改也要保证不影响用户程序。      
           
        多个代码文件使用一个接口文件:这种头文件用于那些认为一个模块使用一个文件太大的情况。对于这种情况对于这种情况在参考上述建议后,也要参考以下建议。      
        1,多个代码文件组成的一个模块只有一个接口文件。因为这些文件完成的是一个模块。      
        2,使用模块下文件命名 <系统名 > <模块名命名 >      
        3,不要滥用这种文件。      
        4,有时候也会出现几个*.c文件用于共向数据的*.h文件,这种文件的特点是在一个*.c文件里定义全局变量,而在其他*.c文件里使用,要将这种文件和用于暴露模块接口的文件区别。      
        5,一个模块如果有几个子模块,可以用一个*.h文件暴露接口,在这个文件里用#include包含每个子模块的接口文件。      
           
        还有一种头文件,说明性头文件,这种头文件不需要有一个对应的代码文件,在这种文件里大多包含了大量的宏定义,没有暴露的数据变量和函数。这些文件给出以下建议:      
        1,包含一些需要的概念性的东西.      
        2,命名方式,定义的功能.h      
        3,不包含任何其他的头文件.      
        4,不定义任何类型.      
        5,不包含任何数据和函数声明.      
           
        上面介绍了C头文件的一些建议,下面介绍C代码文件*.c文件的一些建议,*.c文件是C语言中生成汇编代码和机器码的内容,要注意以下建议:      
        1.命名方式       模块名.c      
        2,用static修饰本地的数据和函数。      
        3,不要使用external。这是在*.h中使用的,可以被包含进来。      
        4,无论什么时候定义内部的对象,确保独立与其他执行文件。      
        5,这个文件里必须包含相应功能函数。      
           
        上面介绍了一些C文件组织的建议,用于提高C语言项目的质量,在以后的C项目组织中,学习面向对象和COM的思想,将这些思想加入到C程序中,能够写出更高质量的代码。上面的建议在具体的项目里应该灵活运用,附录里有*.h头文件和*.c代码文件的模版,在工程中可以作为参考。另外,C工程中经常有一些汇编代码文件,这些文件也要使有*.h头文件暴露其中的数据和函数,以便其他*.c文件包含使用。
    展开全文
  • 本人收藏的C语言模块化编程的书籍,挺不错的一本书,非常受用,分享给大家
  • 单片机C语言模块化编程 高清pdf 单片机C语言模块化编程 高清pdf
  • 51黑论坛_keil软件C语言模块化编程.pdf
  • C语言模块化程序设计

    千次阅读 2017-09-07 22:29:29
    C语言模块化程序设计 模块划分 C语言模块化程序设计需理解如下概念:  (1) 模块即是一个.c文件和一个.h文件的结合,头文件(.h)中是对于该模块接口的声明;  (2) 某模块提供给其它模块调用的...

    C语言模块化程序设计

    模块划分


    C语言模块化程序设计需理解如下概念:

      (1) 模块即是一个.c文件和一个.h文件的结合,头文件(.h)中是对于该模块接口的声明;

      (2) 某模块提供给其它模块调用的外部函数及数据需在.h中文件中冠以extern关键字声明;

      (3) 模块内的函数和全局变量需在.c文件开头冠以static关键字声明;

      (4) 永远不要在.h文件中定义变量!定义变量和声明变量的区别在于定义会产生内存分配的操作,是汇编阶段的概念;而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。

     

    一个嵌入式系统通常包括两类模块:

      (1)硬件驱动模块,一种特定硬件对应一个模块;

      (2)软件功能模块,其模块的划分应满足低偶合、高内聚的要求。

    多任务还是单任务

      所谓"单任务系统"是指该系统不能支持多任务并发操作,宏观串行地执行一个任务。而多任务系统则可以宏观并行(微观上可能串行)地"同时"执行多个任务。

      多任务的并发执行通常依赖于一个多任务操作系统(OS),多任务OS的核心是系统调度器,它使用任务控制块(TCB)来管理任务调度功能。TCB包括任务的当前状态、优先级、要等待的事件或资源、任务程序码的起始地址、初始堆栈指针等信息。调度器在任务被激活时,要用到这些信息。此外,TCB还被用来存放任务的"上下文"(context)。任务的上下文就是当一个执行中的任务被停止时,所要保存的所有信息。通常,上下文就是计算机当前的状态,也即各个寄存器的内容。当发生任务切换时,当前运行的任务的上下文被存入TCB,并将要被执行的任务的上下文从它的TCB中取出,放入各个寄存器中。

     

    究竟选择多任务还是单任务方式,依赖于软件的体系是否庞大。例如,绝大多数手机程序都是多任务的,但也有一些小灵通的协议栈是单任务的,没有操作系统,它们的主程序轮流调用各个软件模块的处理程序,模拟多任务环境。

     

    单任务程序典型架构

      (1)从CPU复位时的指定地址开始执行;

      (2)跳转至汇编代码startup处执行;

      (3)跳转至用户主程序main执行,在main中完成:

      a.初试化各硬件设备; 

      b.初始化各软件模块;

      c.进入死循环(无限循环),调用各模块的处理函数

      用户主程序和各模块的处理函数都以C语言完成。用户主程序最后都进入了一个死循环,其首选方案是:

    while(1)
    {

     

    中断服务程序

      中断是嵌入式系统中重要的组成部分,但是在标准C中不包含中断。许多编译开发商在标准C上增加了对中断的支持,提供新的关键字用于标示中断服务程序(ISR),类似于__interrupt、#program interrupt等。当一个函数被定义为ISR的时候,编译器会自动为该函数增加中断服务程序所需要的中断现场入栈和出栈代码。

    中断服务程序需要满足如下要求:

      (1)不能返回值;

      (2)不能向ISR传递参数;

      (3) ISR应该尽可能的短小精悍;

      (4) printf(char * lpFormatString,…)函数会带来重入和性能问题,不能在ISR中采用。


    硬件驱动模块

      一个硬件驱动模块通常应包括如下函数:

      (1)中断服务程序ISR

      (2)硬件初始化

      a.修改寄存器,设置硬件参数(如UART应设置其波特率,AD/DA设备应设置其采样速率等);

      b.将中断服务程序入口地址写入中断向量表:

    /* 设置中断向量表 */
    m_myPtr = make_far_pointer(0l); /* 返回void far型指针void far * */ 
    m_myPtr += ITYPE_UART; /* ITYPE_UART: uart中断服务程序 */
    /* 相对于中断向量表首地址的偏移 */
    *m_myPtr = &UART _Isr; /* UART _Isr:UART的中断服务程序 */ 

      (3)设置CPU针对该硬件的控制线

      a.如果控制线可作PIO(可编程I/O)和控制信号用,则设置CPU内部对应寄存器使其作为控制信号;

      b.设置CPU内部的针对该设备的中断屏蔽位,设置中断方式(电平触发还是边缘触发)。

      (4)提供一系列针对该设备的操作接口函数。例如,对于LCD,其驱动模块应提供绘制像素、画线、绘制矩阵、显示字符点阵等函数;而对于实时钟,其驱动模块则需提供获取时间、设置时间等函数。

      C的面向对象

      在面向对象的语言里面,出现了类的概念。类是对特定数据的特定操作的集合体。类包含了两个范畴:数据和操作。而C语言中的struct仅仅是数据的集合,我们可以利用函数指针将struct模拟为一个包含数据和操作的"类"。下面的C程序模拟了一个最简单的"类":

    #ifndef C_Class
    #define C_Class struct
    #endif
    C_Class A 
    {
     C_Class A *A_this; /* this指针 */
     void (*Foo)(C_Class A *A_this); /* 行为:函数指针 */
     int a; /* 数据 */
     int b;
    }; 

      我们可以利用C语言模拟出面向对象的三个特性:封装、继承和多态,但是更多的时候,我们只是需要将数据与行为封装以解决软件结构混乱的问题。C模拟面向对象思想的目的不在于模拟行为本身,而在于解决某些情况下使用C语言编程时程序整体框架结构分散、数据和函数脱节的问题。我们在后续章节会看到这样的例子。 

      总结

      本篇介绍了嵌入式系统编程软件架构方面的知识,主要包括模块划分、多任务还是单任务选取、单任务程序典型架构、中断服务程序、硬件驱动模块设计等,从宏观上给出了一个嵌入式系统软件所包含的主要元素。

      请记住:软件结构是软件的灵魂!结构混乱的程序面目可憎,调试、测试、维护、升级都极度困难。

    展开全文
  • C语言模块化编程样例

    2021-04-26 22:38:47
    以下举例对C语言模块化编程进行浅析:项目中包含a.c和b.c文件,其中a.c中定义了变量/结构体,而b.c中需要用到这些变量/结构体,那么有如下几种方法可选: get/set封装 在a.c种为每个需要被外部引用的变量/结构体...

    模块化编程向来不是面向对象语言的专利,即使是C语言,为了降低文件、模块间的耦合度,依然要注意对变量、函数进行封装。
    以下举例对C语言模块化编程进行浅析:项目中包含a.c和b.c文件,其中a.c中定义了变量/结构体,而b.c中需要用到这些变量/结构体,那么有如下几种方法可选:

    1. get/set封装
      在a.c种为每个需要被外部引用的变量/结构体编写get/set函数,并在a.h中声明get/set函数,b.c include a.h,需要使用变量/结构体的值时调用get函数,需要设置变量/结构体时调用set函数:
    //a.c
    static int intA;
    static struct structType structData;
    
    int getA()
    {
    	return intA;
    }
    
    void setA(int a)
    {
    	intA = a;
    	return;
    }
    
    struct structType getStructData()
    {
    	return structData;
    }
    void setStructData(struct structType data)
    {
    	structData = data;
    	return;
    }
    
    //a.h
    struct structType{
    int c1;
    int c2;
    };
    
    int getA();
    void setA(int a);
    struct structType getStructData();
    void setStructData(struct structType data);
    
    //b.c
    #include "a.h"
    
    void funcB()
    {
    	int tmpA = getA();
    	tmpA += 1;
    	setA(tmpA);
    
    	struct structType structTmp = getStructData();
    	structTmp.c1 = 0;
    	setStructData(structTmp);
    	return;
    }
    

    写起来比较繁琐,但是是规规矩矩的封装。

    1. get进阶封装
      get/set封装使用时需要先get到变量值,加以修改后再set回去,相比之下,获取变量的地址之后直接进行修改要更方便些,写法如下:
    //a.c
    static int intA;
    static struct structType structData;
    
    int *getPA()
    {
    	return &intA;
    }
    
    struct structType *getPStructData()
    {
    	return &structData;
    }
    
    //a.h
    struct structType{
    int c1;
    int c2;
    };
    
    int *getPA();
    struct structType *getPStructData();
    
    //b.c
    #include "a.h"
    
    void funcB()
    {
    	int *tmpA = getPA();
    	(*tmpA) += 1;
    
    	struct structType *structTmp = getPStructData();
    	structTmp->c1 = 0;
    	return;
    }
    

    缺点是指针操作易发生段错误。

    1. 如果“b.c和a.c联系十分紧密,以至于b.c中用到的intA变量和a.c中用到的一样频繁”,这时也可以在get/set封装的基础上,在b.c中extern int intA;从而可以在b.c中直接使用intA,其他文件使用intA时借助get/set封装。而为了能让b.c extern,a.c中的intA就不能再加static,也就失去了get/set封装的意义,这是十分矛盾也是十分奇怪的写法。归根结底,“b.c和a.c联系十分紧密,以至于b.c中用到的intA变量和a.c中用到的一样频繁”这种情况是不应该出现的,如果两个文件联系紧密,那么该想想这两个文件是不是该合并成一个,或者把两者关于intA的操作提取出来单独存放。
      模块化编程成功的前提是对模块有好的拆分,没有好的拆分,封装的工作将变得十分棘手。
    展开全文
  • 模块化设计原则:高内聚第一步:创建头文件(源文件与头文件同名如delay.c与delay.h)第二步:防止重复包含处理在.h文件里加入#ifndefXXXX#defineXXXX.......#endif例如:#ifndef_DELAY_H__#define_DELAY_H__.......#...

    模块化设计原则:高内聚

    第一步:创建头文件(源文件与头文件同名如delay.c与delay.h)

    第二步:防止重复包含处理

    在.h文件里加入

    #ifndefXXXX

    #defineXXXX

    .......

    #endif

    例如:

    #ifndef_DELAY_H__

    #define_DELAY_H__

    .......

    #endif

    第三步: 代码封装(内部调用【.h封装外部调用的部分】)

    封装成函数或者宏定义以便提高可读性和可修改文件,尽量少用或者不用全局变量

    第四步:使用源文件

    .c文件添加到文件中

    模块化编程实例:

    delay.h文件

    #ifndef __DELAY_H__

    #define __DELAY_H__

    #define uchar unsingned char

    #define uint unsigned int

    void delay50us(uint t);

    void delay50ms(uint t);

    #endif

    delay.c文件

    #includereg52.h>

    #include"模块化编程实例.h"

    void delayus(uint t)//延时函数

    { uint j;

    for(;t>0;t--)

    for(j=6245;j>0;j--);

    }

    void delayms(uint t)//延时函数

    { uint j;

    for(;t>0;t--)

    for(j=6245;j>0;j--);

    }

    数码管.h文件

    #ifndef __DELAY_H__

    #define __DELAY_H__

    #define"模块化编程实例.h"

    #define uint unsigned int

    void dispaytable(uchar *p);

    void dispayt(uchar num0,uchar num1,uchar num2,uchar num3,uchar num4,uchar num5,uchar num6,uchar num7,);

    #endif

    数码管.c文件

    #include"数码管.h"

    #include"模块化编程实例.h"

    unsigned char code smg_du[]={0xfe,0xfd,0xfb,0xf7,0xef,0xbf,0x7f};

    unsigned char code smg_we[]={0x00,0x00,0x3e,0x41,0x41,0x41,0x3e,0x00};

    void display_table(uchar *p)

    {

    uchar i;

    foe(i=0;i8;i++)

    {

    P1=smg_du[*p];

    P2=smg_we[i];

    delay_50us(20);

    }

    }

    void display(uchar num0,uchar num1,uchar num2,uchar num3,uchar num4,uchar num5,uchar num6,uchar num7,)

    {

    P1=smg_du[mun0];

    P2=smg_we[0];

    delay_50us(20);

    P1=smg_du[mun1];

    P2=smg_we[1];

    delay_50us(20);

    P1=smg_du[mun2];

    P2=smg_we[2];

    delay_50us(20);

    P1=smg_du[mun3];

    P2=smg_we[3];

    delay_50us(20);

    P1=smg_du[mun4];

    P2=smg_we[4];

    delay_50us(20);

    P1=smg_du[mun5];

    P2=smg_we[5];

    delay_50us(20);

    P1=smg_du[mun6];

    P2=smg_we[6];

    delay_50us(20);

    P1=smg_du[mun7];

    P2=smg_we[7];

    delay_50us(20);

    }

    mian.c文件

    #include"数码管.h"

    #includereg52.h>

    #include"模块化编程实例.h"

    sbit rst=P3^6;

    unsigned char table[]={2,3,4,5,6,7,8,9};

    void main()

    {

    rst=0;

    while(1)

    { display_tale(table);

    }

    }

    展开全文
  • C语言模块化编程(我见过最好的),我目前就使用的,觉得不错
  • Keil软件C语言模块化编程讲述Keil模块化编程当你在一个项目小组做一个相对较复杂的工程时,意味着你不再独自单干。你需要和你的小组成员分工合作,一起完成项目,这就要求小组成员各自负责一部分工程。比如你可能...
  • C语言模块化编程的代码示例老赵最近写了一个小代码,是关于C语言程序化编程的,挺有趣的,和大家分享一下啦。一、程序概述二、程序结构三、 具体代码1、主函数2、随机数函数3、产生算法题函数4、答错反馈函数5、答对...
  • 嵌入式 Linux C语言(十一)——C语言模块化编程一、C语言模块化编程 所谓模块化编程,就是指一个程序包含多个源文件(.c 文件和 .h 文件),每个模块即是一个.c文件和一个.h文件的结合,头文件(.h)中是对于该模块...
  • C语言模块化编译介绍

    2015-06-25 20:26:00
    C语言模块化编译介绍 模块化编程的概念  所谓模块化变成(多文件开发),就是多文件(.c文件)编程,一个.c文件和一个.h文件可以被称为一个模块。 头文件开发的注意事项: 1)头文件中可以和C程序一样引用其它...
  • C语言模块化编程(我见过最好的)不下是你的错,不是我不传
  • C语言模块化设计控温器的实现 版本记录表 设计思路 设计一个控温器模块由加热器、制冷器、算法器三个子模块构成。控温器负责三个模块的协同工作以及与外界交换信息(设定值、实时值、控制参数等),并根据这些数据去...
  • keil中实现C语言模块化编程.doc在使用 KEIL 的时候,我们习惯上在一个.c 的文件中把自己要写的东西按照自己思路的顺序进行顺序书写。这样是很普遍的写法,当程序比较短的时候比如几十行或者一百多行,是没有什么问题的...
  • C语言模块化设计资料,主要描述了在做C语言开发时,要形成良好的编写习惯,包括备注、分享符号等,一方面可以提高自己的编写逻辑,另一方面可以让小伙伴看得懂自己的代码,或者3年后可以明白当初自己编程的思路。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,295
精华内容 1,318
关键字:

c语言模块化

c语言 订阅