嵌入式 C 语言设计模式，在STC89C52上的应用

最新推荐文章于 2024-04-29 19:12:31 发布
最新推荐文章于 2024-04-29 19:12:31 发布
阅读量408 收藏 3
点赞数 1
文章标签： c语言 策略模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zp1990412/article/details/130894191
版权

嵌入式系统中的C语言设计模式主要包括以下几种：

  1. 状态机模式：状态机模式是一种常用的嵌入式系统设计模式，可以用于处理多状态的控制逻辑。状态机模式将系统的状态和状态转换定义为一组状态和转换规则，通过状态转换来实现控制逻辑。

  2. 观察者模式：观察者模式是一种常用的事件处理模式，可以用于处理系统中的事件通知。观察者模式将事件处理和事件通知分离开来，通过注册和通知机制来实现事件处理。

  3. 适配器模式：适配器模式是一种常用的接口转换模式，可以用于处理系统中的接口兼容问题。适配器模式将不兼容的接口转换为兼容的接口，从而实现系统的兼容性。

  4. 单例模式：单例模式是一种常用的对象创建模式，可以用于控制系统中的对象数量。单例模式通过限制对象创建数量来实现系统的控制和优化。

  5. 工厂模式：工厂模式是一种常用的对象创建模式，可以用于处理系统中的对象创建和管理。工厂模式将对象的创建和管理分离开来，通过工厂来实现对象的创建和管理。

  6. 策略模式：策略模式是一种常用的算法处理模式，可以用于处理系统中的算法选择和执行。策略模式将不同的算法实现定义为一组策略，通过策略选择来实现算法的处理。

以上是常用的嵌入式系统中的C语言设计模式，不同的设计模式适用于不同的应用场景，需要根据具体的需求进行选择和应用。

采用嵌入式 C 语言设计模式，写STC89C52,P2口8个按键的C51应用实例

状态机模式

好的，以下是一个简单的状态机模式的例子，用于控制STC89C52芯片的P2口8个按键。请注意，这只是一个基本的示例，实际上，您可能需要根据您的具体需求进行修改和优化。

#include <reg52.h>

#define KEY_PORT P2 // 按键端口
sbit LED = P1^0; // LED端口

typedef enum{
    IDLE_STATE = 0,
    KEY1_PRESSED,
    KEY2_PRESSED,
    KEY3_PRESSED,
    KEY4_PRESSED,
    KEY5_PRESSED,
    KEY6_PRESSED,
    KEY7_PRESSED,
    KEY8_PRESSED
} KeyState;

void key_scan(void)
{
    static KeyState state = IDLE_STATE;
    switch(state){
        case IDLE_STATE:
            if(KEY_PORT != 0xFF){ // 检测到按键按下
                switch(KEY_PORT){
                    case 0xFE:
                        state = KEY1_PRESSED;
                        break;
                    case 0xFD:
                        state = KEY2_PRESSED;
                        break;
                    case 0xFB:
                        state = KEY3_PRESSED;
                        break;
                    case 0xF7:
                        state = KEY4_PRESSED;
                        break;
                    case 0xEF:
                        state = KEY5_PRESSED;
                        break;
                    case 0xDF:
                        state = KEY6_PRESSED;
                        break;
                    case 0xBF:
                        state = KEY7_PRESSED;
                        break;
                    case 0x7F:
                        state = KEY8_PRESSED;
                        break;
                    default:
                        break;
                }
            }
            break;
        case KEY1_PRESSED:
            LED = ~LED; // LED取反
            state = IDLE_STATE;
            break;
        case KEY2_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY3_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY4_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY5_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY6_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY7_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        case KEY8_PRESSED:
            // do something
            state = IDLE_STATE;
            break;
        default:
            state = IDLE_STATE;
            break;
    }
}

void main()
{
    while(1)
    {
        key_scan(); // 扫描按键
    }
}

