病人就医管理代码

2.病人就医管理

1.目标与要求

编写一个程序，反应病人到医院看病，排队看医生的情况。在病人排队的过程中，主要发生两件事。

（1） 病人到达诊室，将病历本交给护士，拍到等待队列中候诊。

（2） 护士从等待队列中取出以为病人的病历，该病人进入诊室就诊。

要求程序采用菜单方式，其选项及功能说明如下。

（1） 排队—输入病人的病历号，加入到病人排队队列中。

（2） 就诊—病人排列队列中最前面的病人就诊，并将其从队列中删除。

（3） 查看排队—从队首到队尾列出所有的排队病人的病历号。

（4） 下班—退出运行。

2.工具、准备工作

在实验开始前，应回顾或复习相关内容。

需要一台计算机，其中安装有Visual C++ 6.0、Visual c++ 2005、Visual C++ 2005

Express Dev-c++或MinGW Developer Studio等集成开发环境软件

3.实验分析

4.代码如下：

//头文件：hospitalize.h

#ifndef __HOSPITALIZE_H__

#define __HOSPITALIZE_H__

#include \"lk_queue.h\" // 链队列// 行医类

class Hospitalize

{

private:

// 行医类的数据成员:

LinkQueue queue; // 病人队列

// 辅助函数

void StandInALine(); // 排队

void Cure(); // 就诊

void Display(); // 查看排队

public:

// 方法声明及重载编译系统默认方法声明:

Hospitalize(){}; // 无参数的构造函数

~Hospitalize(){}; // 析构函数

void Work(); // 医生工作

};

// 行医类的实现部分

void Hospitalize::StandInALine()

// 操作结果: 输入排队病人的病历号，加入到病人排队队列中

{

unsigned int num; // 病历号

cout << \"请输入病历号:\";

cin >> num; // 输入排队病人

queue.InQueue(num); // 将病历号加入到病人排队队列中

}

void Hospitalize::Cure()

// 操作结果: 病人排队队列中最前面的病人就诊，并将其从队列中删除

{

if (queue.Empty())

{ // 无病人

cout << \"现已没有病人在排队了!\" << endl;

}

else

{

unsigned int num; // 病历号

queue.OutQueue(num); 并将其从队列中删除

// 病人排队队列中最前面的病人就诊，

cout << num << \"号病人现在就医.\" << endl;

}

}

void Hospitalize::Display()

// 操作结果: 从队首到队尾列出所有的排队病人的病历号

{

queue.Traverse(Write); 人的病历号

// 从队首到队尾列出所有的排队病

cout << endl;

}

void Hospitalize::Work()

// 操作结果: 医生工作

{

int select = 0;

while (select != 4)

{

cout << \"1. 排队--输入病人的病历号，加入到病人队列中\" << endl;

cout << \"2. 就诊--病人排队队列中最前面的病人就诊，并将其从队列中删除\" endl;

cout << \"3. 查看排队--从队首到队尾列出所有的排队病人的病历号\" << endl;

cout << \"4. 下班--退出运行\" << endl;

cout << \"请选择:\";

cin >> select; // 选择功能

<< switch(select)

{

case 1:

StandInALine(); break;

case 2:

Cure(); 除

break;

case 3:

Display(); break;

}

}

// 排队--输入病人的病历号，加入到病人队列中

// 就诊--病人排队队列中最前面的病人就诊，并将其从队列中删

// 查看排队--从队首到队尾列出所有的排队病人的病历号

}

#endif

//头文件：lk_queue.h

#ifndef __LK_QUEUE_H__

#define __LK_QUEUE_H__

#include \"utility.h\" // 实用程序软件包

#include \"node.h\" // 结点类模板

// 链队列类模板

template

class LinkQueue

