물마시니의 구구절절

뭐 이것저것 손대다 보니

어느새 한번에 너무 많이 진행 중…

이러다 제풀에 지쳐서 다 망하는 건 아닌지 … –_- 완전 걱정 중;;

또 학기 중에 과목으로 소프트웨어 공학, 웹 프로그래밍, 데이터베이스, 네트워크 수강 중인데

이게 다 팀으로 과제 제출 하는 거라서

-_-… 오 마이 갓…진짜 토 나온다 ㅎㅎ

그 중에서 가장 백미는 역시 소프트웨어 공학 !!

교수님부터 완전 엄하게 지도하시다 보니

과제 검사 및 완성도도 장난 아니라는..ㅠㅠ

평소에 전공 책 한 글자 보기 힘든 내가… 책까지 어디서 줏어 와서 열심히 들여다 보고 있으니;;

근데 책이 참 더럽구먼;;

요즘에 어쩌다보니 하는 것도 없이 합숙실에 계속 눌러 있게 되었지만

우연찮게 어학원 홈페이지 만드는 일을 맡게 되서

30만원이라는 싸구려 몸값으로 일하게 되었다 =_= 허허허

물론 내 코딩이 참 쓰레기 라는걸 알지만 허허 이건 너무 싸잖아

하지만 난 요즘 통장 잔고도 바닥나서 이대로 살다가는

가난에 치여 죽을지도 모르는 상황…

어쩔수 없이 승락하고 약 2주일 가량의 밍기적 거림으로

홈페이지를 완성 하게 되었다.

http://globalfunglish.com 아놔 썅

이런 식으로 다시 만들어 달라고 하는 클라이언트 있으면

때려줄지도 모른다능?! 덤벼라 =_=

암튼 합숙실에서는 애들 과제 나올때마다 발표를 하면서 약간의 실력 향상을

도모 하고 있긴 한데.. 과연 몇명이나 따라 올지?!

뭐 근성있게 따라 오는 녀석들도 있지만.. 과제도 아예 안하고 노는 애들도 많은 상황이라 =_=

2학기 되서 수업내용 앞서 나가려면 지금 열심히 해야 되는데.. 흠…

진영아 수업 안듣고 어딜 보는거니 =_=

나름대로 열심히 하려고 하긴 하는구나만..=_= 허헛.. 집중좀 해 =_=

나름대로 열심히 준비해서 수업하고 있는 진동이..ㅋㅋ 마음에 든다 +_+!! 뭐 평소에는 힘들지만..ㅋㅋ

허허허허~~

아무튼 나름대로 열심히 준비도 하고 노력도 많이 하고 있지만

아직 부족한 점이 많은 합숙실이라.. 후배들한테 좀 미안하기는 하지만

조만간에 에어컨도 빵빵하게 나오고

어디 다른 동아리에서 터치도 못하도록 할수 있도록 노력 중이니

뭐 잘되겠지 ㅋㅋㅋ

암튼 합숙실에 많이들 오라는 이야기 =_=

이번에 만든 프로그램은 링크드 리스트를 이용한

간단한? 입,퇴원 및 병실 및 병동 입원현황을 알수 있도록 만드는 것이다.

파일로부터 입력받은 환자와 병실 목록을 이용해서

병실 정보 안에 링크드리스트로 입원중인 환자를 추가하는 게

기본적인 아이디어다.

퇴원은 반대로 링크드리스트에서 제외하는것.

환자 목록은 현재 입원중인 환자와 퇴원한 환자 2가지 경우로 나누어

생각했기 때문에 목록을 각각 따로 만들어주었다.

그렇기 때문에 입원 및 퇴원시 각각 목록으로 옮겨주어야 되는 단점이 있지만

따로 관리 하기 때문에 더 편리한 부분이 있다.

[spoiler "소스 내용"]

#include <iostream>

#include <fstream>

#include <stdlib.h>

#include <string>

#include <time.h>

using namespace std;

#pragma warning(disable:4996) // warning 을 감춰주는 매크로

#define MAX_PATIENTS 100 // 최대 환자수

#define MAX_ROOMS 100 // 최대 방수

#define MAX_CLINICAL_PARTS 10 // 최대 진료부서수

#define MAX_LENGTH 20 // 최대길이

#define MAX_DATE_LEN 9 // “yyyymmdd”

