如何使用 OOP 运行存储在容器中的实际对象的函数？

如何使用 OOP 运行存储在容器中的实际对象的函数？

背景：我正在编写一个游戏。有 4 间相连的房间。有两种不同的房间类型和两种不同的玩家类型。玩家应该作为线程运行。杀手应该在行动室中与普通玩家进行战斗。在第二种类型的房间里，不应该发生任何事情。简化了游戏逻辑和代码。

当线程启动时，void Player::operator()()正在被执行。玩家进入房间，执行他的行动initializeAction()，然后离开它。如果发生杀手，他的initializeAction()导致room->actionInRoom(*this)，它执行player.inActionRoom().

问题出在这段代码中void Killer::inActionRoom():

std::vector<Player> &playersWithoutKillers = room->getPlayersWithoutKillers();
auto it = playersWithoutKillers.begin();
std::advance(it, 0);
Player chosenPlayerForFight = *it;
...
chosenPlayerForFight.decreasePoints();

where chosenPlayerForFight.decreasePoints();不会减少实际玩家的分数，但我认为它会减少对象的副本。

如果我运行代码，这个错误是可见的：OtherPlayer 的点数将始终重置为 1。如果我每次战斗发生时都减少它，则预期会出现负值。

-> Killer in Forth room Killer 11 vs OtherPlayer 1
Starting decreasing points from 1
Ending decreasing points from 0

我尝试修复代码，主要是通过确保传递对象的引用。

主要.cpp：

#include <iostream>
#include <memory>
#include <thread>
#include "Room.h"
#include "Player.h"

std::mutex globalMessageMutex;

int main() {

    auto first = std::make_shared<RelaxRoom>("First room");
    auto second = std::make_shared<ActionRoom>("Second room");
    auto third = std::make_shared<RelaxRoom>("Third room");
    auto forth = std::make_shared<ActionRoom>("Forth room");

    first->setRoomPair(second, forth);
    second->setRoomPair(third, first);
    third->setRoomPair(forth, second);
    forth->setRoomPair(first, third);

    std::vector<std::thread> players;

    players.emplace_back(OtherPlayer("OtherPlayer", first));
    players.emplace_back(Killer("Killer", first));

    for (auto &t : players) {
        if (t.joinable()) {
            t.join();
        }
    }

    return 0;
}

Player.h

#ifndef HW03_PLAYER_H
#define HW03_PLAYER_H

#include <string>
#include <memory>

class Room;

class Player {
    friend class Room;
public:
    Player(const std::string &playerName, std::shared_ptr<Room> initialTargetRoom);
    void operator()();
    friend bool operator== ( const Player &lhs, const Player &rhs );
    const std::string &getName() const;
    virtual void inActionRoom() {};
    virtual void inRelaxRoom(Room &pRoom) {};
    virtual bool isKiller()const;
    virtual bool isOtherPlayer();
    int getPoints()const;
    void increasePoints();
    void decreasePoints();
    int points;
protected:
    std::shared_ptr<Room> room;
    virtual void initializeAction();
private:
    std::string name;
    std::shared_ptr<Room> initialRoom;
};

class OtherPlayer : public Player {
public:
    OtherPlayer(const std::string &playerName, const std::shared_ptr<Room> &initialTargetRoom);
    void initializeAction() override;
    void inActionRoom() override;
    void inRelaxRoom(Room &pRoom) override;
    bool isOtherPlayer() override;
};


class Killer : public Player {
public:
    Killer(const std::string &playerName, const std::shared_ptr<Room> &initialTargetRoom);
    void initializeAction()  override;
    void inActionRoom() override;
    void inRelaxRoom(Room &pRoom) override;
    bool isKiller() const override;
};


#endif //HW03_PLAYER_H

播放器.cpp

#include <iostream>
#include <chrono>
#include <thread>
#include <random>
#include "Player.h"
#include "Room.h"

extern std::mutex globalMessageMutex;

