探讨一下方法的封装

wwwymq

函数，宏，类都能对代码进行抽象，实验代码的复用。
用一个简单的应用来探讨下。
首先大家认为单片机怎么才算是入门了？
我认为是从开始思考处理多任务，开始思考如何消除万恶delay()函数开始的。
所以说我决定用定时调用来举例：
首先是最基本的用法，刚开始肯定会写出这样的代码：

1. unsigned long startTime, delayTime;
   
2. void setup() {
   
3.   // put your setup code here, to run once:
   
4.   startTime = millis();
   
5.   delayTime = 1000;
   
6. }
   
7. 
   
8. void loop() {
   
9.   // put your main code here, to run repeatedly:
   
10.   if (millis() - startTime > delayTime)
    
11.   {
    
12.     //做一些事情
    
13.     startTime = millis();
    
14.   }
    
15. }

复制代码

如果同时有两个任务要运行怎么办？粘贴复制。

1. unsigned long startTime, delayTime;
   
2. unsigned long startTime1, delayTime1;
   
3. void setup() {
   
4.   // put your setup code here, to run once:
   
5.   startTime = millis();
   
6.   delayTime = 1000;
   
7.   startTime1 = millis();
   
8.   delayTime1 = 2000;
   
9. }
   
10. 
    
11. void loop() {
    
12.   // put your main code here, to run repeatedly:
    
13.   if (millis() - startTime > delayTime)
    
14.   {
    
15.     //做一些事情
    
16.     startTime = millis();
    
17.   }
    
18.   if (millis() - startTime1 > delayTime1)
    
19.   {
    
20.     //做一些事情
    
21.     startTime1 = millis();
    
22.   }
    
23. }

复制代码

如果有N个任务又怎么办呢，如果N超级大，我们还能粘贴复制吗？显然是不行的，这时候必须考虑吧这个功能进行封装。
在封装一个函数的时候，一定要考虑函数的可重入问题。
那么什么样的函数是可重入的呢？就是在函数在一个地方调用的时候不会影响到另一个地方的调用，这就必须要求我们的数据和功能是分离的。

1. unsigned long startTime, delayTime;
   
2. unsigned long startTime1, delayTime1;
   
3. typedef void (*action)();//回调函数指针
   
4. void timer(unsigned long *, action , unsigned long) ;
   
5. void setup() {
   
6.   // put your setup code here, to run once:
   
7.   startTime = millis();
   
8.   delayTime = 1000;
   
9.   startTime1 = millis();
   
10.   delayTime1 = 2000;
    
11.   Serial.begin(9600);
    
12. }
    
13. 
    
14. void loop() {
    
15.   // put your main code here, to run repeatedly:
    
16.   timer(&startTime, things, delayTime);
    
17.   timer(&startTime1, things, delayTime1);
    
18. }
    
19. void timer(unsigned long *startTime, action doSomething, unsigned long delayTime) {
    
20.   if (millis() - *startTime > delayTime)
    
21.   {
    
22.     //做一些事情
    
23.     doSomething();
    
24.     *startTime = millis();
    
25.   }
    
26. }
    
27. void things() {
    
28.   Serial.println("hello");
    
29. }

复制代码

如果要更整洁一些可以这样写，把细节封装到结构体中。

1. typedef void (*action)();//回调函数指针
   
2. typedef struct timStruct//定时结构体
   
3. {
   
4.   unsigned long startTime;
   
5.   action func;
   
6. };
   
7. void timer(timStruct *, unsigned long) ;
   
8. timStruct tim1, tim2;
   
9. void setup() {
   
10.   // put your setup code here, to run once:
    
11.   tim1.startTime = millis;
    
12.   tim1.func = things;
    
13.   tim2.startTime = millis;
    
14.   tim2.func = things;
    
15. 
    
16.   Serial.begin(9600);
    
17. }
    
18. 
    
19. void loop() {
    
20.   // put your main code here, to run repeatedly:
    
21.   timer(&tim1, 1000);
    
22.   timer(&tim2, 2000);
    
23. }
    
24. void timer(timStruct *tim, unsigned long delayTime) {
    
25.   if (millis() - tim->startTime > delayTime)
    
26.   {
    
27.     //做一些事情
    
28.     tim->func();
    
29.     tim->startTime = millis();
    
30.   }
    
31. }
    
32. void things() {
    
33.   Serial.println("hello");
    
34. }

复制代码

其实仔细思考一下，startTime这个参数并不是我想知道的，用户只关心定时器在什么时候做什么事情，而不是关心实现的细节，只有doSomething和delayTime是需要关心的，因此应该把start这个参数藏起来，而这个工作，就是cpp中的类，面向对象编程所完成的工作。

1. typedef void (*action)();//回调函数指针
   
2. 
   
3. class timer
   
4. {
   
5.   private:
   
6.     unsigned long startTime;
   
7.     static void kong() {
   
8.       Serial.println("nothing");
   
9.     }
   
10.   public:
    
11.     action func;
    
12.     timer(action);
    
13.     timer();
    
14.     Run(unsigned long delayTime);
    
15. };
    
16. 
    
17. timer tim1, tim2;
    
18. void setup() {
    
19.   // put your setup code here, to run once:
    
20.   tim1 = timer(things);
    
21.   tim2 = timer();
    
22.   Serial.begin(9600);
    
23. }
    
24. 
    
25. void loop() {
    
26.   // put your main code here, to run repeatedly:
    
27.   tim1.Run(1000);
    
28.   tim2.Run(2000);
    
29. }
    
30. void things() {
    
31.   Serial.println("hello");
    
32. }
    
33. timer::timer(action doSomething)
    
34. {
    
35.   func = doSomething;
    
36. }
    
37. timer::timer()
    
38. {
    
39.   func = kong;
    
40. }
    
41. timer::Run(unsigned long delayTime)
    
42. {
    
43.   if (millis() - startTime > delayTime)
    
44.   {
    
45.     //做一些事情
    
46.     func();
    
47.     startTime = millis();
    
48.   }
    
49. }

复制代码

只要把类的声明放到.h文件中，实现放到.cpp文件中，就完成了一个方法的封装。
最后看看用宏如何封装

1. #define timer(func,delayTime)({\
   
2.     static unsigned long startTime = millis();\
   
3.     if (millis() - startTime > delayTime){\
   
4.       func; \
   
5.       startTime = millis(); \
   
6.     }\
   
7.   })
   
8. void setup() {
   
9.   Serial.begin(9600);
   
10. }
    
11. void loop() {
    
12.   // put your main code here, to run repeatedly:
    
13.   timer(things(), 1000);
    
14.   timer(Serial.println("timer2"), 2000);
    
15. }
    
16. void things() {
    
17.   Serial.println("hello");
    
18. }

复制代码

可以看出来，用宏封装异常的简洁，在宏中用static定义的静态变量实现了数据上的隔离，每一个都是独立的副本，同时还能在完成初始化的工作。在方法的调用上也是最灵活的，可以写入任意的表达式，而不一定要局限于函数指针。
但是宏也只限于封装比较简单的方法，过于复杂的方法会造成代码量过大，同时也不容易改错，思路不清晰时会很不安全。
但就个人而言认为用c语言加传递结构体指针的方法更加通用，毕竟不是所有的单片机都有c++编译器的。