我用C语言玩对象，状态应用2-MP3

最新推荐文章于 2023-06-17 16:37:34 发布
最新推荐文章于 2023-06-17 16:37:34 发布
阅读量255 收藏 1
点赞数 1
分类专栏： 我用C语言玩对象 文章标签： 面向对象编程 c语言 设计模式 状态机 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rt201314/article/details/116130220
版权

概述

状态模式允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

之前的文章已经详细阐述了这种设计模式的核心和注意事项，并完成了基类设计，请参见《C语言 - 状态模式（基类部分）》，本文将结合实际案例论证这种设计模式，加深读者对状态模式的理解和应用。

示例

★背景说明：音乐播放器包含四种状态，播放态、暂停态、快进态、停止态，而四种状态根据外界按键是否按下决定，按键包含三种（play stop speed），当按下按键，对应的状态将会自行改变。 

★环境对象(music)：

属性：无

行为：按下播放键、按下快进键、按下停止键、获取各按键状态、处理函数。

继承：继承环境类Context基类

★状态对象(播放态、暂停态、快进态、停止态，每种状态单例设计):

属性：无

行为：无。

继承：继承状态类State基类

★包含头文件music.h和源文件music.c（均已验证通过）

 music.h

/**
 * @Filename : music.h
 * @Revision : $Revision: 1.0 $
 * @Author : Feng(微信公众号：不只会拍照的程序猿)
 * @Description : 状态模式应用(C语言模拟C++)
 * @Explain : 音乐播放包含四种状态：
              播放态 非播放态下play=1            play     单例模式
              快进态 播放态下speed=1             speed   单例模式
              停止态 播放态和快进态下play=1   stop     单例模式
              暂停态 播放态和快进态下pause=1  pause   单例模式
**/

#ifndef __music_H__
#define __music_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "state.h"

/* 按键定义 */ 
struct t_button {
    int play;       /* 播放键 */
    int speed;      /* 快进键 */
    int stop;       /* 停止键 */
};

/* 音乐播放器类定义 */
struct music {
    struct context context; /* 继承当前状态基类 */  

    void (*play)(struct music *p_music);                /* 按下播放键 */
    void (*speed)(struct music *p_music);               /* 按下快进键 */
    void (*stop)(struct music *p_music);                /* 按下停止键 */

    struct t_button * (*get)(struct music *p_music);    /* 获取各按键状态 */
    void (*handle)(struct music *p_music);              /* 处理函数 */  
};

/**
 * @创建music对象 
 * @成功返回类对象，失败返回NULL
**/
struct music *new_music(void);

/* 播放状态类定义 */
struct play {
    struct state state;
};

/* 快进状态类定义 */
struct speed {
    struct state state;
};

/* 停止状态类定义 */
struct stop {
    struct state state;
};

/* 暂停状态类定义 */
struct pause {
    struct state state;
};

/**
 * @创建播放对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct play *new_play(char *name);

/**
 * @创建快进状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct speed *new_speed(char *name);

/**
 * @创建停止状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct stop *new_stop(char *name);

/**
 * @创建暂停状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct pause *new_pause(char *name);

#endif

 music.c

/**
 * @Filename : music.c
 * @Revision : $Revision: 1.0 $
 * @Author : Feng(微信公众号：不只会拍照的程序猿)
 * @Description : 状态模式应用(C语言模拟C++)
 * @Explain : 音乐播放包含四种状态：
              播放态 非播放态下play=1            play     单例模式
              快进态 播放态下speed=1             speed   单例模式
              停止态 播放态和快进态下play=1   stop     单例模式
              暂停态 播放态和快进态下pause=1  pause   单例模式
**/
#include "music.h"

/**
 * @获取按键地址
 * @p_music:music类
 * @返回按键地址
**/
static struct t_button *_get(struct music *p_music)
{
    struct context *p_context = (struct context *)p_music;  
    return ((struct t_button *)CLASS_CALL_0(p_context, get_info));
}

/**
 * @清零信息
 * @p_music:music类
**/
static struct t_button *_clear_info(struct music *p_music)
{
    struct t_button *p_tmp = (struct t_button *)CLASS_CALL_0(p_music, get);

    if (p_tmp == NULL)
        p_tmp = (struct t_button *)malloc(sizeof(struct t_button));

