职责链模式（C语言实现）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了职责链模式（C语言实现），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7040字，纯文字阅读大概需要11分钟。

内容图文

一. 概述

职责链模式：

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

二. 举个例子

员工要求加薪

公司的管理者一共有三级：总经理、总监、经理，如果一个员工要求加薪，应该向主管的经理申请，如果加薪的数量在经理的职权内，那么经理可以直接批准，否则将申请上交给总监。总监的处理方式也一样，总经理可以处理所有请求。这就是典型的职责链模式，请求的处理形成了一条链，直到有一个对象处理请求。

结构图如下：

假设：

经理可以处理薪水的范围在：0~500
总监可以处理薪水的范围在：500~1000
总经理可以处理薪水的范围在：1000~2000

则代码如下：

abstractClass.h

#ifndef ABSTRACTCLASS_H
#define ABSTRACTCLASS_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
} AbstractClass;

#endif

handle.h

#ifndef HANDLE_H
#define HANDLE_H

#include <stdlib.h>
#include <stdarg.h>

typedef struct {
    size_t size;
    void* (*ctor)(void *_self, va_list *params);
    void* (*dtor)(void *_self);
    void (*setSuccessor)(void *_self, void *succ);
    void *(*getSuccessor)(const void *_self);
    void (*handleRequest)(const void *_self, int request);
} Handle;


#endif

concreteHandleA.h

#ifndef CONCRETEHANDLEA_H
#define CONCRETEHANDLEA_H

typedef struct {
    const void *_;
    void *succ;
} _ConcreteHandleA;

extern const void *ConcreteHandleA;

#endif

concreteHandleA.c

#include "handle.h"
#include "concreteHandleA.h"
#include <stdlib.h>
#include <stdio.h>

static void *concreteHandleACtor(void *_self, va_list *params) {
    _ConcreteHandleA *self = _self;

    return self;
}

static void *concreteHandleADtor(void *_self) {
    _ConcreteHandleA *self = _self;

    self->succ = NULL;

    return self;
}

static void concreteHandleASetSuccessor(void *_self, void *_succ) {
    _ConcreteHandleA *self = _self;

    self->succ = _succ;
}

static void *concreteHandleAGetSuccessor(const void *_self) {
    const _ConcreteHandleA *self = _self;

    return self->succ;
}

static void concreteHandleAhandleRequest(const void *_self, int request) {
    if (request >= 0 && request < 500) {
        fprintf(stdout, "ConcreteHandleA deal with: %d\n", request);
    } else if (concreteHandleAGetSuccessor(_self) != NULL) {
        const Handle * const *succ = concreteHandleAGetSuccessor(_self);
        (*succ)->handleRequest(succ, request);
    } else {
        fprintf(stderr, "Can't deal with: %d\n", request);
    }
}

static const Handle _concreteHandleA = {
    sizeof(_ConcreteHandleA),
    concreteHandleACtor,
    concreteHandleADtor,
    concreteHandleASetSuccessor,
    concreteHandleAGetSuccessor,
    concreteHandleAhandleRequest
};

const void *ConcreteHandleA = &_concreteHandleA;

concreteHandleB.h

#ifndef CONCRETEHANDLEB_H
#define CONCRETEHANDLEB_H

typedef struct {
    const void *_;
    void *succ;
} _ConcreteHandleB;

extern const void *ConcreteHandleB;

#endif

concreteHandleB.c

#include "handle.h"
#include "concreteHandleB.h"
#include <stdlib.h>
#include <stdio.h>

static void *concreteHandleBCtor(void *_self, va_list *params) {
    _ConcreteHandleB *self = _self;

    return self;
}

static void *concreteHandleBDtor(void *_self) {
    _ConcreteHandleB *self = _self;

    self->succ = NULL;

    return self;
}

static void concreteHandleBSetSuccessor(void *_self, void *_succ) {
    _ConcreteHandleB *self = _self;

    self->succ = _succ;
}

static void *concreteHandleBGetSuccessor(const void *_self) {
    const _ConcreteHandleB *self = _self;

    return self->succ;
}

static void concreteHandleBhandleRequest(const void *_self, int request) {
    if (request >= 500 && request < 1000) {
        fprintf(stdout, "ConcreteHandleB deal with: %d\n", request);
    } else if (concreteHandleBGetSuccessor(_self) != NULL) {
        const Handle * const *succ = concreteHandleBGetSuccessor(_self);
        (*succ)->handleRequest(succ, request);
    } else {
        fprintf(stderr, "Can't deal with: %d\n", request);
    }
}

