c++版模拟银行窗口排队叫号系统

c++版模拟银行窗口排队叫号系统

c++版模拟银行窗口排队叫号系统

看了两位LZ的银行排队系统blog，感觉不错，就也产生了用C++写个排号系统，原因有二，1、对Java不太熟悉，没有看太懂。2、练练手。3、提高一下C++的人气。

进入主题：

对于这一块的业务系统需求没有做过多的分析，只在两位LZ的基础做了小小的改动，然后用C++实现。

题目：

模拟实现银行业务调度系统逻辑，具体需求如下：

银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP 窗口。

有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

异步随机生成各种类型的客户，生成各类型用户的概率比例为：

VIP客户：普通客户：快速客户= 1 ：6 ：3。

客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。

各类型客户在其对应窗口按顺序依次办理业务。

当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。

不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

修改：1、在这里为了简化程序的设计（只省了只行代码），FAST和VIP窗口只办理对应的客户，不办普通客户的业务。

2、由于对于客户的到来，也采用1S来一个的做法，但因为在console程序对于时间不太好控制，在这里只是设定了客户数，即每个1秒来一个客户，根据来的客户数控制时间。

开发环境:Linux

代码：

文件constances.h

该文件中定义了一些常量，其中MAX_WAITING_CLIENT_NUM指的是，最多正在等待的客户数，如果客户数到达最大，后来的客户将会离开。

[cpp]view plaincopy

1.#ifndef CONSTANCES_H_

2.#define CONSTANCES_H_

3.enum {

4. MAX_SERVICE_TIME = 10,

5. MIN_SERVICE_TIME = 1,

6. CLIENT_INTERVAL_TIME = 1,

7. MAX_WAITING_CLIENT_NUM = 50,

8. MAX_CLIENT_NUM = 100,

9.};

10.#endif /* CONSTANCES_H_ */

文件main.cpp

1、每一个窗口对应一个线程，在此创建了6个线程，分别对应4个客户窗口，1个FAST 窗口中，1个VIP窗口中。

2、在这里本想用Unix中的alarm信号来控制客户的间隔时间，但因为时间不好控制就废弃了

[cpp]view plaincopy

1.#include

2.#include

3.#include

4.#include

5.#include

6.#include

7.#include "numMachine.h"

8.#include "serviceWin.h"

9.#include "client.h"

10.#include "constances.h"

11.Client::ClientType createClientType() {

12.int type;

13. type = rand() % 10 + 1;

14.if (type <= 6)

15.return Client::CLIENT_COMMON;

16.else if (type >= 7 && type <= 9)

17.return Client::CLIENT_FAST;

18.return Client::CLIENT_VIP;

19.}

20.int createTasktime() {

21.return rand() % MAX_SERVICE_TIME + 1;

22.}

23.void createClient() {

24. Client::ClientType clientType;

25.int taskTime;

26.for (int i = 0; i < MAX_CLIENT_NUM; ++i) {

27. clientType = createClientType();

28. taskTime = createTasktime();

29. std::cout << "Come in a client : clientType = " << clientType

30. << " taskTime = " << taskTime << std::endl;

31. NumMachine::getInstance()->pressMachine(clientType, taskTime);

32. sleep(1);

33. }

34. sleep(5);

35.}

36.void * serviceWin(void *win) {

37. ServiceWin *serWin = static_cast (win);

38. serWin->execute();

39.return ((void *) 0);

40.}

41.bool createServiceWin() {

42. pthread_t commonServiceWin[4];

43. pthread_t fastServiceWin;

44. pthread_t vipServiceWin;

45.char tmp[10];

46. ServiceWin *win;

47.for (int i = 0; i < 4; ++i) {

48. sprintf(tmp, "CommonWin%d", i);

49. win = new CommonSerWin(tmp);

50.if (win == NULL) {

51. std::cout << "Create common service win error." << std::endl;

52.return -1;

53. }

54.if (pthread_create(&commonServiceWin[i], NULL, serviceWin, (void*) w

in)

55. != 0) {

56. std::cout << "Create common service thread error." << std::endl;

57.return false;

58. }

59. }

60. sprintf(tmp, "FastWin");

61. win = new FastSerWin(tmp);

62.if (win == NULL) {

63. std::cout << "Create fast service win error." << std::endl;

64.return false;

65. }

66.if (pthread_create(&fastServiceWin, NULL, serviceWin, (void*) win) != 0)

{

67. std::cout << "Create fast service thread error." << std::endl;

68.return false;

69. }

70. sprintf(tmp, "VipWin");

71. win = new VipSerWin(tmp);

72.if (win == NULL) {

73. std::cout << "Create vip service win error." << std::endl;

74.return false;

75. }

76.if (pthread_create(&fastServiceWin, NULL, serviceWin, (void*) win) != 0)

{

77. std::cout << "Create vip service thread error." << std::endl;

78.return false;

79. }

80.return true;

81.}