    memset(p_tmp, 0, sizeof(struct t_button));
} 

/**
 * @按下播放键
 * @p_music:music类
**/
static void _play(struct music *p_music)
{
    struct context *p_context = (struct context *)p_music;
    struct t_button *p_tmp = _clear_info(p_music);

    p_tmp->play = 1;       
    CLASS_CALL(p_context, set_info, (void *)p_tmp);
} 

/**
 * @按下快进键
 * @p_music:music类
**/
static void _speed(struct music *p_music)
{
    struct context *p_context = (struct context *)p_music;
    struct t_button *p_tmp = _clear_info(p_music);

    p_tmp->speed = 1;    
    CLASS_CALL(p_context, set_info, (void *)p_tmp);
} 

/**
 * @按下停止键
 * @p_music:music类
**/
static void _stop(struct music *p_music)
{
    struct context *p_context = (struct context *)p_music;
    struct t_button *p_tmp = _clear_info(p_music);

    p_tmp->stop = 1;    
    CLASS_CALL(p_context, set_info, (void *)p_tmp);
}

/**
 * @处理函数
 * @p_music:music类
**/       
static void _handle(struct music *p_music)
{
    struct state *p_state = p_music->context.get(&(p_music->context));

    if (CLASS_CALL(p_music->context.p_dll, find_key, p_state) != NULL)
        CLASS_CALL(p_state, handle, (struct context *)p_music);
} 

/**
 * @创建music对象 
 * @成功返回类对象，失败返回NULL
**/
struct music *new_music(void)
{
    struct context *p_context;
    struct music *p_music;

    p_music = (struct music *)malloc(sizeof(struct music));

    if (p_music == NULL)
        return NULL;

    memset((char *)p_music, 0, sizeof(struct music));

    if ((p_context = new_context()) == NULL) {
        free(p_music);
        return NULL;
    }
    memcpy(&(p_music->context), p_context, sizeof(struct context));
    free(p_context);

    p_music->get = _get;
    p_music->play = _play;
    p_music->speed = _speed;
    p_music->stop = _stop;    
    p_music->handle = _handle;

    return p_music;
}

/**
 * @播放状态匹配判断
 * @p_state:状态      p_context:当前状态类      
 * @匹配返回0，否则返回-1 
**/
static int _play_match(struct state *p_state, struct context *p_context)
{
    struct state *p_cstate = CLASS_CALL_0(p_context, get);
    struct t_button *p_button = (struct t_button *)(p_context->p_info);

    if (((!strcmp(p_cstate->name, "stop")) || (!strcmp(p_cstate->name, "pause"))
    || (!strcmp(p_cstate->name, "speed"))) && (p_button->play))
        return 0;

    return (-1);
} 

/**
 * @暂停状态匹配判断
 * @p_state:状态      p_context:当前状态类      
 * @匹配返回0，否则返回-1 
**/
static int _pause_match(struct state *p_state, struct context *p_context)
{
    struct state *p_cstate = CLASS_CALL_0(p_context, get);
    struct t_button *p_button = (struct t_button *)(p_context->p_info);

    if (((!strcmp(p_cstate->name, "play"))
    || (!strcmp(p_cstate->name, "speed"))) && (p_button->play))
        return 0;

    return (-1);
} 

/**
 * @停止状态匹配判断
 * @p_state:状态      p_context:当前状态类      
 * @匹配返回0，否则返回-1 
**/
static int _stop_match(struct state *p_state, struct context *p_context)
{
    struct state *p_cstate = CLASS_CALL_0(p_context, get);
    struct t_button *p_button = (struct t_button *)(p_context->p_info);

    if (((!strcmp(p_cstate->name, "play"))
    || (!strcmp(p_cstate->name, "speed"))) && (p_button->stop))
        return 0;

    return (-1);
}

/**
 * @快进状态匹配判断
 * @p_state:状态      p_context:当前状态类      
 * @匹配返回0，否则返回-1 
**/
static int _speed_match(struct state *p_state, struct context *p_context)
{
    struct state *p_cstate = CLASS_CALL_0(p_context, get);
    struct t_button *p_button = (struct t_button *)(p_context->p_info);

    if ((!strcmp(p_cstate->name, "play")) && (p_button->speed))
        return 0;

    return (-1);
}