在上面的代码中，我们使用了一个枚举类型(KeyState)来表示状态机的状态。在 key_scan() 函数中，我们使用一个静态变量 state 来表示当前状态，并根据按键的状态来切换状态。当检测到按键按下时，我们根据按键的值来切换到不同的状态，然后执行相应的操作。当状态执行完毕后，我们将状态切换回 IDLE_STATE，等待下一次按键事件的发生。

请注意，上面的代码只是一个简单的示例，您需要根据您的具体需求进行修改和优化。同时，如果您使用的是不同的开发板，您需要根据您的开发板来修改代码中的引脚定义和端口号。

观察者模式

好的，下面是基于观察者模式的STC89C52 P2口8个按键的C51代码：

#include <reg52.h>
#include <intrins.h>

#define uint unsigned int
#define uchar unsigned char

// 定义观察者模式的接口
typedef struct {
  void (*press)(uchar key);  // 按键按下事件
  void (*release)(uchar key);  // 按键释放事件
} KeyObserver;

// 定义按键
typedef struct {
  uchar state;  // 按键状态，0表示未按下，1表示按下
  uchar code;  // 按键编码，从0开始
  KeyObserver* observer;  // 观察者，可以为空
} Key;

// 定义按键数组
Key keys[8];

// 定义状态机
typedef enum {
  IDLE, PRESSED, RELEASED
} KeyState;

// 定义状态机转移表
KeyState stateTable[3][2] = {
  {PRESSED, IDLE},  // IDLE状态下按下按键，转移到PRESSED状态
  {PRESSED, RELEASED},  // PRESSED状态下释放按键，转移到RELEASED状态
  {IDLE, IDLE}  // RELEASED状态下不做任何事情，转移到IDLE状态
};

// 定义按键扫描函数
void scanKeys() {
  uchar i;
  for (i = 0; i < 8; i++) {
    // 设置P2口为输入
    P2 = P2 & ~(1 << i);
    _nop_();
    _nop_();
    _nop_();
    keys[i].state = (P2 >> i) & 1;  // 读取P2口状态
    // 设置P2口为输出
    P2 = P2 | (1 << i);
  }
}

// 定义按键状态机处理函数
void handleKeys() {
  uchar i;
  for (i = 0; i < 8; i++) {
    Key* key = &keys[i];
    KeyState prevState = key->state;
    KeyState nextState = stateTable[prevState][key->state];
    key->state = nextState;
    if (prevState == IDLE && nextState == PRESSED) {
      // 触发按键按下事件
      if (key->observer != NULL && key->observer->press != NULL) {
        key->observer->press(key->code);
      }
    } else if (prevState == PRESSED && nextState == RELEASED) {
      // 触发按键释放事件
      if (key->observer != NULL && key->observer->release != NULL) {
        key->observer->release(key->code);
      }
    }
  }
}

// 定义状态机模式的例子，用于控制P2口8个按键
void main() {
  uchar i;
  // 初始化按键数组
  for (i = 0; i < 8; i++) {
    keys[i].state = 0;
    keys[i].code = i;
    keys[i].observer = NULL;
  }
  // 设置P2口为输出
  P2 = 0xff;
  // 循环扫描按键并处理状态机
  while (1) {
    scanKeys();
    handleKeys();
  }
}

在这个例子中，我们定义了一个观察者模式的接口KeyObserver，用于定义按键按下和释放事件的回调函数。然后定义了一个按键结构体Key，包含了按键的状态、编码和观察者。接着定义了一个按键数组keys，用于存储8个按键的状态。然后定义了一个状态机KeyState，包含了三个状态：IDLE、PRESSED和RELEASED。接着定义了一个状态机转移表stateTable，用于根据当前状态和输入状态计算下一个状态。然后定义了按键扫描函数scanKeys()，用于读取P2口的状态并更新按键的状态。接着定义了按键状态机处理函数handleKeys()，用于根据当前状态和下一个状态触发按键事件。最后在main()函数中初始化按键数组，并循环调用scanKeys()和handleKeys()函数来处理按键事件。

