C++习题The Werewolves of Miller's Hollow

Task

实现一个简单的“狼人游戏”通知机制

Details

角色有：村民，狼人，预言家，女巫，猎人（Uninitialized只用于默认构造函数）

法官呼叫“狼人/预言家/女巫/猎人”，相应角色进行回答

法官呼叫“村民”，全体角色回答

game.cpp

#include "judge.hpp"
#include "player.hpp"
#include <cassert>
#include <iostream>
#include <string>
using std::cin;

void RunAllTests() {
Judge judge;
Player players[Judge::kMaxCountOfPlayers];
std::string name;
Player::Role role;

for (int i = 0; i < Judge::kMaxCountOfPlayers; ++i) {
switch (i) {
case 0:
case 1:
case 2: { role = Player::Villager; break; }
case 3:
case 4:
case 5: { role = Player::Werewolf; break; }
case 6: { role = Player::Seer; break; }
case 7: { role = Player::Witch; break; }
case 8: { role = Player::Hunter; break; }
default: assert(false);
}

cin >> name;
players[i].init(name, role);
judge.on(&players[i]);
}

int role_index;
cin >> role_index;
judge.call(static_cast<Player::Role>(role_index));
//static_cast是一个强制类型转换操作符。强制类型转换，也称为显式转换，C++中强制类型转换操作符有static_cast、dynamic_cast、const_cast、reinterpert_cast四个。本节介绍static_cast操作符。
}

int main() {
RunAllTests();
return 0;
}

/*
Two probable tests:
input0:

Kathy
Julie
Kenneth
Albert
William
Jack
Lisa
Carol
Harold
2

output0:

Calling: Werewolf
Albert: Shh... I am a Werewolf.
William: Shh... I am a Werewolf.
Jack: Shh... I am a Werewolf.

=========================================
input1:

Lisa
Albert
Julie
Harold
Jack
Carol
William
Kenneth
Kathy
1

output1:

Calling: Villager
Lisa: I am the villager!!
Albert: I am the villager!!
Julie: I am the villager!!
Harold: I am the villager!!
Jack: I am the villager!!
Carol: I am the villager!!
William: I am the villager!!
Kenneth: I am the villager!!
Kathy: I am the villager!!

*/

player.hpp

#ifndef PLAYER_HPP_
#define PLAYER_HPP_
#include <string>

class Player {
public:
enum Role { Uninitialized, Villager, Werewolf, Seer, Witch, Hunter };

Player();
void init(std::string name, Role role);
~Player();

Role role() const;
void answer() const;
void pretend() const;

private:
Role m_role;
std::string m_name;
};

#endif

judge.hpp

#ifndef JUDGE_HPP_
#define JUDGE_HPP_
#include "player.hpp"

class Judge {
public:
static const int kMaxCountOfPlayers = 9;

Judge();
~Judge();

void on(const Player* player);
void call(Player::Role role);

private:
const Player* m_players[kMaxCountOfPlayers];//这是一个指针数组（区别于数组指针），即本质是一个数组，数组的每
b9b1
个成员都是指针（而数组指针本质是一个指向一个数组的指针）
int m_players_count;
};

#endif

player.cpp*

#include "player.hpp"
#include "judge.hpp"
#include <iostream>
using namespace std;
Player::Player(){
}//构建函数
void Player::init(std::string name, Role role){
Player::m_name = name;
Player::m_role = role;
}
Player::~Player(){}//析构函数

Player::Role Player::role() const{
return m_role;
}//由于Judge类中的函数不能直接获取Player类中的private变量，于是通过成员方法的间接传递该值。
void Player::answer() const{
if (m_role == Villager) cout << Player::m_name<<": I am the villager!!"<< endl;
else if (m_role == Werewolf) cout << Player::m_name << ": Shh... I am a Werewolf."<< endl;
else if (m_role == Seer) cout << Player::m_name << ": Shh... I am a Seer."<< endl;
else if (m_role == Witch) cout << Player::m_name <<": Shh... I am a Witch."<< endl;
else if (m_role == Hunter) cout << Player::m_name <<": Shh... I am a Hunter."<< endl;
}
void Player::pretend() const{
cout << m_name <<": I am the villager!!"<< endl;
}

judge.cpp*

#include "player.hpp"
#include "judge.hpp"
#include <iostream>
using namespace std;

Judge::Judge(){
m_players_count = 0;
}//对数组初始下标初始化，避免越界
Judge::~Judge(){
}

void Judge::on(const Player* player){
m_players[m_players_count++] = player;//数组下标推进
}
void Judge::call(Player::Role role){
int index;
if (role == Player::Villager) {
cout << "Calling: Villager" << endl;
for (index = 0; index < kMaxCountOfPlayers; index++) {
if (m_players[index]->Player::role() == Player::Villager) m_players[index]->answer();
else m_players[index]->pretend();
}//注意是指针数组，类指针的成员要用“->”不是“.”
return;
}
else {
if (role == Player::Werewolf) cout << "Calling: Werewolf"<<endl;//输出枚举变量对应的名称的方法？
else if (role == Player::Seer) cout << "Calling: Seer" <<endl;
else if (role == Player::Witch) cout << "Calling: Witch"<<endl;
else if (role == Player::Hunter) cout << "Calling: Hunter"<<endl;
for (index = 0; index < kMaxCountOfPlayers; index++) {
if (m_players[index]->Player::role() == role) m_players[index]->answer();
}
}
}

Hint

objA.on(objB)表示将objB作为objA的监听者（事件订阅者）

知识点：

观察者模式

类与类的关系：关联

C++ enum

类静态变量

One more step

将构造函数和初始化操作（Player();和void init(std::string name, Role role);）分离出来有何优缺点？

judge.hpp中const Player*能改为const Player&吗？为什么？

enum类型Role定义在Player类的public部分有何好处？

Role为什么定义成enum类型？定义成string数组合适吗？

kMaxCountOfPlayers为什么要作为类静态变量？如果类静态变量为double类型，还能在类定义中初始化吗？