/**
 * @不同状态下的执行函数，实际应用中可分开写
 * @p_state:状态      p_context:当前状态类      
**/
static void _state_handle(struct state *p_state, struct context *p_context)
{
    printf("my state is %s\n", p_state->name);
}

/**
 * @获取状态名
 * @p_state:状态   
 * @返回当前状态名
**/
static char *_get_name(struct state *p_state)
{
    return (p_state->name);
} 

/**
 * @创建播放对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct play *new_play(char *name)
{
    struct state *p_state;
    static struct play *p_play = NULL;

    if (p_play != NULL)
        return p_play;

    p_play = (struct play *)malloc(sizeof(struct play));

    if (p_play == NULL)
        return NULL;

    memset((char *)p_play, 0, sizeof(struct play));

    if ((p_state = (struct state *)malloc(sizeof(struct state))) == NULL) {
        free(p_play);
        return NULL;
    }
    strcpy(p_state->name, name);
    p_state->get_name = _get_name;
    p_state->match = _play_match;
    p_state->handle = _state_handle;
    memcpy(&(p_play->state), p_state, sizeof(struct state));
    free(p_state);

    return p_play;
}

/**
 * @创建快进状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct speed *new_speed(char *name)
{
    struct state *p_state;
    static struct speed *p_speed = NULL;

    if (p_speed != NULL)
        return p_speed;

    p_speed = (struct speed *)malloc(sizeof(struct speed));

    if (p_speed == NULL)
        return NULL;

    memset((char *)p_speed, 0, sizeof(struct speed));

    if ((p_state = (struct state *)malloc(sizeof(struct state))) == NULL) {
        free(p_speed);
        return NULL;
    }
    strcpy(p_state->name, name);
    p_state->get_name = _get_name;
    p_state->match = _speed_match;
    p_state->handle = _state_handle;
    memcpy(&(p_speed->state), p_state, sizeof(struct state));
    free(p_state);

    return p_speed;
}

/**
 * @创建停止状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct stop *new_stop(char *name)
{
    struct state *p_state;
    static struct stop *p_stop = NULL;

    if (p_stop != NULL)
        return p_stop;

    p_stop = (struct stop *)malloc(sizeof(struct stop));

    if (p_stop == NULL)
        return NULL;

    memset((char *)p_stop, 0, sizeof(struct stop));

    if ((p_state = (struct state *)malloc(sizeof(struct state))) == NULL) {
        free(p_stop);
        return NULL;
    }
    strcpy(p_state->name, name);
    p_state->get_name = _get_name;
    p_state->match = _stop_match;
    p_state->handle = _state_handle;
    memcpy(&(p_stop->state), p_state, sizeof(struct state));
    free(p_state);

    return p_stop;
}

/**
 * @创建暂停状态对象
 * @name:类名
 * @成功返回类对象，失败返回NULL
**/
struct pause *new_pause(char *name)
{
    struct state *p_state;
    static struct pause *p_pause = NULL;

    if (p_pause != NULL)
        return p_pause;

    p_pause = (struct pause *)malloc(sizeof(struct pause));

    if (p_pause == NULL)
        return NULL;

    memset((char *)p_pause, 0, sizeof(struct pause));

    if ((p_state = (struct state *)malloc(sizeof(struct state))) == NULL) {
        free(p_pause);
        return NULL;
    }
    strcpy(p_state->name, name);
    p_state->get_name = _get_name;
    p_state->match = _pause_match;
    p_state->handle = _state_handle;
    memcpy(&(p_pause->state), p_state, sizeof(struct state));
    free(p_state);

    return p_pause;
}