请注意，这只是一个简单的例子，仅用于演示如何使用观察者模式设计嵌入式系统中的按键处理程序。实际应用中，可能需要根据具体情况进行修改和优化。

适配器模式

好的，以下是一个使用嵌入式C语言设计模式中的适配器模式来设计STC89C52芯片P2口8个按键的C51完整代码：

#include <reg52.h> 
#include <intrins.h>

#define uint unsigned int
#define uchar unsigned char

sbit K1 = P2^0;
sbit K2 = P2^1;
sbit K3 = P2^2;
sbit K4 = P2^3;
sbit K5 = P2^4;
sbit K6 = P2^5;
sbit K7 = P2^6;
sbit K8 = P2^7;

/* 适配器模式 */
typedef struct {
    void (*init)(void);
    uint (*read)(void);
} KeyAdapter;

/* 适配器实现 */
void P2AdapterInit(void) {
    P2 = 0xff;
}

uint P2AdapterRead(void) {
    return P2;
}

/* 状态机模式 */
typedef enum {
    IDLE = 0,
    PRESS,
    RELEASE
} KeyState;

/* 状态机结构体 */
typedef struct {
    KeyState state;
    uint cnt;
} KeyFSM;

/* 状态机初始化 */
void KeyFSMInit(KeyFSM* fsm) {
    fsm->state = IDLE;
    fsm->cnt = 0;
}

/* 状态机更新 */
void KeyFSMUpdate(KeyFSM* fsm, uint input) {
    switch(fsm->state) {
        case IDLE:
            if(input != 0xff) {
                fsm->state = PRESS;
                fsm->cnt = 0;
            }
            break;
        case PRESS:
            if(input == 0xff) {
                fsm->state = RELEASE;
                fsm->cnt = 0;
            }
            else {
                fsm->cnt++;
                if(fsm->cnt == 100) {
                    fsm->cnt = 0;
                    /* 按键按下 */
                    if(input & 0x01) {
                        /* K1被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x02) {
                        /* K2被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x04) {
                        /* K3被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x08) {
                        /* K4被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x10) {
                        /* K5被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x20) {
                        /* K6被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x40) {
                        /* K7被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                    else if(input & 0x80) {
                        /* K8被按下 */
                        // TODO: 在这里添加相应的处理代码
                    }
                }
            }
            break;
        case RELEASE:
            if(input != 0xff) {
                fsm->state = PRESS;
                fsm->cnt = 0;
            }
            break;
        default:
            break;
    }
}

/* 主函数 */
void main() {
    KeyAdapter adapter = {
        .init = P2AdapterInit,
        .read = P2AdapterRead
    };
    KeyFSM fsm;
    KeyFSMInit(&fsm);
    adapter.init();
    while(1) {
        uint input = adapter.read();
        KeyFSMUpdate(&fsm, input);
    }
}

在这段代码中，我们使用了适配器模式来适配STC89C52芯片的P2口输入，使得我们可以将其当做一个普通的按键输入来处理。然后，我们使用状态机模式来处理按键的按下和弹起事件，并在按键按下时调用相应的处理代码。在这里，我们只是留下了一些TODO标记，你需要根据具体的需求来编写相应的处理代码。

单例模式

好的，以下是一个基于状态机模式的单例模式设计的STC89C52芯片P2口8个按键的C51完整代码，供您参考：

#include <reg52.h>

// 定义按键的状态
#define KEY_UP 0
#define KEY_DOWN 1

// 定义状态机的状态
typedef enum {
  STATE_IDLE,
  STATE_PRESS,
  STATE_RELEASE
} State;

// 定义单例模式实例
static State state = STATE_IDLE;

// 定义按键的状态数组
static unsigned char key_states[8] = {0};