Player::Player(const std::string &playerName, std::shared_ptr<Room> initialTargetRoom) {
    name = playerName;
    initialRoom = initialTargetRoom;
    room = initialTargetRoom;
    points = 1;
}

void Player::operator()() {
    room->enter(*this);
    initializeAction();
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    room->leave(*this);

    while (auto nextRoom = room->getNext()) {
        room = nextRoom;
        nextRoom->enter(*this);
        initializeAction();
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        nextRoom->leave(*this);
    }
}

void Player::initializeAction() {}

bool operator==(const Player &lhs, const Player &rhs) {
    return lhs.name == rhs.name;
}

const std::string &Player::getName() const {
    return name;
}

bool Player::isKiller() const {
    return false;
}

bool Player::isOtherPlayer() {
    return false;
}

int Player::getPoints() const {
    return points;
}

void Player::increasePoints() {
    points++;
}

void Player::decreasePoints() {
    std::cout << "Starting decreasing points from " << points << std::endl;
    points--;
    std::cout << "Ending decreasing points from " << points << std::endl;
}


OtherPlayer::OtherPlayer(const std::string &playerName, const std::shared_ptr<Room> &initialTargetRoom) : Player(playerName,
                                                                                                         initialTargetRoom) {}

void OtherPlayer::initializeAction() {
    room->actionInRoom(*this);
}

void OtherPlayer::inActionRoom() {}

void OtherPlayer::inRelaxRoom(Room &pRoom) {}

bool OtherPlayer::isOtherPlayer() {
    return true;
}


Killer::Killer(const std::string &playerName, const std::shared_ptr<Room> &initialTargetRoom) : Player(playerName,
                                                                                                         initialTargetRoom) {}

void Killer::initializeAction() {
    room->actionInRoom(*this);
}

void Killer::inActionRoom() {
    std::lock_guard<std::mutex> ml(globalMessageMutex);
    if (!room->getPlayersWithoutKillers().empty()) {

        **std::vector<Player> &playersWithoutKillers = room->getPlayersWithoutKillers();**

        **auto it = playersWithoutKillers.begin();
        std::advance(it, 0);
        Player chosenPlayerForFight = *it;**

        auto killersVitality = this->getPoints();
        auto othersPlayerPoints = chosenPlayerForFight.getPoints();

        std::cout << "-> Killer in " << room->getName() << " " << this->getName() << " " << killersVitality
                  << " vs " << chosenPlayerForFight.getName() << " " << othersPlayerPoints << std::endl;

        this->increasePoints();
        **chosenPlayerForFight.decreasePoints();**
    }
}

void Killer::inRelaxRoom(Room &pRoom) {

}

bool Killer::isKiller() const {
    return true;
}

Room.h

#ifndef HW03_ROOM_H
#define HW03_ROOM_H

#include <string>
#include <vector>
#include <condition_variable>


class Player;
class Room {

public:
    Room(const std::string &roomName);
    void setRoomPair(std::shared_ptr<Room> firstRoom, std::shared_ptr<Room> secondRoom);
    std::shared_ptr<Room> getNext();
    void enter(Player &player);
    void leave(Player &player);
    virtual void actionInRoom(Player &player)= 0;
    const std::string &getName() const;
    const std::vector<Player> &getPlayers();
    std::vector<Player> &getPlayersWithoutKillers();

protected:
    std::string name;
    size_t killersCount;
    size_t playersWithoutKillersCount;

private:
    std::vector<Player> players;
    std::vector<Player> playersWithoutKillers;
    std::condition_variable cv;
    std::mutex mutex;
    std::pair<std::shared_ptr<Room>, std::shared_ptr<Room>> roomPair;
    void updateCounterPlayerLeaves(Player &player);
    void updateCounterPlayerEnters(Player &player);
};

class ActionRoom : public Room {
public:
    ActionRoom(const std::string &roomName) : Room(roomName) {}
    void actionInRoom(Player &player) override;
};

