職責(zé)鏈模式（C語言實現(xiàn)）
來源：程序員人生 發(fā)布時間：2014-10-02 08:00:01 閱讀次數(shù)：2593次
一. 概述
職責(zé)鏈模式：
使多個對象都有機會處理請求，從而避免請求的發(fā)送者和接收者之間的耦合關(guān)系。將這些對象連成一條鏈，并沿著這條鏈傳遞該請求，直到有一個對象處理它為止。
二. 舉個例子
員工要求加薪
公司的管理者一共有三級：總經(jīng)理、總監(jiān)、經(jīng)理，如果一個員工要求加薪，應(yīng)該向主管的經(jīng)理申請，如果加薪的數(shù)量在經(jīng)理的職權(quán)內(nèi)，那么經(jīng)理可以直接批準(zhǔn)，否則將申請上交給總監(jiān)。總監(jiān)的處理方式也一樣，總經(jīng)理可以處理所有請求。這就是典型的職責(zé)鏈模式，請求的處理形成了一條鏈，直到有一個對象處理請求。
結(jié)構(gòu)圖如下：
假設(shè)：
經(jīng)理可以處理薪水的范圍在：0~500
總監(jiān)可以處理薪水的范圍在：500~1000
總經(jīng)理可以處理薪水的范圍在：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
", request);
} else if (concreteHandleAGetSuccessor(_self) != NULL) {
const Handle * const *succ = concreteHandleAGetSuccessor(_self);
(*succ)->handleRequest(succ, request);
} else {
fprintf(stderr, "Can't deal with: %d
", 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
", request);
} else if (concreteHandleBGetSuccessor(_self) != NULL) {
const Handle * const *succ = concreteHandleBGetSuccessor(_self);
(*succ)->handleRequest(succ, request);
} else {
fprintf(stderr, "Can't deal with: %d
", 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
", request);
} else if (concreteHandleCGetSuccessor(_self) != NULL) {
const Handle * const *succ = concreteHandleCGetSuccessor(_self);
(*succ)->handleRequest(succ, request);
} else {
fprintf(stderr, "Can't deal with: %d
", 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
生活不易，碼農(nóng)辛苦
如果您覺得本網(wǎng)站對您的學(xué)習(xí)有所幫助,可以手機掃描二維碼進行捐贈