// 定义按键的状态更新函数
void update_key_states() {
  // 读取P2口的值
  unsigned char p2_value = P2;
  
  // 遍历8个按键
  for (int i = 0; i < 8; i++) {
    // 判断按键状态是否改变
    if ((p2_value & (1 << i)) && key_states[i] == KEY_UP) {
      key_states[i] = KEY_DOWN;
    } else if (!(p2_value & (1 << i)) && key_states[i] == KEY_DOWN) {
      key_states[i] = KEY_UP;
    }
  }
}

// 定义状态机的状态转换函数
void transition_state() {
  switch (state) {
    case STATE_IDLE:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_DOWN) {
          state = STATE_PRESS;
          break;
        }
      }
      break;
      
    case STATE_PRESS:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_UP) {
          state = STATE_RELEASE;
          break;
        }
      }
      break;
      
    case STATE_RELEASE:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_DOWN) {
          state = STATE_PRESS;
          break;
        }
      }
      if (state == STATE_RELEASE) {
        state = STATE_IDLE;
      }
      break;
  }
}

// 定义主函数
void main() {
  while (1) {
    update_key_states();
    transition_state();
    
    // 按键按下时的处理
    if (state == STATE_PRESS) {
      // TODO: 在此处编写按键按下时的处理代码
    }
    
    // 按键释放时的处理
    if (state == STATE_RELEASE) {
      // TODO: 在此处编写按键释放时的处理代码
    }
  }
}

需要注意的是，以上代码只是一个示例，您需要根据具体需求进行修改和完善。另外，您还需要根据硬件连接情况修改按键状态更新函数中的P2口读取代码。

工厂模式

好的，以下是一个基于工厂模式的STC89C52芯片P2口8个按键的C51完整代码，供您参考：

#include <reg52.h>

// 定义按键的状态
#define KEY_UP 0
#define KEY_DOWN 1

// 定义状态机的状态
typedef enum {
  STATE_IDLE,
  STATE_PRESS,
  STATE_RELEASE
} State;

// 定义按键的状态数组
static unsigned char key_states[8] = {0};

// 定义按键处理器接口
typedef void (*KeyHandler)(void);

// 定义按键处理器工厂
typedef struct {
  KeyHandler press_handler;
  KeyHandler release_handler;
} KeyHandlerFactory;

// 定义按键处理器
static void handle_key_1_press(void) {
  // TODO: 在此处编写按键1按下时的处理代码
}

static void handle_key_1_release(void) {
  // TODO: 在此处编写按键1释放时的处理代码
}

static void handle_key_2_press(void) {
  // TODO: 在此处编写按键2按下时的处理代码
}

static void handle_key_2_release(void) {
  // TODO: 在此处编写按键2释放时的处理代码
}

// 定义按键处理器工厂实例
static KeyHandlerFactory key_handler_factory[8] = {
  { handle_key_1_press, handle_key_1_release },
  { handle_key_2_press, handle_key_2_release },
  // TODO: 在此处添加剩余按键的处理器
};

// 定义按键的状态更新函数
void update_key_states() {
  // 读取P2口的值
  unsigned char p2_value = P2;
  
  // 遍历8个按键
  for (int i = 0; i < 8; i++) {
    // 判断按键状态是否改变
    if ((p2_value & (1 << i)) && key_states[i] == KEY_UP) {
      key_states[i] = KEY_DOWN;
    } else if (!(p2_value & (1 << i)) && key_states[i] == KEY_DOWN) {
      key_states[i] = KEY_UP;
    }
  }
}