#define EMPTY “”

#define EMPTY_DATE “0″ // empty data of in_date or out_date

#define EMPTY_ROOM -1

#define EMPTY_PATIENT -1

#define DUMMY_P_ID -999 // 병실 입원 환자 목록 더미노드의 Patient ID 값

#define SUCCESS 1

#define NOT_FOUND -1

#define CHECKED_IN -2 // 입원중인 환자

#define CHECKED_OUT -3 // 퇴원한 환자

#define WANT_TO_QUIT -999

#define TRUE 1

#define FALSE 0

// menu constants

#define CHECK_IN 1

#define CHECK_OUT 2

#define INQUIRY 3

#define EXIT 4

void get_date(char date[]);

int get_menu();

//환자 관련 클래스

class Patient {

int patient_id; // 고유 번호

char patient_name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_DATE_LEN]; // yyyymmdd

int room_no; // 현재 입원중인 환자: 병실번호, 퇴원환자:NULL

char out_date[MAX_DATE_LEN]; // 현재 입원중인 환자: EMPTY, 퇴원환자:퇴원일

public:

Patient() { // 생성자

patient_id=EMPTY_PATIENT; strcpy(patient_name, “”);

sex=0; age=0; insurance=’N';

clinic_part=0;

strcpy(in_date, “”);

room_no = EMPTY_ROOM, strcpy(out_date, “”);

}

Patient(int p_id, char *p_name, char p_sex, int p_age, char p_insurance, char p_clinic_part, char *p_in_date, int r_no, char *p_out_date) { // 생성자 오버라이딩

patient_id=p_id;

strncpy(patient_name, p_name, MAX_LENGTH);

sex=p_sex;

age=p_age;

insurance=p_insurance;

clinic_part=p_clinic_part;

strncpy(in_date, p_in_date, MAX_DATE_LEN);

room_no = r_no;

strncpy(out_date, p_out_date, MAX_DATE_LEN);

}

~Patient() { } // 파괴자

void setPatientId(int p_id) { patient_id = p_id; } //환자 ID 저장

int getPatientId() { return patient_id; } //환자 ID 반환

char* getPatientName() { return patient_name; } //환자 이름반환

char getSex() { return sex; } //환자 성별 반환

int getAge() { return age; } // 환자 나이 반환

char getInsurance() { return insurance; } // 환자 보험여부 반환

char getClinicPartId() { return clinic_part; } // 진료부서 반환

char* getInDate() { return in_date; } // 입원일자 반환

int getRoomNo() { return room_no; } // 입원병실 반환

char* getOutDate() { return out_date;} // 퇴원일자 반환

void setRoomNo(int room) { room_no = room; }

void SetOutDate(char date[]) { strcpy(out_date, date); }

};

// 환자 목록 클래스

class PatientList {

int max_number;

int patient_count;

Patient *patient_list; // 환자 목록의 배열

public:

PatientList() {max_number=MAX_PATIENTS; patient_count=0; patient_list = new Patient[MAX_PATIENTS];}

PatientList(int n) {max_number=n; patient_count=0; patient_list = new Patient[n];}

~PatientList() { delete[] patient_list;}

int getMaxNumber() { return max_number; }

int getPatientCount() { return patient_count; }

Patient *getPatientList() { return patient_list;}

Patient getPatient(int index) {return patient_list[index];}

void InsertPatient(Patient p);

void deletePatient(int p_index);

int findPatientByIndex(int p_id); // ID를 이용해 환자 목록 검색후 배열의 인덱스를 반환

void SortPatientList();

};

// 환자 정보 헨들링 클래스

class PatientDataHandler {

ifstream in;

ofstream out; // 파일 출력용 out을 선언

void OpenPatientFile(char *fname) {in.open(fname);}

void SavePatientFile(char *fname) {out.open(fname);}

void ClosePatientFile() {in.close();}

void CloseSavePatientFile() {out.close();}

Patient getPatientFromFile(); // 환자 정보를 파일로부터 불러온다.

public:

PatientDataHandler() {}

~PatientDataHandler() {}

int getPatientIdFromKeyboard(); // 키보드로부터 환자ID를 입력받아 반환해줌

Patient getPatientDataFromKeyboard(int p_id); // 키보드로부터 환자정보를 입력받음

void getPatientsFromFile(char *fname, PatientList *in_p_list, PatientList *out_p_list); //파일로부터 환자목록을 입력받음

void savePatientToFile(char *fname, PatientList *in_p_list, PatientList *out_p_list); // 환자 목록을 파일로 저장함

};

