C语言和设计模式(解释器模式)

【 声明:版权所有,欢迎转载,请勿用于商业用途。  联系信箱:feixiaoxing @163.com】

    

    解释器模式虽然听上去有些费解,但是如果用示例说明一下就不难理解了。我们知道在C语言中,关于变量的定义是这样的:一个不以数字开始的由字母、数字和下划线构成的字符串。这种形式的表达式可以用状态自动机解决,当然也可以用解释器的方式解决。

typedef struct _Interpret
{
    int type;
    void* (*process)(void* pData, int* type, int* result);

}Interpret;
    上面的数据结构比较简单,但是很能说明问题。就拿变量来说吧,这里就可以定义成字母的解释器、数字解释器、下划线解释器三种形式。所以,我们可以进一步定义一下process的相关函数。

#define DIGITAL_TYPE 1
#define LETTER_TYPE  2
#define BOTTOM_LINE  3

void* digital_process(void* pData, int* type, int* result)
{
    UINT8* str;
    assert(NULL != pData && NULL != type && NULL != result);

    str = (UNT8*)pData;
    while (*str >= '0' && *str <= '9')
    {
        str ++;
    } 

    if(*str == '\0')
    {
        *result = TRUE;
        return NULL;
    }   

    if(*str == '_')
    {
        *result = TRUE;
        *type = BOTTOM_TYPE;
        return str;
    }

    if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
    {
        *result = TRUE;
        *type = LETTER_TYPE;
        return str;
    }

    *result = FALSE;
    return NULL;            
}    