// 定义状态机的状态转换函数
void transition_state() {
  static State state = STATE_IDLE;
  
  switch (state) {
    case STATE_IDLE:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_DOWN) {
          state = STATE_PRESS;
          break;
        }
      }
      break;
      
    case STATE_PRESS:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_UP) {
          state = STATE_RELEASE;
          break;
        }
      }
      break;
      
    case STATE_RELEASE:
      for (int i = 0; i < 8; i++) {
        if (key_states[i] == KEY_DOWN) {
          state = STATE_PRESS;
          break;
        }
      }
      if (state == STATE_RELEASE) {
        state = STATE_IDLE;
      }
      break;
  }
  
  // 调用对应的按键处理器
  if (state == STATE_PRESS) {
    for (int i = 0; i < 8; i++) {
      if (key_states[i] == KEY_DOWN) {
        key_handler_factory[i].press_handler();
      }
    }
  } else if (state == STATE_RELEASE) {
    for (int i = 0; i < 8; i++) {
      if (key_states[i] == KEY_UP) {
        key_handler_factory[i].release_handler();
      }
    }
  }
}

// 定义主函数
void main() {
  while (1) {
    update_key_states();
    transition_state();
  }
}

需要注意的是，以上代码只是一个示例，您需要根据具体需求进行修改和完善。另外，您还需要根据硬件连接情况修改按键状态更新函数中的P2口读取代码，并根据实际需求添加按键处理器工厂中的处理器函数。

策略模式

好的，以下是一个基于策略模式的STC89C52芯片P2口8个按键的C51完整代码，供您参考：

#include <reg52.h>

// 定义按键的状态
#define KEY_UP 0
#define KEY_DOWN 1

// 定义按键处理器接口
typedef void (*KeyHandler)(void);

// 定义按键处理器策略
typedef struct {
  KeyHandler press_handler;
  KeyHandler release_handler;
} KeyHandlerStrategy;

// 定义按键处理器
static void handle_key_1_press(void) {
  // TODO: 在此处编写按键1按下时的处理代码
}

static void handle_key_1_release(void) {
  // TODO: 在此处编写按键1释放时的处理代码
}

static void handle_key_2_press(void) {
  // TODO: 在此处编写按键2按下时的处理代码
}

static void handle_key_2_release(void) {
  // TODO: 在此处编写按键2释放时的处理代码
}

// 定义按键处理器策略数组
static KeyHandlerStrategy key_handler_strategies[8] = {
  { handle_key_1_press, handle_key_1_release },
  { handle_key_2_press, handle_key_2_release },
  // TODO: 在此处添加剩余按键的处理器策略
};

// 定义按键状态数组
static unsigned char key_states[8] = {0};

// 定义按键状态更新函数
void update_key_states() {
  // 读取P2口的值
  unsigned char p2_value = P2;
  
  // 遍历8个按键
  for (int i = 0; i < 8; i++) {
    // 判断按键状态是否改变
    if ((p2_value & (1 << i)) && key_states[i] == KEY_UP) {
      key_states[i] = KEY_DOWN;
    } else if (!(p2_value & (1 << i)) && key_states[i] == KEY_DOWN) {
      key_states[i] = KEY_UP;
    }
  }
}

// 定义按键状态处理函数
void handle_key_states() {
  // 遍历8个按键
  for (int i = 0; i < 8; i++) {
    // 判断按键状态
    if (key_states[i] == KEY_DOWN) {
      // 调用按键按下处理器
      key_handler_strategies[i].press_handler();
    } else if (key_states[i] == KEY_UP) {
      // 调用按键释放处理器
      key_handler_strategies[i].release_handler();
    }
  }
}

// 定义主函数
void main() {
  while (1) {
    update_key_states();
    handle_key_states();
  }
}

需要注意的是，以上代码只是一个示例，您需要根据具体需求进行修改和完善。另外，您还需要根据硬件连接情况修改按键状态更新函数中的P2口读取代码，并根据实际需求添加按键处理器策略。