static const Handle _concreteHandleB = {
    sizeof(_ConcreteHandleB),
    concreteHandleBCtor,
    concreteHandleBDtor,
    concreteHandleBSetSuccessor,
    concreteHandleBGetSuccessor,
    concreteHandleBhandleRequest
};

const void *ConcreteHandleB = &_concreteHandleB;

concreteHandleC.h

#ifndef CONCRETEHANDLEC_H
#define CONCRETEHANDLEC_H

typedef struct {
    const void *_;
    void *succ;
} _ConcreteHandleC;

extern const void *ConcreteHandleC;

#endif

concreteHandleC.c

#include "handle.h"
#include "concreteHandleC.h"
#include <stdlib.h>
#include <stdio.h>

static void *concreteHandleCCtor(void *_self, va_list *params) {
    _ConcreteHandleC *self = _self;

    return self;
}

static void *concreteHandleCDtor(void *_self) {
    _ConcreteHandleC *self = _self;

    self->succ = NULL;

    return self;
}

static void concreteHandleCSetSuccessor(void *_self, void *_succ) {
    _ConcreteHandleC *self = _self;

    self->succ = _succ;
}

static void *concreteHandleCGetSuccessor(const void *_self) {
    const _ConcreteHandleC *self = _self;

    return self->succ;
}

static void concreteHandleChandleRequest(const void *_self, int request) {
    if (request >= 1000 && request < 2000) {
        fprintf(stdout, "ConcreteHandleC deal with: %d\n", request);
    } else if (concreteHandleCGetSuccessor(_self) != NULL) {
        const Handle * const *succ = concreteHandleCGetSuccessor(_self);
        (*succ)->handleRequest(succ, request);
    } else {
        fprintf(stderr, "Can't deal with: %d\n", request);
    }
}

static const Handle _concreteHandleC = {
    sizeof(_ConcreteHandleC),
    concreteHandleCCtor,
    concreteHandleCDtor,
    concreteHandleCSetSuccessor,
    concreteHandleCGetSuccessor,
    concreteHandleChandleRequest
};

const void *ConcreteHandleC = &_concreteHandleC;

new.h

#ifndef NEW_H
#define NEW_H

void *New(const void *_class, ...);
void Delete(void *_class);
void SetSuccessor(void *_handle, void *_succ);
void HandleRequest(void *_handle, int request);

#endif

new.c

#include "new.h"
#include "abstractClass.h"
#include "handle.h"
#include <stdarg.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

void *New(const void *_class, ...) {
    const AbstractClass *class = _class;

    void *p = calloc(1, class->size);

    assert(p);
    *(const AbstractClass **)p = class;
    
    if (class->ctor) {
        va_list params;

        va_start(params, _class);
        p = class->ctor(p, ?ms);
        va_end(params);
    }

    return p;
}

void Delete(void *_class) {
    const AbstractClass **class = _class;

    if (_class && *class && (*class)->dtor) {
        _class = (*class)->dtor(_class);
    }

    free(_class);
}

void SetSuccessor(void *_handle, void *_succ) {
    Handle **handle = _handle;

    if (_handle && *handle && (*handle)->setSuccessor) {
        (*handle)->setSuccessor(_handle, _succ);
    }
}

void HandleRequest(void *_handle, int request) {
    Handle **handle = _handle;

    if (_handle && *handle && (*handle)->handleRequest) {
        (*handle)->handleRequest(_handle, request);
    }
}

main.c

#include "new.h"
#include "concreteHandleA.h"
#include "concreteHandleB.h"
#include "concreteHandleC.h"

int main(int argc, char *argv[]) {
    void *h1 = New(ConcreteHandleA);
    void *h2 = New(ConcreteHandleB);
    void *h3 = New(ConcreteHandleC);

    SetSuccessor(h1, h2);
    SetSuccessor(h2, h3);

    HandleRequest(h1, 300);
    HandleRequest(h1, 600);
    HandleRequest(h1, 1500);
    HandleRequest(h1, 3000);
    
    Delete(h1);
    Delete(h2);
    Delete(h3);
    
    return 0;
}

图片来源：http://blog.csdn.net/hmsiwtv/article/details/9627307

原文：http://blog.csdn.net/hmsiwtv/article/details/39613759

内容总结

以上是互联网集市为您收集整理的职责链模式（C语言实现）全部内容，希望文章能够帮你解决职责链模式（C语言实现）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1212786.html

来源：【匿名】

【上一篇】【C语言总结】字符串【下一篇】C语言MD5的源码实例详解