// 병실 정보에 연결될 환자 NODE 클래스

class PatientNode

{

int patient_id;

PatientNode * pNext; // 링크드 리스트를 위한 포인터

public:

PatientNode() {}

PatientNode(int p_id) {patient_id = p_id; pNext = NULL; }

~PatientNode() {};

int getPatientId() { return patient_id; }

PatientNode* getPatientNodepNext() { return pNext;}

void SetPatientNodepNext(PatientNode *p_pNext) { pNext = p_pNext;}

};

// 진료부서 클래스

class ClinicPart

{

char part_id; // 진료부서 코드

char part_name[MAX_LENGTH]; // 진료부서 이름

int ward_no; // 병동 인덱스

public:

ClinicPart() {part_id = 0; strcpy(part_name, “”); ward_no=0;}

ClinicPart(int p_id, char *p_name, int w_no) {part_id = p_id; strcpy(part_name, p_name); ward_no = w_no; }

~ClinicPart(){}

char getPartId() {return part_id;}

char* getPartName() {return part_name;}

int getWardNo() {return ward_no;}

};

// 진료부서 목록 클래스

class ClinicPartTable

{

int count; // 현재 진료부서의 수

ClinicPart * clinicPartTable; // 진료부서 배열

public:

ClinicPartTable();

~ClinicPartTable() { delete[] clinicPartTable; }

ClinicPart getClinicPartId(char pId); // 진료부서 코드에 해당하는 진료부서 객체를 반환하는 메소드

ClinicPart getClinicPartId(int roomNo); // 병실 번호에 해당하는 진료부서 객체를 반환하는 메소

};

// 병실 정보 클래스

class Room

{

int room_no; // 병실번호

int capacity; // 수용인원

char sex; // B:both, F:female, M:male

int count; // 현재 입원 환자 수

public:

PatientNode *p_list; // 해당 병실 입원환자 목록에 대한 포인터, 더미 노드 사용

public:

Room() { room_no=EMPTY_ROOM; capacity=0; sex=’ ‘; count=0; p_list=new PatientNode(DUMMY_P_ID); }

Room(int r_no, int r_capa, char r_sex) { room_no=r_no; capacity=r_c
apa; sex=r_sex, count=0; p_list=new PatientNode(DUMMY_P_ID); }

~Room(){}

int getRoomNo() { return room_no; }

int getCapacity() { return capacity; }

char getSex() { return sex;}

int getCount() { return count; }

PatientNode * getPatinetList() { return p_list; }

void insertPatient(PatientNode* p); // 환자 노드를 병실 정보에 삽입

int deletePatient(int p_id); // 넘겨받은 ID로 환자 정보 삭제

};

// 병실 목록 클래스

class RoomList

{

int max_number; // 최대 병실 갯수

int count; // 현재 병실의 갯수

Room *room_list; // 병실 목록의 배열

public:

RoomList() {max_number = MAX_ROOMS; count = 0; room_list = new Room[MAX_ROOMS]; };

RoomList(int n) {max_number = n; count = 0; room_list = new Room[n]; };

~RoomList(){}

int getCount() { return count;}

int getRoomIndex(int room_no);

Room * getRoom(int index) { return &room_list[index];}

void loadPatientsIntoRoom(PatientList &in_p_list); // 읽어온 환자 정보를 병실에 삽입

int findRoomIndexForCheckIn(char clinicPart_id, char sex); // 성별과 진료부서에 맞는 병실을 찾아 병동번호를 반환

void insertRoom(Room r); // 병실 정보를 삽입

};

// 병실 정보 핸들러 클래스

class RoomDataHandler

{

ifstream in;

void openRoomFile(char *fname) { in.open(fname); }

void closeRoomFile() { in.close(); }

Room getRoomFromFile(); // 파일로부터 병실 정보를 읽어온후 반환한다

public:

RoomDataHandler(){}

~RoomDataHandler(){}

int getClinicPartIdIdFromKeyboard(); // 진료부서를 키보드로부터 입력받는다.

void getRoomListFromFile(char *fname, RoomList *r_list); // 파일로부터 병실 정보를 읽어와 병실 목록을 만든다

};