zp1990412
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C嵌入式编程设计模式（pdf 压缩）
07-26
本书以面向对象的视角，重新审视嵌入式系统，全面总结了嵌入式系统中常见的以及关键的设计模式。
C语言设计模式
Bonaventure的博客
02-02 3069
C语言设计模式
C语言设计模式：实现简单工厂模式和工程创建
m0_74985965的博客
03-07 1276
● 设计模式是建筑设计领域引入到计算机科学中来的；● 设计模式是对面向对象设计中反复出现的问题的解决方案；● 算法不是设计模式，因为算法致力于解决问题而非设计问题；● 设计模式通常描述了一组相互紧密作用的类与对象；● 设计模式使代码更稳定，更安全，拓展性更强，同时也方便代码重构。● 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象；● 共同的接口：我们自己创建共同接口API，从工厂里面获得需要的对象放入main函数中去运行。
C语言开发中的“设计模式”
yimuta9538的博客
06-08 1360
在 C 语言开发中，虽然没有像面向对象编程语言那样的设计模式，但是可以借鉴一些通用的设计原则和思想。
【知识分享】C语言中的设计模式——开篇
知识噬元兽的博客
07-31 3831
从一个普通的码农成为架构师的第一步，就是要从代码搬运转化为有自己一套设计方法。架构设计的基石，就是要拥有一套可信手拈来的设计模式。
C语言实现设计模式之行为模式：策略模式
和风化雨
08-14 522
行为模式主要用于解决if--else过多的问题 命令模式一般用于输出仅与本次输入输入有关，与以前的输入无关。 一种输入根据处理方法的可以有多种输出。 处理的方法可以自由调整。 举例：针对不同人的打折销售 #ifndef REQUEST_H #define REQUEST_H typedef struct{ ... }Request; typedef enum{HANDLE1=0,...,HANDLEN}HandlerType; void handleRequest(Request *r, Han
C语言和设计模式（总结篇）
gooogleman#foxmail.com
10-16 807
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 设计模式的书相信很多人都看过。对于设计模式这样一种方法，相信不同的人有不同的理解。我在这里写的博客只是我个人对设计模式的粗浅认识。文中肯定存在很多的不足和不成熟之处，希望朋友们谅解。望大家多多指正，谢谢！ 01）C语言和设计模式（继承、封装、多态） 02）C语言和设计模式（访问者...
STC89C52单片机开发板设计.doc
02-27
在单芯片上，拥有灵巧的8 位CPU 和在系统可编程Flash，使得STC89C52为众多嵌入式控制应用系统提供高灵活、超有效的 解决方案。 具有以下标准功能： 8k字节Flash，512字节RAM， 32 位I/O 口线，看门狗定时器，内置4KB...
基于stc89c52的智能交通灯C程序+开题报告+仿真图+原理图+论文+制作详解+操作说明.rar
10-13
1、用单片机STC89C52设计一个交通灯系统，并用数码管显示时间，LED指示通行。 2、用74HC245来驱动4个数码管，使数码管在白天显得更亮些。 3、按键功能：黄灯常亮（深夜模式）、禁行、东西通行、南北通行、时间加、...
基于51单片机太阳能风能风光互补路灯控制器设计
04-05
本设计由STC89C52单片机电路+太阳能电池板电路+风机发电电路+锂电池充电保护电路+升压电路+稳压电路+光敏电阻电路+4位高亮LED灯电路+2档拨动开关电路+电源电路设计而成。 功能： 1、采用风机和太阳能电池板给锂电池...
基于51单片机的智能婴儿床设计（毕业设计）
04-06
基于51单片机的智能婴儿床设计（毕业设计） 1. 液晶显示当前信息和状态 2. 声音传感器检测婴儿哭闹 3. 湿度传感器检测婴儿是否尿床 4. 如果检测尿床，led指示灯亮，进行语音播报 请注意：宝贝需要更换尿不湿 ...
基于单片机的自动窗帘设计
02-18
针对传统窗帘无法满足现代化智能化的需求，以STC89C52单片机为核心设计了自动窗帘控制系统。该系统能实时准确采集光照强度和当前时间，具有三种工作模式，可通过光照强度来控制窗帘开闭，也能定时开关窗帘，还能利用...
linux驱动-CCF-1 provider 注册时钟
2401_83458819的博客
04-24 427
struct clk_hw_onecell_data onecell 填充到struct of_clk_provider *cp 中的data。struct clk_hw 组成 struct clk_hw_onecell_data onecell。b. 调用 of_clk_add_hw_provider 根据 进一步生成of_clk_provider ，并添加到全局列表。void *data;//对应 clk_hw_onecell_data（包含clk provider 注册的所有数组）
【软考】设计模式之策略模式
王佑辉的博客
04-27 740
并且这些行为在这个类的操作中以。
03-JAVA设计模式-策略模式
丨Anna丨的博客
04-25 1441
策略模式（Strategy Pattern）是行为设计模式之一，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的上下文对象。策略对象更改上下文对象的执行算法。策略模式对应于解决某一个问题的算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法，并且有客户端决定调用那个算法。
对策略模式的理解
南七行者的博客
04-26 952
接下来的 N 行，每行输入两个整数，第一个整数M( 0 < M < 400) 表示商品的价格, 第二个整数表示优惠策略，1表示九折优惠策略，2表示满减优惠策略。小明家的超市推出了不同的购物优惠策略，你可以根据自己的需求选择不同的优惠方式。请你设计一个购物优惠系统，用户输入商品的原价和选择的优惠策略编号，系统输出计算后的价格。输入的第一行是一个整数 N（1 ≤ N ≤ 20），表示需要计算优惠的次数。每行输出一个数字，表示优惠后商品的价格。个人觉得这种方式更灵活。
Spring中实现策略模式的几种方式
最新发布
qq_45136592的博客
04-29 300
在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代码比较臃肿，所以这个时候就需要抽象化，将每个场景独立开来，定义一个顶层接口，不同场景有不同实现，这个时候策略模式就出现了。本文主要阐述工作中常用的实现策略模式的几种方式。 2.2 定义枚举 2.3 定义实现类 2.4 定义策略工厂类 2.5 测试 实现一主要是为IHandler接口新增一个用于区分使用何种策略的方法，再构建一个策略工厂类，利用构
设计模式- 策略模式（Strategy Pattern）结构|原理|优缺点|场景|示例
piaomiao_的博客
04-24 579
设计模式中的策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装在一个单独的类中，使得它们可以互相替换。策略模式使得算法可以在运行时根据需要动态地改变，同时客户端代码可以通过统一的接口调用不同的策略实现。
stc89c52库pcbliv
12-28
stc89c52库pcbliv是一款基于STC89C52单片机的嵌入式开发板。它采用了STC89C52芯片作为核心处理器，具有丰富的外设接口和功能模块，可以用于各种嵌入式系统的开发和实验。这款开发板具有强大的性能和稳定的工作特性，能够支持多种编程语言和开发环境，如C语言、Assembly语言、Keil、IAR等。 stc89c52库pcbliv在设计上充分考虑了用户的使用需求，提供了丰富的外设接口，包括LED灯、数码管、按键、串口通信等，方便用户进行各种实验和应用的开发。同时，它还支持多种通信接口，如IIC、SPI等，可以方便地与外部模块进行通信和数据交换。 该开发板结构紧凑、外形美观，具有良好的可靠性和稳定性，广泛应用于学术研究、电子设计、嵌入式系统开发等领域。除此之外，stc89c52库pcbliv还提供了丰富的示例程序和教学资料，方便用户快速上手和学习，是一款性价比较高的嵌入式开发平台。 总之，stc89c52库pcbliv是一款功能丰富、易用性强的嵌入式开发板，适用于各种嵌入式系统的学习和开发。它的推出将为用户提供更加便捷、高效的开发环境，有望在嵌入式领域发挥重要作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zp1990412

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值