关于模块化编程问题

and001

为了使程序更加结构紧凑，具有更好的条理化，程序员往往将自己的程序按模块分成若干个原文件（*。c）.然后用H头文件将函数相互关联起来，要调用就方便了！

现在我有个问题好象不是太明白，就是函数本身有时需要全局变量来参与运行如下：

KEY.C文件如:
void Key_SCan(void)
        {
               
        if(fkey_count)    //fkey_count是用来做标志，为“1”的时候才进入出来扫描
                {
//                P1=0xF4;
//        确认是自动扫描还是手动选择 ,手动时的自己输出  fhand_operation 1: 自动扫描 0: 手动
                uchar        Status_P_1_for_P1_0;
                fkey_count=0;
                Status_P_1_for_P1_0=P1;
                if(!(Status_P_1_for_P1_0&0x01)) {fhand_operation=0;}
                else{fhand_operation=1;}                                               
                old_status=new_status;
                new_status=P1;       
                }


KEY.H文件如:
         #ifndef _KEY_H_
         #define _KEY_H_
/*
void Key_SCan(void);  //在这里申明各函数
....
   
   上面是的fkey_count位变量应该怎么处理比较合适呢？是在头文件H中定义还是怎么样？一般好象是不定义变量的在其他原。C文件中不定义，请问有经验的朋友，你们是怎么处理的？


  另外，调用数是用带参还是尽量不用带参数好，如果带参的话，就好象不用在KEY.C文件中定义全局位变量（只要用形参传进来就好了）请大家各抒己见...

millwood0

就是函数本身有时需要全局变量来参与运行如下：

Generally speaking, global variables are evil and should be reduced as much as you can.

   上面是的fkey_count位变量应该怎么处理比较合适呢？

Two approaches, in three expressions:

1) you can make the global variable globally accessbile, by declaring it extern in the .h file.
2) you can write a wrapper function that returns fkey_count's value - this is the more prudent but more expensive approach.
3) you can write a wrapper macro that returns fkey_count's value - this is fundamentally the #1 approach above. Sub-optimal but fast. You can further improve its safety by limiting your access to the variable via just the macro, and on some (good) compilers, you can declare that variable "const" in the .h file - this may not work if the compiler you are using is not exactly C-compliant (it will then put "const" variables in the flash).

Etual

对于模块以外使用的全局变量，不能通过
extern int var 的形式去调用，应该这样做：

static int var;

int get_var(void)
{
    return var;
}

在其他文件中需要用到这个变量，则不能extern int var，而要通过接口
get_var()  来访问。

从用户的角度来看，这个模块就是一个黑盒子，我不知道他里面什么变量，是什么，怎么得到的，
我只关心我能用什么，我通过调用API 就能拿到什么数据。（类似C++的类，成员函数等等思想）
这样可移植性就好了，你只需要在新平台上实现这些接口，其他程序都不需要改了。
这就是模块化，而不是说，分开几个文件来写程序就是模块化了。

devcang

一般的MCU，才多少空间，搞模块不是MCU必要的。


这模块化，是需要付出代价的。

badboy.tao

两个头文件，一个给外部，一个给自己

zhugean

对于全局变量
如果是C文件本身用的就定义在C文件中，并用static修饰
如果只是这个函数用的就定义在函数中，并用static修饰
如果是给别的文件用的则定义在C文件，不加修饰，并在h文件中声明成外部变量，用extern修饰

zhugean

个人见解：
对于嵌入式系统不太建议使用类似C++的封装方式来调用全局变量
速度慢，而且每个BYTE的FLASH都是钱啊

and001

zhugean 发表于 2013-8-5 11:11
对于全局变量
如果是C文件本身用的就定义在C文件中，并用static修饰
如果只是这个函数用的就定义在函数中， ...

很精炼，很容易理解！赞一个呀！



还有一点就是：
如果是给别的文件和本身用的呢？定义在H文件中合适吗？

zhugean

给别的文件和本身用的 同给别的文件
C文件要包含自己的H文件

and001

badboy.tao 发表于 2013-8-5 08:50
两个头文件，一个给外部，一个给自己

这个不懂？能具体点吗？

zhugean

一个C只能对应一个H文件

badboy.tao

and001 发表于 2013-8-5 13:53
这个不懂？能具体点吗？

给外部的放给其它模块调用的函数声明和变量声明，注释尽量写详细，这样人家就只看你这个.H文件就知道怎么来调用你的函数了。

给内部用的.H，原本是放在.C文件开头定义的这个模块用的全局变量，和函数声明，我为了美观，单独用了一个.H，放在那里

qingyin2009

devcang 发表于 2013-8-5 08:36
一般的MCU，才多少空间，搞模块不是MCU必要的。

其实占用空间是一样的，只是阅读修改起来不一样罢了

小程序当然不必要，当程序比较多的时候，一万行的程序写一个里面，那你翻看时要多么麻烦。

and001

是的！感觉按功能模块来比较合适

devcang

qingyin2009 发表于 2013-8-5 17:57
其实占用空间是一样的，只是阅读修改起来不一样罢了

小程序当然不必要，当程序比较多的时候，一万行的程 ...

不错，  几K的程序，不必的了。  

and001

我觉得这是一种编程风格，要严格规范要求自己，习惯养成了要面对ARM复杂程序就条理更清楚了！

millwood0

Writing a modular code base is not just to make it more readable, but also to make it re-usable for your next job.

The following is an example:

1. 
   
2. //#include <avr/io.h>  //we use gcc-avr
   
3. #include <regx51.h>                                                        //we use keil c51
   
4. #include "gpio.h"
   
5. //#include "delay.h"
   
6. #include "tmr0.h"                                                        //we use hardware tmr
   
7. 
   
8. //hardware configuration
   
9. #define P1_PORT                        P2
   
10. #define P2_DDR                        P2
    
11. #define P1_OUT                        (1<<0)                                //pulse 1 output pin
    
12. #define P1_PR                        (TMR_20ms + TMR_5ms)        //p1's period
    
13. #define P1_TMR                        TMR_5ms                                //tmr interrupts every 5ms
    
14. #define P1_WIDTH()                {NOP();}                        //p1's pulse width
    
15. //end hardware configuration
    
16. 
    
17. //reset the pins
    
18. void p1_init(void) {
    
19.         IO_CLR(P1_PORT, P1_OUT);                                //idles low
    
20.         IO_OUT(P1_DDR, P1_OUT);                                        //pin as output
    
21. }
    
22. 
    
23. //output a pulse
    
24. void p1_out(void) {
    
25.         static unsigned char p1_count=0;                //counter
    
26. 
    
27.         p1_count+=1;
    
28.         if (p1_count>=(P1_PR / P1_TMR)) {                //50ms has been reached
    
29.                 p1_count -= (P1_PR / P1_TMR);                //update p1_count
    
30.                 //output 12 pulses, 50% dc, with duration P1_WIDTH()
    
31.                 //each pulse takes (2 + 1) * 2 us, at 12Mhz crystal, 12:1 prescaler
    
32.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
33.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
34.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
35.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
36.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
37.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
38.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
39.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
40.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
41.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
42.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
43.                 IO_SET(P1_PORT, P1_OUT); P1_WIDTH(); IO_CLR(P1_PORT, P1_OUT); P1_WIDTH();
    
44.         }
    
45. }
    
46. 
    
47. void mcu_init(void) {
    
48. }
    
49. 
    
50. int main(void) {
    
51.         mcu_init();                                                                //reset the mcu
    
52.         p1_init();                                                                //reset the pins
    
53.         tmr0_init(1, TMR_5ms);                                        //5ms per interrupt
    
54.         tmr0_act(p1_out);                                                //install handler
    
55.         ei();
    
56.         while (1) {
    
57.         }
    
58. }
    

复制代码

It is a piece of code that I wrote to generate a series of short pulses every 25ms. It was originally written for an avr, utilizing tmr0. I simply copy-and-paste the avr code, made a few minor changes, and then plug in the corresponding C51 timer modules and then code now runs on 89C51.

The way those modules are coded allows me to reuse the code base, with confidence that they would work for a new chip - because I have debug'd and tested them before and they share the same interface.

That is really the beauty of writing modular / portable code.

wzd5230

我的经验是头文件里面只声明函数，不要定义变量，可以定义枚举体什么的，但是不要定义变量，否则在重复包含头文件的时候会有变量重复定义的问题，全局变量就在.c文件中定义就可以了，如果需要在别的文件中进行引用，直接在需要引用的那个文件里定义外部变量，比如：extern int var;这样就可以在这个文件里面用了。

ghostxdy

Etual 发表于 2013-8-5 08:23
对于模块以外使用的全局变量，不能通过
extern int var 的形式去调用，应该这样做：

这番话点醒了我，谢谢

and001

wzd5230 发表于 2013-8-8 23:54
我的经验是头文件里面只声明函数，不要定义变量，可以定义枚举体什么的，但是不要定义变量，否则在重复包含 ...

你最后那句话很金典----很多书上好像没说！我很容易搞混‘EXTERN’的实际意思！总是弄糊涂！这算是懂了！

and001

millwood0 发表于 2013-8-8 19:03
Writing a modular code base is not just to make it more readable, but also to make it re-usable for  ...

谢谢你！模块化编程的可读性和可移植性都应该比较好吧！

jhjkdz

学习。。。。。