// 사용자로 부터 입력받은 메뉴를 진행

class RoomListProcessor {

public :

RoomListProcessor() {};

~RoomListProcessor() {};

void checkInHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

void checkOutHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

void inquiryHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

};

// ===== Class 정의 시작======

void PatientList::InsertPatient(Patient p)

{

if(patient_count >= max_number) {

cout << “환자 정보를 저장할 공간이 부족합니다.\n” << endl;

exit(1);

}

patient_list[patient_count] = p;

patient_count++;

}

void PatientList::deletePatient(int p_index)

{

int i;

if (patient_count == 0) {

cout << “Patient List Empty!!” << endl;

return;

}

for (i = p_index; i < patient_count; i++) {

patient_list[i] = patient_list[i+1];

}

patient_count–;

}

// ID를 이용해 환자 목록 검색후 배열의 인덱스를 반환

int PatientList::findPatientByIndex(int p_id)

{

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

if(p_id == patient_list[i].getPatientId()) return i;

return NOT_FOUND;

}

// 버블 sort 알고리즘을 이용한 정렬

void PatientList::SortPatientList()

{

Patient temp; // 스왑을 위한 temp

for(int i=0; i<patient_count; i++) {

int min = i;

for(int j=i+1; j<patient_count; j++)

if(patient_list[j].getPatientId() < patient_list[min].getPatientId())

min = j;

if(min != i) {

temp = patient_list[i];

patient_list[i] = patient_list[min];

patient_list[min]= temp;

}

}

}

int PatientDataHandler::getPatientIdFromKeyboard()

{

int p_id;

cout << “\nType patient id, (quit to ” << WANT_TO_QUIT << ” )==> “;

cin >> p_id;

return p_id;

}

// 환자 정보를 키보드로부터 입력받는다

Patient PatientDataHandler::getPatientDataFromKeyboard(int p_id)

{

char name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_DATE_LEN];

char out_date[MAX_DATE_LEN];

// ID를 제외한 나머지 정보를 키보드로 부터 입력받는다.

cout << “\nType a patient name ==> “;

cin >> name;

cout << “\nType sex of patient. (F:female, M:male) ==> “;

cin >> sex;

cout << “\nType age of patient ==> “;

cin >> age;

cout << “\nType insurance. (0:미가입, 1:가입) ==> “;

cin >> insurance;

cout << “\nType a clinical part id. ==> “;

cin >> clinic_part;

get_date(in_date); // 입원일자를 현재날짜로 입력받는다.

strcpy(out_date, “”); // 퇴원일자에 “”를 넣어준다.

Patient p(p_id, name, sex, age, insurance, clinic_part, in_date, EMPTY_ROOM, out_date); // 입력받은 값으로 Patient 클래스를 생성

return p; // Patient 클래스를 반환해준다.

}

// 환자 정보를 파일로부터 저장받고 저장받은 값을 반환한다.

Patient PatientDataHandler::getPatientFromFile()

{

int id;

char name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_LENGTH];

int room_no;

char out_date[MAX_LENGTH];

if( in.eof() ) {

Patient p(EMPTY_PATIENT,”", 0, 0, 0, 0, “”, 0, “”);

return p;

}

in >> id >> name >> sex >> age >> insurance >> clinic_part >> in_date >> room_no >> out_date;

Patient p(id, name, sex, age, insurance, clinic_part, in_date, room_no, out_date);

return p;

}

// 파일로부터 읽어들인 환자 정보를 가지고 환자 목록을 만든다

void PatientDataHandler::getPatientsFromFile(char *fname, PatientList *in_p_list, PatientList *out_p_list)

{

Patient p;

OpenPatientFile(fname);

while(1) { // 파일로 부터 읽어온 환자 정보가 NULL 값을 가질때까지 반복

p = getPatientFromFile();

if (p.getPatientId() == EMPTY_PATIENT) break;

if ( strcmp(p.getOutDate(), EMPTY_DATE) == 0) in_p_list->InsertPatient(p); // 입원환자 목록을 만든다

else out_p_list->InsertPatient(p); // 퇴원환자 목록을 만든다

}

ClosePatientFile();

}

void PatientDataHandler::savePatientToFile(char *fname, PatientList *in_p_list, PatientList *out_p_list)