void* letter_process(void* pData, int* type, int* result)
{
    UINT8* str;
    assert(NULL != pData && NULL != type && NULL != result);

    str = (UNT8*)pData;
    while (*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
    {
        str ++;
    } 

    if(*str == '\0')
    {
        *result = TRUE;
        return NULL;
    }   

    if(*str == '_')
    {
        *result = TRUE;
        *type = BOTTOM_TYPE;
        return str;
    }

    if(*str >= '0' && *str <= '9')
    {
        *result = TRUE;
        *type = DIGITAL_TYPE;
        return str;
    }

    *result = FALSE;
    return NULL;            
}          

void* bottom_process(void* pData, int* type, int* result)
{
    UINT8* str;
    assert(NULL != pData && NULL != type && NULL != result);

    str = (UNT8*)pData;
    while ('_' == *str )
    {
        str ++;
    } 

    if(*str == '\0')
    {
        *result = TRUE;
        return NULL;
    }   

    if(*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z')
    {
        *result = TRUE;
        *type = LETTER_TYPE;
        return str;
    }

    if(*str >= '0' && *str <= '9')
    {
        *result = TRUE;
        *type = DIGITAL_TYPE;
        return str;
    }

    *result = FALSE;
    return NULL;            
} 

  • 2
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
《嵌入式系统设计实战:基于飞思卡尔S12X微控制器》以飞思卡尔半导体公司(原摩托罗拉半导体部)16位S12X系列微控制器中MC9S12XS128为蓝本阐述嵌入式系统的软件与硬件设计。全书共11章,其中第1章阐述嵌入式系统的知识体系、学习误区与学习建议。第2章给出XS128硬件最小系统,并简要介绍S12XCPU(CPU12X)。第3章给出第一个样例程序及CodeWai·“or工程组织,完成第一个S12X工程的入门。第4章给出基于硬件构件的嵌入式系统开发方法。第5章阐述串行通信接口SCI,并给出第一个带中断的实例。1~5章介绍了学习一个新MCU完整要素(知识点)的入门。6~12章分别介绍GPIO的应用(键盘、LED及LCD)、定时器(含PWM)、串行外设接口SPI、Flash存储器在线编程、CAN总线、A/D转换及S12XS128其他模块等。附录给出相关资料。《嵌入式系统设计实战:基于飞思卡尔S12X微控制器》涉及的实例源程序、辅助资料、相关芯片资料及常用软件工具,可在北航出版社下载中心或苏州大学飞思卡尔嵌入式系统研发中心网站下载。《嵌入式系统设计实战:基于飞思卡尔S12X微控制器》可供大学有关专业的高年级学生和研究生用作教材或参考读物,也可供嵌入式系统开发与研究人员用作参考和进修资料。 第1章 概述 1 1.1 嵌入式系统定义、由来及特点 1 1.1.1 嵌入式系统的定义 1 1.1.2 嵌入式系统的由来及其与微控制器的关系 2 1.1.3 嵌入式系统的特点 3 1.2 嵌入式系统的知识体系、学习误区及学习建议 4 1.2.1 嵌入式系统的知识体系 4 1.2.2 嵌入式系统的学习误区 5 1.2.3 基础阶段的学习建议 8 1.3 嵌入式系统常用术语 10 1.3.1 与硬件相关的术语 10 1.3.2 与通信相关的术语 11 1.3.3 与功能模块及软件相关的术语 12 1.4 嵌入式系统常用的C语言基本语法 13 第2章 S12X系列MCU硬件最小系统及CPU12X 26 2.1 S12X系列MCU概述及型号标识 26 2.1.1 S12X系列MCU概述 26 2.1.2 S12X系列MCU型号标识 28 2.2 S12X系列MCU的功能及存储器映像 29 2.2.1 S12X系列MCU的功能 30 2.2.2 S12X系列MCU的存储器映像及特点 31 2.3 XS128的引脚功能及硬件最小系统 36 2.3.1 XS128(80引脚QFP封装)的引脚功能 37 2.3.2 XS128的硬件最小系统 40 2.3.3 硬件最小系统的焊接与测试步骤 43 2.4 CPU12X的内部寄存器 44 2.5 CPU12X的寻址方式 47 2.6 CPU12X指令系统概要 51 2.6.1 数据传送类指令 53 2.6.2 算术运算类指令 56 2.6.3 逻辑运算类与位操作类指令 60 2.6.4 程序控制类指令 63 2.6.5 其他类指令 71 2.7 CPU12X汇编语言基础 72 2.7.1 S12X汇编源程序格式 72 2.7.2 S12X汇编语言伪指令 74 第3章 第一个样例程序及CodeWarrior工程组织 77 3.1 通用I/O接口基本概念及连接方法一 77 3.2 XS128的GPIO寄存器与GPIO构件封装 79 3.2.1 XS128的GPIO寄存器 79 3.2.2 GPIO的简单编程方法 83 3.3 CodeWarrior开发环境与S08/S12/ColdFire三合一写入器 84 3.3.1 CodeWarrior开发环境简介与基本使用方法 85 3.3.2 S08/S12/ColdFire三合一写入器 86 3.3.3 MC9S12XS128硬件评估板 87 3.4 CW环境C语言工程文件的组织 87 3.4.1 工程文件的逻辑组织结构 88 3.4.2 工程文件的物理组织结构 90 3.4.3 系统启动及初始化相关文件 91 3.4.4 芯片初始化、主程序、中断程序及其他文件 98 3.4.5 机器码文件(s19文件)的简明解释 101 3.4.6 lst文件与map文件 103 3.4.7 如何在CW环境下新建一个S12工程 105 3.5 第一个C语言工程:控制小灯闪烁 105 3.5.1 GPIO构件设计 106 3.5.2 Light构件设计 113 3.5.3 Light测试工程主程序 115 3.5.4 理解第一个C工程的执行过程 116 3.6 第一个汇编语言工程:控制小灯闪烁 117 3.6.1 汇编工程文件的组织 118 3.6.2 Light构件汇编程序 122 3.6.3 Light测试工程主程序 124 3.6.4 理解第一个汇编工程的执行过程 126 第4章 基于硬件构件的嵌入式系统开发方法 129 4.1 嵌入式系统开发所遇到的若干问题 129 4.2 嵌入式硬件构件的基本思想与应用方法 130 4.3 基于硬件构件的嵌入式系统硬件电路设计 131 4.3.1 设计时需要考虑的基本问题 131 4.3.2 硬件构件化电路原理图绘制的简明规则 133 4.3.3 实验PCB板设计的简明规则 135 4.4 基于硬件构件的嵌入式底层软件构件的编程方法 139 4.4.1 嵌入式硬件构件和软件构件的层次模型 139 4.4.2 底层构件的实现方法与编程思想 140 4.4.3 硬件构件及底层软件构件的重用与移植方法 141 第5章 串行通信接口SCI 144 5.1 异步串行通信的通用基础知识 144 5.1.1 串行通信的基本概念 145 5.1.2 RS-232总线标准 146 5.1.3 TTL电平到RS-232电平转换电路 148 5.1.4 串行通信编程模型 149 5.2 SCI模块的编程寄存器 150 5.3 SCI编程实例 155 5.3.1 SCI初始化与收发编程的基本方法 156 5.3.2 SCI构件设计与测试实例 157 5.4 XS128的中断源与第一个带有中断的编程实例 166 5.4.1 中断与异常的通用知识 166 5.4.2 XS128的中断机制 166 5.4.3 XS128的中断编程方法 171 5.4.4 XS128的中断优先级编程实例 173 第6章 GPIO的应用实例:键盘、LED与LCD 175 6.1 键盘技术概述 175 6.1.1 键盘模型及接口 175 6.1.2 键盘编程的基本问题 177 6.1.3 键盘构件设计与测试实例 178 6.2 LED技术概述 184 6.2.1 扫描法LED显示编程原理 184 6.2.2 LED构件设计与测试实例 186 6.3 LCD技术概述 191 6.3.1 LCD的特点和分类 191 6.3.2 点阵字符型液晶显示模块 193 6.3.3 HD44780 193 6.3.4 LCD构件设计与测试实例 199 第7章 定时器相关模块 207 7.1 计数/定时器的基本工作原理 207 7.2 定时器模块的基本编程方法与实例 208 7.2.1 定时器模块计时功能的基本寄存器 210 7.2.2 定时器构件设计与测试实例 212 7.3 定时器模块输入捕捉功能的编程方法与实例 216 7.3.1 输入捕捉的基本含义 216 7.3.2 输入捕捉的寄存器 217 7.3.3 输入捕捉构件设计与测试实例 218 7.4 定时器模块输出比较功能的编程方法与实例 221 7.4.1 输出比较的基本知识 222 7.4.2 用于输出比较功能的相关寄存器 222 7.4.3 输出比较构件设计与测试实例 224 7.5 定时器模块脉冲累加功能的编程方法与实例 226 7.5.1 脉冲累加的基本知识 226 7.5.2 脉冲累加功能的相关寄存器 227 7.5.3 脉冲累加器构件设计 228 7.6 脉宽调制模块 231 7.6.1 PWM工作原理 231 7.6.2 XS128的PWM的特点及模块框图 232 7.6.3 脉宽调制模块PWM相关寄存器 233 7.6.4 PWM构件设计及测试实例 236 7.7 周期中断定时器模块PIT 243 7.7.1 PIT模块功能描述 243 7.7.2 PIT模块的编程寄存器 245 7.7.3 PIT构件设计与测试实例 248 第8章 A/D与SPI 252 8.1 A/D通用知识 252 8.1.1 A/D的基本问题 252 8.1.2 A/D转换器 253 8.1.3 A/D转换常用传感器简介 254 8.1.4 电阻型传感器采样电路设计 255 8.2 A/D模块的编程寄存器 257 8.3 A/D模块编程方法与实例 264 8.3.1 A/D模块基本编程方法 264 8.3.2 A/D构件设计与测试实例 265 8.4 SPI的基本工作原理 270 8.4.1 SPI基本概念 270 8.4.2 SPI的数据传输 272 8.4.3 SPI模块的时序 272 8.4.4 模拟SPI 276 8.5 SPI模块的编程寄存器 276 8.6 SPI构件设计与测试实例 282 第9章 Flash存储器在线编程 289 9.1 S12X系列MCU的Flash存储器的特点及分页机制 289 9.1.1 S12X系列MCU的Flash存储器的特点 290 9.1.2 XS128的Flash存储器分页机制 290 9.2 Flash存储器编程方法 295 9.2.1 Flash存储器编程的基本概念 295 9.2.2 Flash存储器的编程寄存器 296 9.2.3 FCCOB-NVM命令模式 300 9.2.4 Flash存储器的编程步骤 301 9.3 D-Flash在线编程 303 9.4 P-Flash在线编程 308 9.5 Flash存储器的保护特性和安全性 313 9.5.1 Flash存储器的配置区域 313 9.5.2 Flash存储器的保护特性 314 9.5.3 Flash存储器的安全性 317 第10章 CAN总线 321 10.1 CAN总线通用知识 321 10.1.1 CAN总线协议的历史概况 321 10.1.2 CAN硬件系统的典型电路 321 10.1.3 CAN总线的有关基本概念 324 10.1.4 帧结构 327 10.1.5 位时间 331 10.2 MSCAN模块简介 332 10.2.1 MSCAN特性 333 10.2.2 报文存储结构、标识符验收过滤与时钟系统 334 10.2.3 CAN模块的主要运行模式、低功耗选项、中断与响应 341 10.3 MSCAN模块的内存映射及寄存器定义 345 10.3.1 MSCAN模块内存映射 345 10.3.2 MSCAN模块寄存器 346 10.4 MSCAN模块双机通信测试实例 360 10.4.1 测试模型 360 10.4.2 编程要点 360 10.4.3 CAN模块底层构件设计 361 10.4.4 测试操作要点 374 10.5 MSCAN模块的自环通信实例 374 10.5.1 测试模型 374 10.5.2 编程要点及设计代码 374 第11章 系统时钟与其他功能模块 378 11.1 时钟与复位产生模块概述 378 11.1.1 锁相环技术 378 11.1.2 CRG模块框图 380 11.1.3 CRG模块的工作模式 381 11.1.4 XS128内部锁相环结构 383 11.2 XS128的CRG模块的初始化 384 11.2.1 XS128的CRG模块寄存器 384 11.2.2 初始化编程方法与实例 389 11.3 CRG模块的其他功能 392 11.3.1 CRG产生复位信号 392 11.3.2 中断 397 11.4 XS128的IRQ、XIRQ引脚、RTIBRK及SWI中断 398 11.4.1 IRQ与XIRQ引脚中断 398 11.4.2 实时中断 398 11.4.3 调试模块DBG与软件中断SWI指令 399 附录A XS128的映像寄存器 400 附录B S08/S12/ColdFireBDM简明使用方法 410 附录C 常见实践问题集锦 414 附录D XS128的C语言函数库 417 附录E XS128的中断源与中断向量表 421 参考文献 424
汇编语言是一种低级编程语言,它直接对应于计算机的机器语言,但使用了人类可读的助记符和符号来替代机器语言中的二进制指令和地址。以下是关于汇编语言的详细说明: ### 基本概念与特性 1. **机器相关性**: - **面向特定体系结构**:汇编语言是为特定计算机体系结构(如x86、ARM、MIPS等)设计的,每种体系结构都有其专属的汇编语言。这意味着汇编程序通常不能直接在不同类型的处理器上运行,不具备源代码级别的可移植性。 2. **指令与操作码**: - **助记符表示**:汇编语言使用助记符(mnemonics)来代表特定的机器指令,这些助记符往往与指令的功能相关,如`MOV`(移动数据)、`ADD`(加法)、`JMP`(跳转)等。每个助记符对应一个特定的二进制操作码。 3. **低级操作**: - **直接硬件控制**:汇编语言允许程序员直接操控硬件资源,如寄存器、内存地址、I/O端口等,这使得它非常适合编写对时间和空间效率要求极高、需要精确控制硬件的程序,如设备驱动、实时系统内核、性能关键算法等。 4. **代码效率**: - **紧凑的代码**:汇编程序生成的目标代码通常比高级语言编译后的代码更为紧凑,占用内存较少。 - **快速执行**:由于直接对应于机器指令,汇编程序在执行时无需经过复杂的解释或编译过程,能够快速、高效地被执行。 5. **编写与调试难度**: - **复杂性高**:编写汇编程序需要深入了解计算机体系结构和指令集细节,即使是简单的任务也可能需要大量的指令。此外,程序逻辑的表述不如高级语言直观,容易出错且难以阅读和维护。 - **调试挑战**:由于代码高度依赖具体的硬件状态,调试汇编程序可能非常困难,尤其是在处理复杂的控制流、数据依赖性和异常处理时。 6. **工具支持**: - **汇编器**:汇编语言源代码通过汇编器(assembler)转换成机器语言(机器码或二进制码),汇编器负责将助记符和符号地址解析为具体的机器指令和物理地址。 - **链接器**:生成的机器码通常需要链接器(linker)进行链接,将多个目标文件合并为一个可执行文件,同时解决外部符号引用。 ### 应用场景与优势 汇编语言主要应用于以下几个方面: - **系统级编程**:操作系统内核、设备驱动、中断服务程序等底层软件开发,这些领域要求对硬件有精细控制,且性能要求高。 - **性能优化**:在高级语言编写的程序中,对性能敏感的部分可以用汇编重写以提升效率。 - **反病毒与安全研究**:理解和编写汇编代码有助于分析恶意软件行为、逆向工程及编写防病毒软件。 - **教学与理解计算机原理**:学习汇编语言有助于深入理解计算机体系结构、指令集、内存管理和硬件接口等基础概念。 ### 编程特点与挑战 - **手动管理内存**:程序员需要手动分配和释放内存,跟踪数据在内存中的位置,处理堆栈、堆和静态内存区域。 - **无高级抽象**:缺乏高级语言中的类、对象、函数库等高级抽象概念,所有编程结构如循环、条件分支等都需要手工实现。 - **依赖特定硬件**:汇编程序直接依赖于特定处理器的指令集、寄存器组织和寻址模式,更换硬件平台通常意味着重新编写代码。 尽管汇编语言具有上述挑战,但它在特定场景下提供了无可比拟的优势,如极高的执行效率、对硬件资源的精确控制以及在安全和反病毒领域的应用。随着编译器技术的进步,许多高级语言也能生成高效的目标代码,但在某些对性能和硬件控制有严格要求的情况下,汇编语言仍然是不可或缺的工具。
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一.简单匹配算法 先来看一个简单匹配算法的函数: int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符 起存在和串 T 相同的子串,则称匹配成功,返回第一个 这样的子串在串 S 中的下标,否则返回 -1 */ int i = pos, j = 0; while ( S[i+j] != '\0'&& T[j] != '\0') if ( S[i+j] == T[j] ) j ++; // 继续比较后一字符 else { i ++; j = 0; // 重新开始新的一轮匹配 } if ( T[j] == '\0') return i; // 匹配成功 返回下标 else return -1; // 串S中(第pos个字符起)不存在和串T相同的子串 } // Index_BF 此算法的思想是直截了当的:将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较 S[i+j] 与 T[j],若相等,则在主串 S 中存在以 i 为起始位置匹配成功的可能性,继续往后比较( j逐步增1 ),直至与T串中最后一个字符相等为止,否则改从S串的下一个字符起重新开始进行下一轮的"匹配",即将串T向后滑动一位,即 i 增1,而 j 退回至0,重新开始新一轮的匹配。 例如:在串S=”abcabcabdabba”中查找T=” abcabd”(我们可以假设从下标0开始):先是比较S[0]和T[0]是否相等,然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图: 当这样一个失配发生时,T下标必须回溯到开始,S下标回溯的长度与T相同,然后S下标增1,然后再次比较。如图: 这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图: 这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图: 又一次发生了失配,所以T下标又回溯到开始,S下标增1,然后再次比较。这次T中的所有字符都和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图: 二. KMP匹配算法 还是相同的例子,在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值(next[5]=2,为什么?后面讲),直接比较S[5] 和T[2]是否相等,因为相等,S和T的下标同时增加;因为又相等,S和T的下标又同时增加。。。最终在S中找到了T。如图: KMP匹配算法和简单匹配算法效率比较,一个极端的例子是: 在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾,发现字符不同,然后T的下标回溯到开始,S的下标也要回溯相同长度后增1,继续比较。如果使用KMP匹配算法,就不必回溯. 对于一般文稿中串的匹配,简单匹配算法的时间复杂度可降为O (m+n),因此在多数的实际应用场合下被应用。 KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子。为什么T[5]==’d’的模式函数值等于2(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同,且T[5]==’d’不等于开始的两个字符之后的第三个字符(T[2]=’c’).如图: 也就是说,如果开始的两个字符之后的第三个字符也为’d’,那么,尽管T[5]==’d’的前面有2个字符和开始的两个字符相同,T[5]==’d’的模式函数值也不为2,而是为0。 前面我说:在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值,直接比较S[5] 和T[2]是否相等。。。为什么可以这样? 刚才我又说:“(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同”。请看图 :因为,S[4] ==T[4],S[3] ==T[3],根据next[5]=2,有T[3]==T[0],T[4] ==T[1],所以S[3]==T[0],S[4] ==T[1](两对相当于间接比较过了),因此,接下来比较S[5] 和T[2]是否相等。。。 有人可能会问:S[3]和T[0],S[4] 和T[1]是根据next[5]=2间接比较相等,那S[1]和T[0],S[2] 和T[0]之间又是怎么跳过,可以不比较呢?因为S[0]=T[0],S[1]=T[1],S[2]=T[2],而T[0] != T[1], T[1] != T[2],==> S[0] != S[1],S[1] != S[2],所以S[1] != T[0],S[2] != T[0]. 还是从理论上间接比较了。 有人疑问又来了,你分析的是不是特殊轻况啊。 假设S不变,在S中搜索T=“abaabd”呢?答:这种情况,当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=-1,意思是S[2]已经和T[0] 间接比较过了,不相等,接下来去比较S[3]和T[0]吧。 假设S不变,在S中搜索T=“abbabd”呢?答:这种情况当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=0,意思是S[2]已经和T[2]比较过了,不相等,接下来去比较S[2]和T[0]吧。 假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢?答:这种情况当比较到S[5]和T[5]时,发现不等,就去看next[5]的值,next[5]=2,意思是前面的比较过了,其中,S[5]的前面有两个字符和T的开始两个相等,接下来去比较S[5]和T[2]吧。 总之,有了串的next值,一切搞定。那么,怎么求串的模式函数值next[n]呢?(本文中next值、模式函数值、模式值是一个意思。) 三. 怎么求串的模式值next[n] 定义: (1)next[0]= -1 意义:任何串的第一个字符的模式值规定为-1。 (2)next[j]= -1 意义:模式串T中下标为j的字符,如果与首字符 相同,且j的前面的1—k个字符与开头的1—k 个字符不等(或者相等但T[k]==T[j])(1≤k<j)。 如:T=”abCabCad” 则 next[6]=-1,因T[3]=T[6] (3)next[j]=k 意义:模式串T中下标为j的字符,如果j的前面k个 字符与开头的k个字符相等,且T[j] != T[k] (1≤k<j)。 即T[0]T[1]T[2]。。。T[k-1]== T[j-k]T[j-k+1]T[j-k+2]…T[j-1] 且T[j] != T[k].(1≤k<j); (4) next[j]=0 意义:除(1)(2)(3)的其他情况。 举例: 01)求T=“abcac”的模式函数的值。 next[0]= -1 根据(1) next[1]=0 根据 (4) 因(3)有1<=k<j;不能说,j=1,T[j-1]==T[0] next[2]=0 根据 (4) 因(3)有1<=k<j;(T[0]=a)!=(T[1]=b) next[3]= -1 根据 (2) next[4]=1 根据 (3) T[0]=T[3] 且 T[1]=T[4] 即 下标 0 1 2 3 4 T a b c a c next -1 0 0 -1 1 若T=“abcab”将是这样: 下标 0 1 2 3 4 T a b c a b next -1 0 0 -1 0 为什么T[0]==T[3],还会有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j] != T[k]”被划入(4)。 02)来个复杂点的,求T=”ababcaabc” 的模式函数的值。 next[0]= -1 根据(1) next[1]=0 根据(4) next[2]=-1 根据 (2) next[3]=0 根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入(4) next[4]=2 根据 (3) T[0]T[1]=T[2]T[3] 且T[2] !=T[4] next[5]=-1 根据 (2) next[6]=1 根据 (3) T[0]=T[5] 且T[1]!=T[6] next[7]=0 根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入(4) next[8]=2 根据 (3) T[0]T[1]=T[6]T[7] 且T[2] !=T[8] 即 下标 0 1 2 3 4 5 6 7 8 T a b a b c a a b c next -1 0 -1 0 2 -1 1 0 2 只要理解了next[3]=0,而不是=1,next[6]=1,而不是= -1,next[8]=2,而不是= 0,其他的好象都容易理解。 03) 来个特殊的,求 T=”abCabCad” 的模式函数的值。 下标 0 1 2 3 4 5 6 7 T a b C a b C a d next -1 0 0 -1 0 0 -1 4 next[5]= 0 根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5] next[6]= -1 根据 (2) 虽前面有abC=abC,但T[3]==T[6] next[7]=4 根据 (3) 前面有abCa=abCa,且 T[4]!=T[7] 若T[4]==T[7],即T=” adCadCad”,那么将是这样:next[7]=0, 而不是= 4,因为T[4]==T[7]. 下标 0 1 2 3 4 5 6 7 T a d C a d C a d next -1 0 0 -1 0 0 -1 0 如果你觉得有点懂了,那么 练习:求T=”AAAAAAAAAAB” 的模式函数值,并用后面的求模式函数值函数验证。 意义: next 函数值究竟是什么含义,前面说过一些,这里总结。 设在字符串S中查找模式串T,若S[m]!=T[n],那么,取T[n]的模式函数值next[n], 1. next[n]= -1 表示S[m]和T[0]间接比较过了,不相等,下一次比较 S[m+1] 和T[0] 2. next[n]=0 表示比较过程中产生了不相等,下一次比较 S[m] 和T[0]。 3. next[n]= k >0 但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了,下一次比较S[m]和T[k]相等吗? 4. 其他值,不可能。 四. 求串T的模式值next[n]的函数 说了这么多,是不是觉得求串T的模式值next[n]很复杂呢?要叫我写个函数出来,目前来说,我宁愿去登天。好在有现成的函数,当初发明KMP算法,写出这个函数的先辈,令我佩服得六体投地。我等后生小子,理解起来,都要反复琢磨。下面是这个函数: void get_nextval(const char *T, int next[]) { // 求模式串T的next函数值并存入数组 next。 int j = 0, k = -1; next[0] = -1; while ( T[j/*+1*/] != '\0' ) { if (k == -1 || T[j] == T[k]) { ++j; ++k; if (T[j]!=T[k]) next[j] = k; else next[j] = next[k]; }// if else k = next[k]; }// while ////这里是我加的显示部分 // for(int i=0;i<j;i++) //{ // cout<<next[i]; //} //cout<<endl; }// get_nextval  另一种写法,也差不多。 void getNext(const char* pattern,int next[]) { next[0]= -1; int k=-1,j=0; while(pattern[j] != '\0') { if(k!= -1 && pattern[k]!= pattern[j] ) k=next[k]; ++j;++k; if(pattern[k]== pattern[j]) next[j]=next[k]; else next[j]=k; } ////这里是我加的显示部分 // for(int i=0;i<j;i++) //{ // cout<<next[i]; //} //cout<<endl; } 下面是KMP模式匹配程序,各位可以用他验证。记得加入上面的函数 #include <iostream.h> #include <string.h> int KMP(const char *Text,const char* Pattern) //const 表示函数内部不会改变这个参数的值。 { if( !Text||!Pattern|| Pattern[0]=='\0' || Text[0]=='\0' )// return -1;//空指针或空串,返回-1。 int len=0; const char * c=Pattern; while(*c++!='\0')//移动指针比移动下标快。 { ++len;//字符串长度。 } int *next=new int[len+1]; get_nextval(Pattern,next);//求Pattern的next函数值 int index=0,i=0,j=0; while(Text[i]!='\0' && Pattern[j]!='\0' ) { if(Text[i]== Pattern[j]) { ++i;// 继续比较后继字符 ++j; } else { index += j-next[j]; if(next[j]!=-1) j=next[j];// 模式串向右移动 else { j=0; ++i; } } }//while delete []next; if(Pattern[j]=='\0') return index;// 匹配成功 else return -1; } int main()//abCabCad { char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc"; char*pattern="adCadCad"; //getNext(pattern,n); //get_nextval(pattern,n); cout<<KMP(text,pattern)<<endl; return 0; } 五.其他表示模式值的方法 上面那种串的模式值表示方法是最优秀的表示方法,从串的模式值我们可以得到很多信息,以下称为第一种表示方法。第二种表示方法,虽然也定义next[0]= -1,但后面绝不会出现-1,除了next[0],其他模式值next[j]=k(0≤k<j)的意义可以简单看成是:下标为j的字符的前面最多k个字符与开始的k个字符相同,这里并不要求T[j] != T[k]。其实next[0]也可以定义为0(后面给出的求串的模式值的函数和串的模式匹配的函数,是next[0]=0的),这样,next[j]=k(0≤k<j)的意义都可以简单看成是:下标为j的字符的前面最多k个字符与开始的k个字符相同。第三种表示方法是第一种表示方法的变形,即按第一种方法得到的模式值,每个值分别加1,就得到第三种表示方法。第三种表示方法,我是从论坛上看到的,没看到详细解释,我估计是为那些这样的编程语言准备的:数组的下标从1开始而不是0。 下面给出几种方法的例子: 表一。 下标 0 1 2 3 4 5 6 7 8 T a b a b c a a b c (1) next -1 0 -1 0 2 -1 1 0 2 (2) next -1 0 0 1 2 0 1 1 2 (3) next 0 1 0 1 3 0 2 1 3 第三种表示方法,在我看来,意义不是那么明了,不再讨论。 表二。 下标 0 1 2 3 4 T a b c A c (1)next -1 0 0 -1 1 (2)next -1 0 0 0 1 表三。 下标 0 1 2 3 4 5 6 7 T a d C a d C a d (1)next -1 0 0 -1 0 0 -1 0 (2)next -1 0 0 0 1 2 3 4 对比串的模式值第一种表示方法和第二种表示方法,看表一: 第一种表示方法next[2]= -1,表示T[2]=T[0],且T[2-1] !=T[0] 第二种表示方法next[2]= 0,表示T[2-1] !=T[0],但并不管T[0] 和T[2]相不相等。 第一种表示方法next[3]= 0,表示虽然T[2]=T[0],但T[1] ==T[3] 第二种表示方法next[3]= 1,表示T[2] =T[0],他并不管T[1] 和T[3]相不相等。 第一种表示方法next[5]= -1,表示T[5]=T[0],且T[4] !=T[0],T[3]T[4] !=T[0]T[1],T[2]T[3]T[4] !=T[0]T[1]T[2] 第二种表示方法next[5]= 0,表示T[4] !=T[0],T[3]T[4] !=T[0]T[1] ,T[2]T[3]T[4] !=T[0]T[1]T[2],但并不管T[0] 和T[5]相不相等。换句话说:就算T[5]==’x’,或 T[5]==’y’,T[5]==’9’,也有next[5]= 0 。 从这里我们可以看到:串的模式值第一种表示方法能表示更多的信息,第二种表示方法更单纯,不容易搞错。当然,用第一种表示方法写出的模式匹配函数效率更高。比如说,在串S=“adCadCBdadCadCad 9876543”中匹配串T=“adCadCad”, 用第一种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时,取next[6]= -1(表三),它可以表示这样许多信息: S[3]S[4]S[5]==T[3]T[4]T[5]==T[0]T[1]T[2],而S[6] != T[6],T[6]==T[3]==T[0],所以S[6] != T[0],接下来比较S[7]和T[0]吧。如果用第二种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时,取next[6]= 3(表三),它只能表示:S[3]S[4]S[5]== T[3]T[4]T[5]==T[0]T[1]T[2],但不能确定T[6]与T[3]相不相等,所以,接下来比较S[6]和T[3];又不相等,取next[3]= 0,它表示S[3]S[4]S[5]== T[0]T[1]T[2],但不会确定T[3]与T[0]相不相等,即S[6]和T[0] 相不相等,所以接下来比较S[6]和T[0],确定它们不相等,然后才会比较S[7]和T[0]。是不是比用第一种表示方法写出的模式匹配函数多绕了几个弯。 为什么,在讲明第一种表示方法后,还要讲没有第一种表示方法好的第二种表示方法?原因是:最开始,我看严蔚敏的一个讲座,她给出的模式值表示方法是我这里的第二种表示方法,如图: 她说:“next 函数值的含义是:当出现S[i] !=T[j]时,下一次的比较应该在S[i]和T[next[j]] 之间进行。”虽简洁,但不明了,反复几遍也没明白为什么。而她给出的算法求出的模式值是我这里说的第一种表示方法next值,就是前面的get_nextval()函数。匹配算法也是有瑕疵的。于是我在这里发帖说她错了: http://community.csdn.net/Expert/topic/4413/4413398.xml?temp=.2027246 现在看来,她没有错,不过有张冠李戴之嫌。我不知道,是否有人第一次学到这里,不参考其他资料和明白人讲解的情况下,就能搞懂这个算法(我的意思是不仅是算法的大致思想,而是为什么定义和例子中next[j]=k(0≤k<j),而算法中next[j]=k(-1≤k<j))。凭良心说:光看这个讲座,我就对这个教受十分敬佩,不仅讲课讲得好,声音悦耳,而且这门课讲得层次分明,恰到好处。在KMP这个问题上出了点小差错,可能是编书的时候,在这本书上抄下了例子,在那本书上抄下了算法,结果不怎么对得上号。因为我没找到原书,而据有的网友说,书上已不是这样,也许吧。说起来,教授们研究的问题比这个高深不知多少倍,哪有时间推演这个小算法呢。总之,瑕不掩玉。 书归正传,下面给出我写的求第二种表示方法表示的模式值的函数,为了从S的任何位置开始匹配T,“当出现S[i] !=T[j]时,下一次的比较应该在S[i]和T[next[j]] 之间进行。” 定义next[0]=0 。 void myget_nextval(const char *T, int next[]) { // 求模式串T的next函数值(第二种表示方法)并存入数组 next。 int j = 1, k = 0; next[0] = 0; while ( T[j] != '\0' ) { if(T[j] == T[k]) { next[j] = k; ++j; ++k; } else if(T[j] != T[0]) { next[j] = k; ++j; k=0; } else { next[j] = k; ++j; k=1; } }//while for(int i=0;i<j;i++) { cout<<next[i]; } cout<<endl; }// myget_nextval 下面是模式值使用第二种表示方法的匹配函数(next[0]=0) int my_KMP(char *S, char *T, int pos) { int i = pos, j = 0;//pos(S 的下标0≤pos<StrLength(S)) while ( S[i] != '\0' && T[j] != '\0' ) { if (S[i] == T[j] ) { ++i; ++j; // 继续比较后继字符 } else // a b a b c a a b c // 0 0 0 1 2 0 1 1 2 { //-1 0 -1 0 2 -1 1 0 2 i++; j = next[j]; /*当出现S[i] !=T[j]时, 下一次的比较应该在S[i]和T[next[j]] 之间进行。要求next[0]=0。 在这两个简单示范函数间使用全局数组next[]传值。*/ } }//while if ( T[j] == '\0' ) return (i-j); // 匹配成功 else return -1; } // my_KMP 六.后话--KMP的历史 [这段话是抄的] Cook于1970年证明的一个理论得到,任何一个可以使用被称为下推自动机的计算机抽象模型来解决的问题,也可以使用一个实际的计算机(更精确的说,使用一个随机存取机)在与问题规模对应的时间内解决。特别地,这个理论暗示存在着一个算法可以在大约m+n的时间内解决模式匹配问题,这里m和n分别是存储文本和模式串数组的最大索引。Knuth 和Pratt努力地重建了 Cook的证明,由此创建了这个模式匹配算法。大概是同一时间,Morris在考虑设计一个文本编辑器的实际问题的过程中创建了差不多是同样的算法。这里可以看到并不是所有的算法都是“灵光一现”中被发现的,而理论化的计算机科学确实在一些时候会应用到实际的应用中。 本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/lin_bei/archive/2006/09/20/1252686.aspx
### 回答1: 好的,我理解您的要求。以下是用C语言实现多例设计模式的示例代码: ```c #include <stdio.h> #include <stdlib.h> // 定义多例类 typedef struct { int id; } MultiInstance; // 定义静态变量数组 static MultiInstance* instances[3]; // 获取实例方法 MultiInstance* getInstance(int id) { if (id >= 0 && id < 3) { if (instances[id] == NULL) { instances[id] = (MultiInstance*)malloc(sizeof(MultiInstance)); instances[id]->id = id; } return instances[id]; } return NULL; } // 测试代码 int main() { MultiInstance* instance1 = getInstance(0); MultiInstance* instance2 = getInstance(1); MultiInstance* instance3 = getInstance(2); MultiInstance* instance4 = getInstance(0); printf("instance1: %p\n", instance1); printf("instance2: %p\n", instance2); printf("instance3: %p\n", instance3); printf("instance4: %p\n", instance4); return 0; } ``` 上述代码实现了一个简单的多例模式,其中包含一个多例类 `MultiInstance` 和一个获取实例的方法 `getInstance`。使用静态变量数组存储实例对象,当需要获取实例时,根据指定的 id 判断实例对象是否已经存在,如果不存在则创建一个新的实例对象,否则直接返回已有的实例对象。 在测试代码中,我们分别获取了 4 个实例对象,其中 `instance1` 和 `instance4` 对应的是同一个 id,验证了多例模式中同一 id 对应的实例对象应该是同一个。 ### 回答2: 设计模式是一种解决特定问题的重复可复用的设计方案。在C语言中,虽然没有像面向对象语言那样内置的类和对象的概念,但我们仍然可以通过一些技巧实现多例设计模式。下面是使用C语言实现多例设计模式的一个示例: ```c #include <stdio.h> typedef struct { int data; } Singleton; static Singleton instances[3] = { {0}, {0}, {0} }; static int counter = 0; Singleton* getInstance() { if (counter >= 3) { return NULL; } return &instances[counter++]; } int main() { Singleton* instance1 = getInstance(); instance1->data = 10; Singleton* instance2 = getInstance(); instance2->data = 20; Singleton* instance3 = getInstance(); instance3->data = 30; printf("Instance 1 data: %d\n", instance1->data); printf("Instance 2 data: %d\n", instance2->data); printf("Instance 3 data: %d\n", instance3->data); return 0; } ``` 在上面的示例中,我们通过定义一个`Singleton`结构,并创建一个包含3个元素的静态数组`instances`来保存多个实例。我们使用一个`counter`变量来跟踪当前创建的实例数量。通过`getInstance()`函数来获取实例,它会检查`counter`的值,并返回对应的实例指针。如果已经创建了3个实例,则返回NULL。 在`main()`函数中,我们依次获取并给每个实例的`data`成员赋值,然后打印出每个实例的`data`值。 这样,我们就通过C语言实现了多例设计模式。注意,这只是一个示例,实际应用中可能需要根据具体需求进行更灵活的设计和实现。 ### 回答3: C语言是一门强大的编程语言,虽然它没有内建的面向对象特性,但仍然可以使用一些技巧来实现各种设计模式。接下来我将介绍一些常见的设计模式,并使用C语言示例进行解释。 1. 工厂模式(Factory Pattern):工厂模式是一种创建型设计模式,可以根据不同的输入条件创建不同的对象。在C语言中,可以通过函数指针实现工厂模式。例如,可以定义一个函数指针类型,然后根据条件动态选择哪个函数进行实例化。 2. 单例模式(Singleton Pattern):单例模式是一种创建型设计模式,它保证一个类只有一个实例,并提供全局访问点。在C语言中,可以使用静态变量来实现单例模式。例如,可以在函数内部定义一个静态变量,然后通过函数返回该变量的指针来实现单例。 3. 观察者模式(Observer Pattern):观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都将得到通知并自动更新。在C语言中,可以使用函数指针来实现观察者模式。例如,可以定义一个结构体,其中包含一个函数指针成员,然后在其他对象中保存该结构体的实例,当需要通知时,调用函数指针进行更新。 4. 适配器模式(Adapter Pattern):适配器模式是一种结构型设计模式,它通过将一个类的接口转换成客户端所期望的另一个接口,使得原本不兼容的类可以一起工作。在C语言中,可以使用函数指针来实现适配器模式。例如,可以定义一个函数指针类型,然后通过函数指针调用不同的函数实现适配。 5. 装饰器模式(Decorator Pattern):装饰器模式是一种结构型设计模式,它允许将对象的行为动态地加入到对象中,而无需对其进行子类化。在C语言中,可以使用函数指针来实现装饰器模式。例如,可以定义一个函数指针类型,然后在实际操作时,根据需要选择性地调用函数指针。 总之,虽然C语言相对于其他编程语言来说在实现设计模式时更具挑战性,但通过合理运用函数指针等技巧,我们仍然可以在C语言实现多例设计模式

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

嵌入式-老费

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

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

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

打赏作者

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

抵扣说明:

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

余额充值