更多 ►

【职责链模式（C语言实现）】教程文章相关的互联网学习教程文章

一. 概述职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。二. 举个例子员工要求加薪公司的管理者一共有三级：总经理、总监、经理，如果一个员工要求加薪，应该向主管的经理申请，如果加薪的数量在经理的职权内，那么经理可以直接批准，否则将申请上交给总监。总监的处理方式也一样，总经理可以处理所有请求。...

【c语言】编写一个函数实现n^k，使用递归实现【图】

//编写一个函数实现n^k，使用递归实现#include <stdio.h>int cifang( int x, int y )//2^3=2*2*2 {int sum = 0;if( y == 0 )sum = 1;elsesum = x * cifang( x, ( y - 1 ) );return sum; }int main() {printf("%d\n",cifang( 2,0 ));printf("%d\n",cifang( 3,2 ));printf("%d\n",cifang( 4,1 ));return 0; } 原文：http://blog.csdn.net/zhaoyaqian552/article/details/44889767

使用C语言来实现模块化【图】

除了C语言以及C++编程语言之外，在其它现在非常流行的开发语言中，比如说：java，php，jsp等等。我们很难想象到缺少标准化的模块管理机制是一件多么可怕的事情。但是这往往也是由C语言本身的设计哲学决定出来的：将尽可能多的可能性留给开发人员。然后根据实际情况的系统，根据大家的实际需要来定制一些自己所需要的东西。　　对于一些稍微小一点的系统来说（就是我们在开发过程中通常会接触到的系统），一般情况下我们都会考虑选择...

C语言itoa()函数和atoi()函数详解(整数转字符C实现)【转载】

文章转载自https://www.cnblogs.com/bluestorm/p/3168719.html C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串。1.int/float to string/array:C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串，下面列举了各函数的方法及其说明。● itoa()：将整型值转换为字符串。● ltoa()：将长整型值转换为字符串。● ultoa()：将无符号长整型值转换为字符串。●...

大数相加（c语言实现）【代码】

用字符串模拟大数，只需注意进位，使用了栈。代码： 1 #include<stdio.h>2 #include<string.h>3char A[99999];4char B[99999];5char sum[99999]="0";6void add()7{8int top1=0,top2=0,len1,len2,len,top=0,i,j,temp;9for(top1=0;A[top1]!=‘\0‘;top1++); 10for(top2=0;B[top2]!=‘\0‘;top2++); 11 printf("%d %d\n",top1,top2); 12 len=top1+top2; 13 top=len; 14 sum[top]=‘\0‘; 15if(top1>top2) j=1; 16else...

C语言实现小游戏之2048篇【代码】

#include <stdio.h>#include <stdlib.h>#include <conio.h>#include <time.h>void start();void qingchu();void restart();void chexiao();void random();void print();void up(int tp[]);void down(int tp[]);void left(int tp[]);void right(int tp[]);void which_key();void magic(int c);void judge();int cube[16] = { 0 };int main(void){ srand((unsigned)time(0)); which_key(); system("pause"); return 0;}void which_ke...

高仿linux下的ls -l命令——C语言实现【代码】【图】

主要用到的函数可以参考头文件，仅仅支持ls -l这功能，扩展就交给大家了0.0相关测试图片：?? 话不多说，直接上码 1 #include <stdio.h>2 #include <stdlib.h>3 #include <unistd.h>4 #include <sys/stat.h>5 #include <sys/types.h>6 #include <string.h>7 #include <time.h>8 #include <pwd.h>9 #include <grp.h>10 #include <time.h>11 #include <dirent.h>12 13#define MAX_FILE_NUM 20014 15 16//可能还有一些小问题没有解决，...

数据结构--快速、冒泡、选择排序C语言实现

#include<stdio.h> //快速排序 void quickSort(int a[],int left,int right) {int i,j,temp;i = left;j = right;temp = a[left];if(left>right)return;while(i!=j){while(a[j]>=temp &&j>i)j--;if(j>i)a[i++] = a[j];while(a[i]<=temp&&j>i)i++;if(j>i)a[j--] = a[i];}a[i] = temp;quickSort(a,left,i-1);quickSort(a,i+1,right); } //冒泡排序 void bubbleSort(int a[],int len) {int i,j,temp;for(i = 0;i<len;i++){ for(j = 0...

C语言实现strcat【代码】