{

Patient p;

SavePatientFile(fname);

int i;

for (i = 0; i < in_p_list->getPatientCount(); i++) {

p = in_p_list->getPatient(i);

out << p.getPatientId() <<” “<< p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << ” ” << p.getInsurance() << ” ” << p.getClinicPartId() << ” ” << p.getInDate() << ” ” << p.getRoomNo() << ” ” << “0″ << endl;

}

for (i = 0; i < out_p_list->getPatientCount(); i++) {

p = out_p_list->getPatient(i);

out << p.getPatientId() <<” “<< p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << ” ” << p.getInsurance() << ” ” << p.getClinicPartId() << ” ” << p.getInDate() << ” ” << p.getRoomNo() << ” ” << p.getOutDate() << endl;

}

CloseSavePatientFile();

}

// 진료부서 테이블을 만든다

ClinicPartTable::ClinicPartTable()

{

cli
nicPartTable = new ClinicPart[5];

clinicPartTable[0] = ClinicPart(’A', “내과”, 61);

clinicPartTable[1] = ClinicPart(’B', “외과”, 62);

clinicPartTable[2] = ClinicPart(’C', “신경과”, 63);

clinicPartTable[3] = ClinicPart(’D', “소아과”, 64);

clinicPartTable[4] = ClinicPart(’E', “산부인과”, 65);

count = 5;

}

ClinicPart ClinicPartTable::getClinicPartId(char pId)

{

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

if(clinicPartTable[i].getPartId() == pId) return clinicPartTable[i];

return ClinicPart(NOT_FOUND, NULL, 0); // NOT_FOUND

}

ClinicPart ClinicPartTable::getClinicPartId(int roomNo)

{

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

if( clinicPartTable[i].getWardNo() == (roomNo/10) ) return clinicPartTable[i];

return ClinicPart(NOT_FOUND, NULL, 0); // NOT_FOUND

}

// 환자 노드를 연결해준다.(링크드 리스트)

void Room::insertPatient(PatientNode* p)

{

PatientNode *ptr = p_list;

// 더미 다음 Node로 연결

p->SetPatientNodepNext(ptr->getPatientNodepNext());

ptr->SetPatientNodepNext(p);

count++;

}

// 환자 노드를 삭제한다.

int Room::deletePatient(int p_id)

{

PatientNode *ptr = p_list;

PatientNode *trail;

while(ptr != NULL) {

if(ptr->getPatientId()== p_id) {

trail->SetPatientNodepNext(ptr->getPatientNodepNext());

delete ptr; // ptr 을 메모리 해제 해줌

count–; // 현재 환자수를 -1 해줌

return SUCCESS;

}

trail = ptr;

ptr = ptr->getPatientNodepNext();

}

return NOT_FOUND;

}

void RoomList::loadPatientsIntoRoom(PatientList &in_p_list)

{

int p_list_count = in_p_list.getPatientCount();

for(int i=0; i<p_list_count; i++) {

// 환자 데이터 하나 선택

Patient p = in_p_list.getPatient(i);

// 기존 입원 병실을 선택

int roomNo = p.getRoomNo();

int r_index = getRoomIndex(roomNo);

if( r_index == NOT_FOUND) {

cout << “존재하지 않는 병실 번호입니다.” << endl;

continue;

}

Room *room = getRoom(r_index);

if( room->getCount() >= room->getCapacity() ) {

cout << “입원 가능 환자수를 초과하여 ” << p.getPatientId() << “환자는 처리 할 수 없습니다.” << endl;

continue;

}

// 환자 노드 만들어서 병실에 환자 삽입

PatientNode *pNode = new PatientNode(p.getPatientId());

room->insertPatient(pNode);

}

}

int RoomList::findRoomIndexForCheckIn(char clinicPart_id, char sex)

{

ClinicPartTable clinicPartTable;

ClinicPart clinicPart;

Room room;

char r_sex;

clinicPart = clinicPartTable.getClinicPartId(clinicPart_id);

// 입원 가능한 병실을 찾는 조건 검사

for(int i=0; i<count; i++) {

room = room_list[i];

if( room.getRoomNo()/10 != clinicPart.getWardNo() ) continue;

r_sex = room.getSex();

if( r_sex != ‘B’ && r_sex != sex ) continue;

if( room.getCount() >= room.getCapacity()) continue;

return i;

}

return NOT_FOUND;

}

int RoomList::getRoomIndex(int room_no)

{

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

if(room_list[i].getRoomNo() == room_no) return i;

return NOT_FOUND;

}

void RoomList::insertRoom(Room r)

{

if( count >= max_number) {

cout << “병실 데이터를 저장할 공간이 부족합니다.\n” << endl;

exit(1);

}

room_list[count] = r;

count++;

}

Room RoomDataHandler::getRoomFromFile()

{

int room_no; // 병실번호

int capacity; // 수용인원

char sex; // B:both, F:female, M:male

Room nullRoom;

if( in.eof()) return nullRoom;

in >> room_no >> capacity >> sex;

Room r(room_no, capacity, sex);

return r;

}

void RoomDataHandler::getRoomListFromFile(char *fname, RoomList *r_list)

{

Room r;

openRoomFile(fname);

while(1) { // 병실 정보가 NULL 일때까지 반복

r = getRoomFromFile();

if( r.getRoomNo() == EMPTY_ROOM ) break;

r_list->insertRoom(r);

}

closeRoomFile();

}

int RoomDataHandler::getClinicPartIdIdFromKeyboard()

{

int r_no;

cout << “\nType Room Number, (quit to ” << WANT_TO_QUIT << ” )==> “;

cin >> r_no;

return r_no;

}

void RoomListProcessor::checkInHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

Patient p;

int p_id;

int p_index; // index for patient list

int r_index; // index for room list

PatientDataHandler pdh;

while(1) {

// 환자 코드를 받는다.

p_id = pdh.getPatientIdFromKeyboard();

// 종료를 원하면 종료

if( p_id == WANT_TO_QUIT) return ;

// 입원 환자 목록에서 p_id 에 해당하는 index 얻어 입원 환자 인지 확인

p_index = in_p_list.findPatientByIndex(p_id);

if( p_index != NOT_FOUND ) {

cout << “입원중인 환자입니다. ” << endl;

continue ;

}

// 퇴원 환자 목록에서 p_id 에 해당하는 index 얻어 기존 환자 데이터가 있는지 확인

p_index = out_p_list.findPatientByIndex(p_id);

if( p_index == NOT_FOUND )

p = pdh.getPatientDataFromKeyboard(p_id); // 새 환자 입력

else

p = out_p_list.getPatient(p_index); // existing patient

// 진료과 코드에 해당하는 병실 목록에서 입원 할 수 있는 병실의 index 찾기

r_index = room_list.findRoomIndexForCheckIn(p.getClinicPartId(), p.getSex());

if( r_index == NOT_FOUND) {

cout << “해당 진료 부서에는 입원 가능한 병실이 없습니다.”;

continue;

}

// 해당 병실에 환자 노드 삽입

Room *room = room_list.getRoom(r_index);

p.setRoomNo(room->getRoomNo());

cout << room->getRoomNo() << ” 병실에 입원” << endl;

// 입원 환자 목록에 환자 데이터 삽입

in_p_list.InsertPatient(p);

PatientNode *pNode = new PatientNode(p.getPatientId());

room->insertPatient(pNode);

}

}

// 퇴원 프로세서 미구현

void RoomListProcessor::checkOutHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

PatientDataHandler pdh;

Patient p;

int p_id;

int p_index;

int r_index;

char out_date[MAX_DATE_LEN];

while (1) {

// 환자 번호 입력

p_id = pdh.getPatientIdFromKeyboard();

// 종료를 입력했을 경우

if (p_id == WANT_TO_QUIT) return ;

// 입원 환자 목록에서 p_id에 해당하는 index를 얻어 입원 환자인지 확인

p_index = in_p_list.findPatientByIndex(p_id);

if (p_index == NOT_FOUND) {

cout << “입원중인 환자가 아닙니다.” << endl;

continue;

}

// 반환받은 환자목록 index를 가지고 환자 정보를 반환받음

p = in_p_list.getPatient(p_index);

// 퇴원일자를 현재 날짜로

get_date(out_date);

p.SetOutDate(out_date);

r_index = room_list.getRoomIndex(p.getRoomNo());

out_p_list.InsertPatient(p);

in_p_list.deletePatient(p_index);

Room *room = room_list.getRoom(r_index);

room->deletePatient(p_id);

}

//

}

// 입원환자 현황 프로세서

void RoomListProcessor::inquiryHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

Patient p;

Room *r_node;

PatientNode *p_node;

<
p>ClinicPartTable *c_temp = new ClinicPartTable();

ClinicPart c;

int r_no; // 병실번호 입력을 위한 변수

int r_index; // 병실 목록 배열을 반환받을 변수

RoomDataHandler rdh;

while (1) {

// 병실 번호 입력

r_no = rdh.getClinicPartIdIdFromKeyboard();

// 사용자가 종료를 선택했을 시

if (r_no == WANT_TO_QUIT) return ;

// 입력받은 병실번호로 배열 인덱스를 반환받는다

r_index = room_list.getRoomIndex(r_no);

// 반환받은 배열 인덱스로 입력받은 병실을 r_node에 저장한다.

r_node = room_list.getRoom(r_index);

c = c_temp->getClinicPartId(r_no);

cout << “병동 : ” << c.getWardNo() << endl;

cout << “병실번호 환자코드 환자성명 성별 나이” << endl;

// p_node에 PatientNode->pNext 값을 넣고 NULL 일때까지 반복

for (p_node = r_node->p_list->getPatientNodepNext(); p_node; p_node = p_node->getPatientNodepNext()) {

// 환자 정보를 Patient p에 대입

p = in_p_list.getPatient(in_p_list.findPatientByIndex(p_node->getPatientId()));

// 환자 정보 출력

cout << r_node->getRoomNo() << ” ” << p.getPatientId() << ” ” <<p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << endl;

}

}

}

// === 클래스 정의 부분 끝 ===

// 오늘의 날짜를 가져오는 함수

void get_date(char date[])

{

time_t timer;

struct tm *t;

timer = time(NULL); // 현재 시각을 초 단위로 얻기

t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 저장

// date에 “YYYYMMDD” 형식으로 저장

sprintf(date, “%0.4d%0.2d%0.2d”, t->tm_year+1900, t->tm_mon+1, t->tm_mday);

}

// get a menu for user

int get_menu()

{

int menu;

while(1) {

// 메뉴 출력

printf(” ***menu***\n”);

printf(”1) Check In\n”);

printf(”2) Check Out\n”);

printf(”3) Inquiry\n”);

printf(”4) Exit\n”);