/**
 * @主函数，演示代码 
**/
int main(void)
{ 
    struct music *p_music = new_music();
    struct play *p_play = new_play("play");
    struct pause *p_pause = new_pause("pause");
    struct speed *p_speed = new_speed("speed");
    struct stop *p_stop = new_stop("stop");

    p_music->context.add((struct context *)p_music, (struct state *)p_play);
    p_music->context.add((struct context *)p_music, (struct state *)p_speed);
    p_music->context.add((struct context *)p_music, (struct state *)p_pause);
    p_music->context.add((struct context *)p_music, (struct state *)p_stop);

    /* 初始为播放状态 */
    p_music->context.change((struct context *)p_music, (struct state *)p_play);
    CLASS_CALL_0(p_music, play);    /* 按下播放键，暂停 */
    printf("---------------------------------------\n");
    CLASS_CALL_0(p_music, stop);    /* 按下停止键，无效 */
    printf("---------------------------------------\n");
    CLASS_CALL_0(p_music, play);    /* 按下播放键，播放 */
    printf("---------------------------------------\n");
    CLASS_CALL_0(p_music, stop);    /* 按下停止键，停止 */
    printf("---------------------------------------\n");
    CLASS_CALL_0(p_music, play);    /* 按下播放键，播放 */
    printf("---------------------------------------\n");
    CLASS_CALL_0(p_music, speed);   /* 按下快进键，快进 */
    return 0;
}

结论

输入示例代码运行，结果如下：

feng:state$ gcc -o music music.c state.c class_dll.c dll.c
feng:state$ ./music
init state : play
state: play change to state : pause
---------------------------------------
---------------------------------------
state: pause change to state : play
---------------------------------------
state: play change to state : stop
---------------------------------------
state: stop change to state : play
---------------------------------------
state: play change to state : speed
feng:state$ 

分析：示例定义了music（MP3播放器）对象作为环境类，同时定义了play（播放）、pause（暂停）、stop（停止）和speed（快进）四种状态对象，状态之间通过用户按下按键进行响应的转换。

关注

更多精彩内容，请关注微信公众号：不只会拍照的程序猿，本人致力分享linux、设计模式、C语言、嵌入式、编程相关知识，也会抽空分享些摄影相关内容，同样也分享大量摄影、编程相关视频和源码，另外你若想要本文章源码请关注公众号：不只会拍照的程序猿，后台回复：设计模式源码，也可点击此处下载。