82.int main(int argc, char *argv[]) {

83. std::cout << "/***start : please wait 5 seconds when progress suspend **

***/" << std::endl;

84. srand((unsigned) time(0));

85.if (!createServiceWin()) {

86. std::cout << "Create service win error." << std::endl;

87.return -1;

88. }

89. createClient();

90.delete NumMachine::getInstance();

91.}

文件client.cpp client.h

定义了我们的客户，因为我们的客户比较简单，所有的客户共享一个class，只是clientType 来区分不同的客户。

[cpp]view plaincopy

1.#ifndef CLIENT_H_

2.#define CLIENT_H_

3.class Client {

4.public:

5.enum ClientType {

6. CLIENT_COMMON, CLIENT_FAST, CLIENT_VIP

7. };

8. Client(ClientType type, int time);

9.virtual ~Client();

10. ClientType getClientType();

11.int getServiceTime();

12.private:

13. ClientType clientType;

14.int serviceTime;

15.};

16.#endif /* CLIENT_H_ */

[c-sharp]view plaincopy

1.#include "client.h"

2.Client::Client(ClientType type, int time) :

3. clientType(type), serviceTime(time) {

4.}

5.Client::~Client() {

6.}

7.Client::ClientType Client::getClientType() {

8.return clientType;

9.}

10.int Client::getServiceTime() {

11.return serviceTime;

12.}

文件numMachine.cpp numMachine.h

文件中定义了排号机，在numMachine中定义了一个client list用来存放我们的客户。[cpp]view plaincopy

1.#ifndef NUMMACHINE_H_

2.#define NUMMACHINE_H_

3.#include

4.#include

5.#include

6.#include

7.#include

8.#include "client.h"

9.#include "constances.h"

10.class NumMachine {

11.public:

12.virtual ~NumMachine();

13.static NumMachine *getInstance();

14.void pressMachine(Client::ClientType clientType, int tasktime);

15. Client * removeClient(Client::ClientType val);

16.private:

17. NumMachine();

18.static NumMachine *numMachine;

19. std::list clientList;

20.int leaveClient;

21.int total;

22.int handledClient;

23. pthread_mutex_t clientListLock;

24.};

25.class DelClientList {

26.public:

27.void operator () (Client * item);

28.};

29.class FindClient {

30.public:

31. FindClient(Client::ClientType t);

32.bool operator () (Client * item);

33.private:

34. Client::ClientType clientType;

35.};

36.#endif /* NUMMACHINE_H_ */

[cpp]view plaincopy

1.#include "numMachine.h"

2./***************************************************************************

************/

3.NumMachine * NumMachine::numMachine = new NumMachine;

4.NumMachine::NumMachine() :

5. leaveClient(0), total(0), handledClient(0) {

6. pthread_mutex_init(&clientListLock, NULL);

7.}

8.NumMachine::~NumMachine() {

9. std::cout << "/********** end ****************/" << std::end

l;

10. std::cout << "The number of total client is " << total << std::endl;

11. std::cout << "The number of handled client is " << handledClient << std:

:endl;

12. std::cout << "The number of waiting client is " << clientList.size() <<

std::endl;

13. std::cout << "The number of client is " << leaveClient

14. << " ,because waiting time too long." << std::endl;

15. for_each(clientList.begin(), clientList.end(), DelClientList());

16.}

17.NumMachine * NumMachine::getInstance() {

18.return numMachine;

19.}

20.void NumMachine::pressMachine(Client::ClientType clientType, int taskTime) {

21. ++total;

22.if (clientList.size() < MAX_WAITING_CLIENT_NUM) {

23. Client * c = new Client(clientType, taskTime);

24.if (c == NULL) {

25. std::cout << "Can't create Client" << std::endl;

26. exit(-1);

27. }

28. clientList.push_back(c);

29. } else {

30. ++leaveClient;

31. }

32.}