{

protected:

// 链队列实现的数据成员:

Node *front, *rear; // 队头队尾指指

// 辅助函数模板:

void Init(); // 初始化队列

public:

// 抽象数据类型方法声明及重载编译系统默认方法声明:

LinkQueue(); // 无参数的构造函数模板

virtual ~LinkQueue(); // 析构函数模板

int Length() const; // 求队列长度

bool Empty() const; // 判断队列是否为空

void Clear(); // 将队列清空

void Traverse(void (*visit)(const ElemType &)) const ; // 遍历队列

StatusCode OutQueue(ElemType &e); // 出队操作

StatusCode GetHead(ElemType &e) const; // 取队头操作

StatusCode InQueue(const ElemType &e); // 入队操作

LinkQueue(const LinkQueue ©); // 复制构造函数模板

LinkQueue &operator =(const LinkQueue ©);// 重载赋值运算符

};

// 链队列类模板的实现部分

template

void LinkQueue::Init()

// 操作结果：初始化队列

{

rear = front = new Node; // 生成头结点

}

template

LinkQueue::LinkQueue()

// 操作结果：构造一个空队列

{

Init();

}

template

LinkQueue::~LinkQueue()

// 操作结果：销毁队列

{

Clear();

}

template

int LinkQueue::Length() const

// 操作结果：返回队列长度

{

int count = 0; // 计数器

for (Node *tmpPtr = front->next; tmpPtr != NULL; tmpPtr = tmpPtr->next)

{ // 用tmpPtr依次指向每个元素

count++; // 对栈每个元素进行计数

}

return count;

}

template

bool LinkQueue::Empty() const

// 操作结果：如队列为空，则返回true，否则返回false

{

return rear == front;

}

template

void LinkQueue::Clear()

// 操作结果：清空队列

{

ElemType tmpElem; // 临时元素值

while (Length() > 0)

{ // 队列非空，则出列

OutQueue(tmpElem);

}

}

template

void LinkQueue::Traverse(void (*visit)(const ElemType &)) const

// 操作结果：依次对队列的每个元素调用函数(*visit)

{

for (Node *tmpPtr = front->next; tmpPtr != NULL;

tmpPtr = tmpPtr->next)

{ // 对队列每个元素调用函数(*visit)

(*visit)(tmpPtr->data);

}

}

template

StatusCode LinkQueue::OutQueue(ElemType &e)

// 操作结果：如果队列非空，那么删除队头元素，并用e返回其值，返回SUCCESS,

// 否则返回UNDER_FLOW，

{

if (!Empty())

{ // 队列非空

Node *tmpPtr = front->next; // 指向队列头素

e = tmpPtr->data; // 用e返回队头元素

front->next = tmpPtr->next; // front指向下一元素

if (rear == tmpPtr)

{ // 表示出队前队列中只有一个元素，出队后为空队列

rear = front;

}

delete tmpPtr; // 释放出队的结点

return SUCCESS;

}

else

{ // 队列为空

return UNDER_FLOW;

}

}

template

StatusCode LinkQueue::GetHead(ElemType &e) const

// 操作结果：如果队列非空，那么用e返回队头元素，返回SUCCESS,

// 否则返回UNDER_FLOW，

{

if (!Empty())

{ // 队列非空

Node *tmpPtr = front->next; // 指向队列头素

e = tmpPtr->data; // 用e返回队头元素

return SUCCESS;

}

else

{ // 队列为空

return UNDER_FLOW;

}

}

template

StatusCode LinkQueue::InQueue(const ElemType &e)

// 操作结果：插入元素e为新的队尾，返回SUCCESS

{

Node *tmpPtr = new Node(e); // 生成新结点

rear->next = tmpPtr; // 新结点追加在队尾

rear = tmpPtr; // rear指向新队尾

return SUCCESS;

}

template

LinkQueue::LinkQueue(const LinkQueue ©)

// 操作结果：由队列copy构造新队列——复制构造函数模板

{

Init();

for (Node *tmpPtr = copy.front->next; tmpPtr != NULL;

tmpPtr = tmpPtr->next)

{ // 对copy队列每个元素对当前队列作入队列操作

InQueue(tmpPtr->data);

}

}

template

LinkQueue LinkQueue ©)