// 메뉴 선택

printf(”\nMENU ==> “);

scanf(”%d”,&menu);

if(menu >= CHECK_IN && menu <= EXIT)

return menu;

// 잘못된 입력일 경우

printf(”\nInvalid menu!! Retry!!”);

}

}

int main()

{

PatientList in_p_list;

PatientList out_p_list;

RoomList room_list;

PatientDataHandler patient_data_handler;

RoomDataHandler room_data_handler;

RoomListProcessor roomListProcessor;

int menu;

patient_data_handler.getPatientsFromFile(”patient.dat”, &in_p_list, &out_p_list);

in_p_list.SortPatientList();

out_p_list.SortPatientList();

room_data_handler.getRoomListFromFile(”room.dat”, &room_list);

// 병실목록에 기존 입원 환자목록 로드

room_list.loadPatientsIntoRoom(in_p_list);

// 사용자로부터 메뉴 입력을 받는다.

while(1)

{

menu = get_menu();

if(menu == EXIT) {

patient_data_handler.savePatientToFile(”patient.dat”, &in_p_list, &out_p_list);

break;

}

switch(menu) {

case CHECK_IN:

roomListProcessor.checkInHandler(in_p_list, out_p_list, room_list);

break;

case CHECK_OUT:

roomListProcessor.checkOutHandler(in_p_list, out_p_list, room_list);

break;

case INQUIRY:

roomListProcessor.inquiryHandler(in_p_list, out_p_list, room_list);

break;

}

}

}

[/spoiler]

하지만 어제 오후 1시 30분에 시작한 수업이

아직까지 끝나지 않았다는거……

후새드.. 게다가 난 10점 만점에 8점 밖에 못 받았다는거……

 (함수 구조적인 면에서 -1점 …… 자료구조 설계 부분에서 -1점….)

오 쉣!! 9점 받은 학우들도 많고

 그 중에서는 교수님이 인정할 정도로 잘한 애들도 몇명 있었다……

도대체 난 언제쯤이면 그정도로 프로그램을 짤수 있을지……

너무 슬프다 흑흑……

짤방은 자료구조 발표중 사진…..