33.Client * NumMachine::removeClient(Client::ClientType val) {

34. std::list::iterator pos;

35. Client *tmp;

36. pthread_mutex_lock(&clientListLock);

37. pos = find_if(clientList.begin(), clientList.end(), FindClient(val));

38. tmp = *pos;

39.if (pos != clientList.end()) {

40. clientList.erase(pos);

41. ++handledClient;

42. pthread_mutex_unlock(&clientListLock);

43.return tmp;

44. } else {

45. pthread_mutex_unlock(&clientListLock);

46.return NULL;

47. }

48.}

49./***************************************************************************

************/

50.void DelClientList::operator ()(Client *item) {

51. std::cout << "Waiting client : clientType =" << item->getClientType()

52. << " taskTime = " << item->getServiceTime() << std::endl;

53.delete item;

54.}

55./***************************************************************************

************/

56.FindClient::FindClient(Client::ClientType t) :

57. clientType(t) {

58.}

59.bool FindClient::operator ()(Client * item) {

60.if (item->getClientType() == clientType)

61.return true;

62.else

63.return false;

64.}

文件serviceWin.cpp serviceWin.h

文件中定义了我们窗口。

[cpp]view plaincopy

1.#ifndef SERVICEWIN_H_

2.#define SERVICEWIN_H_

3.#include

4.#include

5.#include "numMachine.h"

6.class ServiceWin {

7.public:

8. ServiceWin(std::string n);

9.virtual ~ServiceWin();

10.virtual void execute() = 0;

11. std::string getWinName();

12.private:

13. std::string winName;

14.};

15.class CommonSerWin: public ServiceWin {

16.public:

17. CommonSerWin(std::string n);

18.virtual ~CommonSerWin();

19.virtual void execute();

20.};

21.class FastSerWin: public ServiceWin {

22.public:

23. FastSerWin(std::string n);

24.virtual ~FastSerWin();

25.virtual void execute();

26.};

27.class VipSerWin: public ServiceWin {

28.public:

29. VipSerWin(std::string n);

30.virtual ~VipSerWin();

31.virtual void execute();

32.};

33.#endif /* SERVICEWIN_H_ */

[cpp]view plaincopy

1.#include "serviceWin.h"

2./***************************************************************************

******************/

3.ServiceWin::ServiceWin(std::string n) :

4. winName(n) {

5.}

6.ServiceWin::~ServiceWin() {

7.}

8.std::string ServiceWin::getWinName() {

9.return winName;

10.}

11./***************************************************************************

******************/

https://www.360docs.net/doc/d811857555.html,monSerWin::CommonSerWin(std::string n) :

13. ServiceWin(n) {

14.}

https://www.360docs.net/doc/d811857555.html,monSerWin::~CommonSerWin() {

16.}

17.void CommonSerWin::execute() {

18. Client * client = NULL;

19.while (1) {

20. client = NumMachine::getInstance()->removeClient(Client::CLIENT_COMM

ON);

21.if (client != NULL) {

tClientType()

23. << " taskTime = " << client->getServiceTime() << " "<< g

etWinName() << std::endl;

24. sleep(client->getServiceTime());

25.delete client;

26. }

27. }

28.}

29./***************************************************************************

******************/

30.FastSerWin::FastSerWin(std::string n) :

31. ServiceWin(n) {

32.}

33.FastSerWin::~FastSerWin() {

34.}

35.void FastSerWin::execute() {

36. Client * client = NULL;

37.while (1) {

38. client = NumMachine::getInstance()->removeClient(Client::CLIENT_FAST

);

39.if (client != NULL) {

40. std::cout << "A client be handled : clientType = " << client->ge

tClientType()

41. << " taskTime = " << client->getServiceTime() << " "<< g

etWinName() << std::endl;

42. sleep(client->getServiceTime());

43.delete client;

44. }

45. }

46.}

47./***************************************************************************

******************/

48.VipSerWin::VipSerWin(std::string n) :

49. ServiceWin(n) {

50.}

51.VipSerWin::~VipSerWin() {

52.}

53.void VipSerWin::execute() {

54. Client * client = NULL;

55.while (1) {

56. client = NumMachine::getInstance()->removeClient(Client::CLIENT_VIP)

;

57.if (client != NULL) {

tClientType()

59. << " taskTime = " << client->getServiceTime() << " "<< g

etWinName() << std::endl;

60. sleep(client->getServiceTime());

61.delete client;

62. }

63. }

64.}

结论：

经过几次测试发现在上述条件下，FAST窗口办理业务不能满足需求，在客户不在来的后5秒内，不能处理完FAST客户。