&LinkQueue::operator =(const

// 操作结果：将队列copy赋值给当前队列——重载赋值运算符

{

if (© != this)

{

Clear();

for (Node *tmpPtr = copy.front->next; tmpPtr != NULL;

tmpPtr = tmpPtr->next)

{ // 对copy队列每个元素对当前队列作入队列操作

InQueue(tmpPtr->data);

}

}

return *this;

}

#endif

//头文件： node.h

#ifndef __NODE_H__

#define __NODE_H__

// 结点类模板

template

struct Node

{

// 数据成员:

ElemType data; // 数据域

Node *next; // 指针域

// 构造函数模板:

Node(); // 无参数的构造函数模板

Node(ElemType item, Node *link = NULL); 指针建立结构

};

// 结点类模板的实现部分

template

Node::Node()

// 操作结果：构造指针域为空的结点

{

next = NULL;

}

template

// 已知数据元素值和

Node::Node(ElemType item, Node *link)

// 操作结果：构造一个数据域为item和指针域为link的结点

{

data = item;

next = link;

}

#endif

//头文件：utility.h

#ifndef __UTILITY_H__ #define __UTILITY_H__ // 实用程序软件包

#ifdef _MSC_VER #if _MSC_VER == 1200 // 如果没有定义__UTILITY_H__

// 那么定义__UTILITY_H__

// 表示是VC

// 表示VC6.0

// 标准库头文件

#include #include #include #include #include #include #include #include #include #include #include #include

// 标准串和操作

// 标准流操作

// 极限

// 数学函数

// 文件输入输出

// 字符处理

// 日期和时间函数

// 标准库

// 标准输入输出

// 输入输出流格式设置 // 支持变长函数参数

// 支持断言

#else // ANSI C++标准库头文件

#include #include #include #include #include #include #include #include #include #include #include // 其它版本的VC++

// 标准串和操作

// 标准流操作

// 极限

// 数学函数

// 文件输入输出

// 字符处理

// 日期和时间函数

// 标准库

// 标准输入输出

// 输入输出流格式设置 // 支持变长函数参数

#include // 支持断言

using namespace std; // 标准库包含在命名空间std中

#endif // _MSC_VER == 1200

#else // ANSI C++标准库头文件

#include #include #include #include #include #include #include #include // 非VC

// 标准串操作

// 标准流操作

// 极限

// 数据函数

// 文件输入输出

// 字符处理

// 日期和时间函数

// 标准库

#include // 标准输入输出

#include // 输入输出流格式设置

#include // 支持变长函数参数

#include // 支持断言

using namespace std; // 标准库包含在命名空间std中

#endif // _MSC_VER

// 自定义类型

enum StatusCode {SUCCESS, FAIL, UNDER_FLOW, OVER_FLOW,RANGE_ERROR, DUPLICATE_ERROR,

NOT_PRESENT, ENTRY_INSERTED, ENTRY_FOUND, VISITED, UNVISITED};

// 宏定义

#define DEFAULT_SIZE 1000 // 缺省元素个数

#define DEFAULT_INFINITY 1000000 // 缺省无穷大

// 实用函数(模板)声明

static char GetChar(istream &inStream = cin); // 从输入流inStream中跳过空格及制表符获取一字符

static bool UserSaysYes(); 回答(no)时,返回false

// 当用户肯定回答(yes)时, 返回true, 用户否定

static void SetRandSeed(); // 设置当前时间为随机数种子

static int GetRand(int n); // 生成0 ~ n-1之间的随机数

static int GetRand(); // 生成随机数

static int GetPoissionRand(double expectValue);// 生成期望值为expectValue泊松随机数

template

void Swap(ElemType &e1, ElemType &e2); // 交换e1, e2之值

template

void Display(ElemType elem[], int n); // 显示数组elem的各数据元素值

template

void Write(const ElemType &e); // 显示数据元素

// 实用类

class Timer; // 定时器类Timer

class Error; // 通用异常类

static char GetChar(istream &inStream)

// 操作结果：从输入流inStream中跳过空格及制表符获取一字符

{

char ch; // 临时变量

while ((ch = (inStream).peek()) != EOF // 文件结束符(peek()函数从输入流中接受1

// 字符,流的当前位置不变)

&& ((ch = (inStream).get()) == ' ' // 空格(get()函数从输入流中接受1字符,流

// 的当前位置向后移1个位置)

|| ch == '\')); // 制表符

return ch; // 返回字符

}

static bool UserSaysYes()

// 操作结果: 当用户肯定回答(yes)时, 返回true, 用户否定回答(no)时,返回false

{

char ch; // 用户回答字符

bool initialResponse = true; // 初始回答

do

{ // 循环直到用户输入恰当的回答为止

if (initialResponse)

{ // 初始回答

cout << \"(y, n)?\";

}

else

{ // 非初始回答

cout << \"用y或n回答:\";

}

while ((ch = GetChar()) == '\\n'); // 跳过空格,制表符及换行符获取一字符

initialResponse = false;

} while (ch != 'y' && ch != 'Y' && ch != 'n' && ch != 'N');

while (GetChar() != '\\n'); // 跳过当前行后面的字符

if (ch == 'y' || ch == 'Y') return true;

else return false;

}

// 定时器类Timer

class Timer

{

private:

// 数据成员

clock_t startTime;

public:

// 方法声明

Timer() { startTime = clock(); } // 构造函数

~Timer() {}; // 析构函数

double ElapsedTime() // 返回已过的时间

{

clock_t endTime = clock(); // 结束时间

return (double)(endTime - startTime) / (double)CLK_TCK;

// 返回从Timer对象启动或最后一次调用reset()后所使用的CPU时间

}

void Reset() { startTime = clock(); } // 重置开始时间

};

#define MAX_ERROR_MESSAGE_LEN 100

// 通用异常类

class Error

{

private:

// 数据成员

char message[MAX_ERROR_MESSAGE_LEN];// 异常信息

public:

// 方法声明

Error(char mes[] = \"一般性异常!\") // 构造函数

{

strcpy(message, mes); // 复制异常信息

}

~Error(void) {}; // 析构函数

void Show() const // 显示异常信息

{

cout << message << endl; // 显示异常信息

}

};

static void SetRandSeed()

// 操作结果：设置当前时间为随机数种子

{

srand((unsigned)time(NULL));

}

static int GetRand(int n)

// 操作结果：生成0 ~ n-1之间的随机数

{

return rand() % (n);

}

static int GetRand()

// 操作结果：生成随机数

{

return rand();

}

static int GetPoissionRand(double expectValue)

// 操作结果：生成期望值为expectValue泊松随机数

{

double x = rand() / (double)(RAND_MAX + 1); // x均匀分布于[0, 1)

int k = 0;

double p = exp(-expectValue); // pk为泊松分布值

double s = 0; // sk用于求和p0+p1+...+pk-1

while (s <= x)

{ // 当sk <= x时循环, 循环结束后sk-1 <= x < sk

s += p; // 求和

k++;

p = p * expectValue / k; // 求下一项pk

}

return k - 1; // k-1的值服从期希值为expectValue的泊松分布

}

template

void Swap(ElemType &e1, ElemType &e2)

// 操作结果: 交换e1, e2之值

{

ElemType temp; // 临时变量

// 循环赋值实现交换e1, e2

temp = e1; e1 = e2; e2 = temp;

}

template

void Display(ElemType elem[], int n)

// 操作结果: 显示数组elem的各数据元素值

{

for (int i = 0; i < n; i++)

{ // 显示数组elem

cout << elem[i] << \" \";

}

cout << endl;

}

template

void Write(const ElemType &e)

// 操作结果: 显示数据元素

{

cout << e << \" \";

}

#endif

//主函数main().cpp

#include \"utility.h\" // 实用程序软件包

#include \"hospitalize.h\" // 行医类的头文件

int main(void)

{

Hospitalize obj; obj.Work(); system(\"PAUSE\"); return 0; }

// 行医类对象

// 医生工作

// 调用库函数system()

// 返回值0, 返回操作系统