不只会拍照的程序猿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式之状态
Zllvincent的博客
07-17 203
一.简介 程序设计中有些对象是有状态的对象。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。 传统的处理方法是采用if-else 语句判断处理多种状态，状态模式的思想是：把“判断逻辑”提取出来，放到一系列的状态类当中，状态对象在其内部状态发生改变时改变其行为。 模式结构： 1.环境（Context）角色：它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。 2.抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态
linux task_struct结构总结
HanWnz的博客
07-17 559
task_struct描述符描述了进程的所有信息,所以task_struct非常复杂, 该数据结构定义在linux/sched.h头文件. task_struct数据结构中第一个字段是state, 它描述了当前进程的状态. TASK_RUNNING(准备执行或者正在cpu执行) TASK_INTERRUPTIBLE(可中断的睡眠(即可以通过中断来唤醒进程, 包括软中断)) TASK_UNI...
state修饰符只适用于struct
weixin_45982458的博客
12-29 773
使用state修饰符修饰一个结构体，修改结构体的属性时，view会进行刷新，而class不会 定义一个结构体User struct User { var firstname = "Bilbo" var lastname = "Baggins" } 创建一个视图 struct ContentView: View { @State private var user = User() var body: some View { VStack{ ...
c语言设计模式,C语言实现状态设计模式
weixin_35824356的博客
05-19 137
#include #include #include #ifndef VIRTUAL#define VIRTUAL#endif#ifndef DELETE#define DELETE(X)do { free(X);X = NULL; } while(0)#endif#define NEW(TYPE,pInstance,SUBTYPE)struct TYPE* pInstance = NULL;\s...
github经典C++状态机(fsm)源代码剖析
u011208918的专栏
10-09 1万+
在 github上有一个经典的状态机r-lyehv1.0.0，该状态机使用C++开发（支持C++11），单头文件，轻量级，跨平台，支持lambda表达式，使用非常方便，大大地简化了代码，使业务逻辑更清晰，是一个不错的fsm库，值得推荐。下载链接：下载 下面对源该经典状态源代码以及示例以中文注释的方式进行剖析，以及大家更好地了解其原理及使用。 //每个状态机都有'init', 'quit', 'push', 'back'四个成员成员函数 //init:在创建某一状态时调用 ；quit在某一状态结束时..
c语言状态机资料-unlocked_面向对象分析_行为继承_状态机_
10-03
在C语言中，状态通常用枚举类型表示，而状态之间的转换则通过函数或switch语句来实现。 面向对象分析（Object-Oriented Analysis，OOA）是设计状态机的一种有力工具。在OOA中，状态机可以被建模为一个类，每个状态...
C语言+ECS游戏框架Class4-1
04-22
在本项目"C语言+ECS游戏框架Class4-1"中，我们主要探讨的是如何使用C语言来构建一个基于实体组件系统（Entity Component System，简称ECS）的游戏框架。ECS是一种设计模式，常用于游戏开发，它提倡将游戏对象拆分为...
C语言+ECS游戏框架Class6-1
06-10
Ubuntu下编译验证意味着开发者在Linux环境下完成了项目的构建和测试，这通常涉及到使用GCC编译器，用makefile来管理和编译源代码，以及可能的依赖库管理，如GLib或SDL等，用于图形渲染和输入处理。 在这个项目中，...
C语言多功能按键驱动XxxSwitchScan-Driver
01-23
XxxSwitchScan_Driver可以简单的看作为一个C语言的按键驱动，使用简单、灵活且解耦，以面向对象思想结合状态机编写，同时适用于裸机与操作系统。最终实现响应事件有：短按/短按抬起/长按/持续长按/长按抬起/连击/...
蓝桥杯c语言嵌入式练习题之LED-Delay+题解.zip
最新发布
04-10
"c语言" 标签指明了所涉及的技术语言，是C语言，一种广泛应用的编程语言，尤其在系统级和嵌入式开发中。 "嵌入式" 标签则意味着这些练习题和解答是关于嵌入式系统的，这类系统通常运行在微控制器或其他资源有限的...
我用C语言玩对象，状态模式应用1-水的三态
不只会拍照的程序猿
04-14 2470
概述状态模式允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。之前的文章已经详细阐述了这种设计模式的核心和注意事项，并完成了基类设计，请参见《C语言 -状态模式（基...
linux进程task_struct结构体中的state域
a418382926的专栏
04-01 1996
谈到task_struct结构体，可以说她是linux内核源码中最复杂的一个结构体了，成员之多，占用内存之大。 鉴于她的复杂，我们不能简单的亵渎，而是要深入“窥探”. 下面先介绍这些复杂成员中的一员，state域 struct task_struct {     volatile long state;    /* -1 unrunnable, 0 runnable, >0
struct stat结构体的详解和用法
weixin_34310785的博客
09-11 1613
_stat函数用来获取指定路径的文件或者文件夹的信息。//! 需要包含de头文件 #include &lt;sys/types.h&gt; #include &lt;sys/stat.h&gt; int stat(　　const char *filename //文件或者文件夹的路径　　, struct stat *buf //获取的信息保存在内存中);...
获取文件大小的几种方式
fengruoying93的专栏
07-29 2061
转自：https://blog.csdn.net/Nick_666/article/details/78345106 1、通过文件C标准IO库函数fseek、fell获得，间接获得，速度慢 #include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) { FILE* fp; ...
C++--struct的用法
热门推荐
一朶婲
09-10 1万+
1.struct的自然对界 　struct是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如array、struct、union等）的数据单元。对于结构体，编译器会自动进行成员变量的对齐，以提高运算效率。缺省情况下，编译器为结构体的每个成员按其自然对界（natural alignment）条件分配空间。各个成员按照它们被声明
自制头文件 music.h
一个平庸的人
06-17 102
这是一个音乐头文件，beep是一个发音函数，hz_m是各种音。
状态机-面向对象编程
Paper_Love的博客
01-14 273
状态机-面向对象编程 #include "stdio.h" //状态 typedef struct State { const struct State *(* const state_press)(const struct State *pThis); const struct State *(* const state_release)(const struct State *pThis); } State; //事件--改变状态 void initialize(void); voi
CONTEXT（线程结构体）
05-15 1093
typedef struct _CONTEXT { DWORD ContextFlags // -| +00h DWORD Dr0 // | +04h DWORD Dr1 // ...
单片机 c语言 面向对象 源码
12-07
C语言以其简洁、高效和跨平台性而受到广泛的应用。 面向对象是一种编程范式，其核心思想是将程序的结构组织成对象的集合，这些对象通过相互之间的交互来完成任务。面向对象的编程语言有C++、Java等。对于单片机这样...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不只会拍照的程序猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值