class RelaxRoom : public Room {
public:
    RelaxRoom(const std::string &roomName) : Room(roomName) {}
    void actionInRoom(Player &player) override;
};

#endif //HW03_ROOM_H

Room.cpp

#include <iostream>
#include <algorithm>
#include <random>
#include "Room.h"
#include "Player.h"
#include <mutex>

extern std::mutex globalMessageMutex;


Room::Room(const std::string &roomName) {
    name = roomName;
}

const std::string &Room::getName() const {
    return name;
}

std::shared_ptr<Room> Room::getNext() {
    auto seed = std::chrono::high_resolution_clock::now().time_since_epoch().count();
    std::mt19937 engine(seed);
    std::uniform_int_distribution<int> randomGenerator(0, 1);
    auto randomNumber = randomGenerator(engine);
    if (randomNumber) {
        return roomPair.second;
    }
    return roomPair.first;
}

void Room::enter(Player &player) {
    std::unique_lock<std::mutex> lock(mutex);

    cv.wait(lock, [this, &player] {
                return true;
            }
    );

    players.push_back(player);

    updateCounterPlayerEnters(player);

    std::lock_guard<std::mutex> ml(globalMessageMutex);
    std::cout << name << ": killers: " << killersCount << ", other players: " << playersWithoutKillersCount <<
              std::endl;
}

void Room::updateCounterPlayerEnters(Player &player) {
    if (player.isKiller()) {
        killersCount++;
    } else {
        playersWithoutKillersCount++;
        playersWithoutKillers.push_back(player);
    }
}

void Room::leave(Player &player) {
    {
        std::lock_guard<std::mutex> lock(mutex);
        auto it = std::find(players.begin(), players.end(), player);
        if (it == players.end()) {
            return;
        }
        players.erase(it);

        updateCounterPlayerLeaves(player);
    }

    cv.notify_all();
}

void Room::updateCounterPlayerLeaves(Player &player) {
    if (player.isKiller()) {
        killersCount--;
    } else {
        playersWithoutKillersCount--;
        auto it = std::find(playersWithoutKillers.begin(), playersWithoutKillers.end(), player);
        if (it == playersWithoutKillers.end()) {
            return;
        }
        playersWithoutKillers.erase(it);
    }
}

void Room::setRoomPair(std::shared_ptr<Room> firstRoom, std::shared_ptr<Room> secondRoom) {
    roomPair.first = std::move(firstRoom);
    roomPair.second = std::move(secondRoom);
}

const std::vector<Player> &Room::getPlayers() {
    return players;
}

std::vector<Player> &Room::getPlayersWithoutKillers() {
    return playersWithoutKillers;
}

void ActionRoom::actionInRoom(Player &player) {
    player.inActionRoom();
}

void RelaxRoom::actionInRoom(Player &player) {
    player.inRelaxRoom(*this);
}

不是一个完整的答案，因为你说这是一项家庭作业。

但是，可以用来解决此问题的一种模式是让容器存储std::unique_ptr<some_base_class>值，或者如果需要的话std::shared_ptr<some_base_class>，并用指向派生对象的指针填充它们。例如：container.emplace_back(static_cast<some_base_class*>(new derived_class(foo, bar, baz)));将在容器内构建所有内容，因此编译器不需要制作任何临时副本。你也可以写一些类似的东西：

std::vector<std::unique_ptr<some_base_class>> container;

{
   std::unique_ptr<derived_class> temp =
     make_unique<derived_class>();
   temp->setup( foo, bar, baz );
   container.emplace_back(static_cast<some_base_class*>(temp.release()));
   // temp is now empty, and the pointer in the container now owns the object.
}

您可以使用完整的界面some_base_class通过这些智能指针，->，但如果您需要将它们转回对派生对象的引用，则可以使用 RTTI 和dynamic_cast.

还有其他方法，包括受歧视的工会和std::variant，但我建议您在这里尝试存储指向定义接口的基类的智能指针。