首先看看代码： 1#ifndef STRCAT_H2#define STRCAT_H3 4/*******************************************************************5原型:extern char *strcat(char *dest,char *src);6 7strcat() 会将参数 src 字符串复制到参数 dest 所指的字符串尾部；8dest最后的结束字符NULL会被覆盖掉，并在连接后的字符串的尾部再增加一个 NULL。910返回指向dest的指针。 1112注意：dest 与 src 所指的内存空间不能重叠， 13 且 dest 要有足...

最小堆 / 优先队列（C语言实现）

#include<stdio.h> void main() {//其中第一条斜线是00 - 11 - 22 -33 第二条10 - 21 - 32int arr2[4][4] = { 00, 01, 02, 03,10 , 11, 12, 13, 20 , 21, 22, 23,30, 31, 32, 33,};int i, j;int sum = 0;int index = 0;for (int i = 0; i < 4; i++){for (int j = 0; j < 4; j++){//printf("最初的i=%d", i);//满足这个条件的情况下if (j - i == j){int index = j ;printf("\n\n\n%d\n\n", index);printf("i=%d,j=%d\n...

C语言实现状态设计模式

#include <stdio.h> #include <stdlib.h> #include <string.h>#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; struct SUBTYPE* SUBTYPE##instance = (struct SUBTYPE*)malloc(sizeof(struct SUBTYPE)); SUBTYPE##instance->SUBTYPE##_constructor = SUBTYPE##_construc...

用C语言实现统计一个文件夹中各种文件的比例【代码】【图】

原文:用C语言实现统计一个文件夹中各种文件的比例　　《UNIX环境高级编程》中的程序清单4-7就介绍了如何实现递归地统计某个目录下面的文件！我刚开始看过它的代码后，觉得照着敲太没意思了，所以就合上书自己写了一遍！为此还写了一篇博文，这是博文地址：在linux下用C语言实现递归查看某个目录中的所有文件【CSDN】！今天做《Unix环境高级编程》的课后题，看到题目4.11这里提供了一种新的实现这个程序的思路，那就是每回读到一个...

c语言编程:实现数字的翻转

方法一：（易理解的）#include<stdio.h> #include<stdlib.h>int main() {int n;scanf("%d",&n);//输入要翻转的数字 int result = 0;//保存翻转后的结果while(1)//while(true)也可以 {int i = n%10;//每次都是得到最低位上的数字result = result*10+i;n = n/10;//递归降位if(n == 0){break;} }printf("翻转后的数字是%d\n",result); } 方法二(模块化设计，好像是百度的面试题) #include<stdio.h> #include<stdlib.h>//获取一个整数...

Android通过JNI实现与C语言的串口通讯操作蓝牙硬件模块【图】

一直想写一份技术文档，但由于自感能力有限而无从下笔，最近做了个关于Android平台下实现与C语言的通讯来操作蓝牙模块的项目，中间碰到了许多问题，也在网上查了许多资料，在完成主要功能后，也有一些人在网上问我一些问题，这里写下这篇文档算是一个阶段性的总结。如果反响好，后续将会发上Android Stub与新版Android HAL的学习文档。由于蓝牙模块是串口通讯机制，使用C语言来访问，而Android的应用层采用Java，无法直接操作硬件。...

二叉树的非递归遍历C语言实现

腾讯面试中被问到二叉树的非递归遍历实现，当时记得不太清楚，回来专门复习了非递归的实现，整理代码如下：//采用二叉链表存储方式的二叉树，非递归中序遍历C语言实现代码 #include<stdio.h> #include <malloc.h> //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //Status是函数的类型，其值是函数结果状态代码 typedef int Status;#define STACK_INI...

C语言 - 技术教程分类

C 语言教程 C 简介 C 程序结构 C 基本语法 C 数据类型 C 变量 C 常量 C 存储类 C 运算符 C 判断 C 循环 C 函数 C 作用域规则 C 数组 C enum(枚举) C 指针 C 函数指针与回调函数 C 字符串 C 结构体 C 位域 C typedef C 输入 & 输出 C 头文件 C 强制类型转换 C 错误处理 C 递归 C 可变参数 C 内存管理 C 命令行参数 C 语言实例 C 标准库 -?ctype.h C 标准库 -?math.h C 标准库 -?string.h c语言全部

C语言 - 最热教程

C语言调试器GDB和LLDB的使用方法 C语言连接MySQL数据库（课程设计总结）小白入门C语言之数组篇 C/C++编程笔记：Unix AIX和Linux C语言...C语言打印Hello sublime text 3 编译C语言配置 C语言编程快捷键线索二叉树（C语言）C语言输出系统时间 c语言小游戏-三子棋的完成