如何独立于C ++中的声明位置使用另一个类函数中的类？

Question

I'm trying to create a Monopoly game in C++ and I've been messing with object-oriented-programming, the problem happens with the classes "Game" and "Player", I would like to know how to use "Game"'s functions inside "Player" and "Player"'s functions inside "Game", but I've been getting a compiler error saying that the class is not defined.

Switching class positions won't work (obviously) but I tried anyways.

Code (reduced and minimized to the Game and Player classes):

    namespace Monopoly {
typedef enum { normal, train, company, incometax, luxurytax, start, chancecard, chestcard, jail } type;
class Game {
private:
    bool running = false;
    int turn = 1;
    int currentPlayerID;
    int startingMoney = 1000;
    std::vector<Player> players;
public:
    // Functions
    void createPlayer() {
        ++currentPlayerID;
        Player newPlayer(currentPlayerID, startingMoney);
        players.push_back(newPlayer);
        ++currentPlayerID;
    }
    void createPlayers(int playerAmount) {
        for (int i = 0; i <= playerAmount; ++i) {
            createPlayer();
        }
    }
    Player getPlayer(int index) {
        Player p = players[index];
        return p;
    }
};
class Player {
private:
    int playerID;
    int money;
    std::vector<int> propertiesOwned;
    void addProperty(int id) {
        this->propertiesOwned.push_back(id);
    }
public:
    // Constructor
    Player(int pID, int sMoney) {
        this->playerID = pID;
        this->money = sMoney;
    }

    // Functions
    Player payMoney(int payAmount, unsigned int destinationID, Game engine) {
        this->money -= payAmount;
        if (destinationID > 0) {
            // Checks if you're paying to a player or bank
            bool playerFound = false;
            for (int i = 0; i <= engine.getPlayerAmount(); ++i) {
                if (engine.getPlayer(i).getID() == destinationID) {
                    playerFound = true;
                    break;
                }
            }
            if (playerFound) {
                // Player was found
                engine.getPlayer(destinationID).giveMoney(payAmount);
                return;
            }
            else {
                std::cout << "\nERROR: Invalid player ID at function payMoney\n";
                return;
            }

        }
        else {
            // You're paying to the bank
        }
        return;
    }
    void buyProperty(int id, int price, Game engine) {
        payMoney(price, 0, engine);
        addProperty(id);
    }
    void giveMoney(int payMoney) {
        this->money += payMoney;
    }

    // Returns
    inline int getMoney() { return this->money; }
    inline int getID() { return this->playerID; }
    inline auto getProperties(int index) {
        auto p = propertiesOwned[index];
        return p;
    }
    inline int getPropertyAmount() {
        int amount = std::size(propertiesOwned);
        return amount;
    }
};
}

I expected the classes to run the other classes function normally, but it seens like that in C++, classes are defined in certain order, and you can only access classes (in a class) declared before the class you're using, feedback and alternatives that fix this would help

Answer 1

You are correct that in C++ declaration order matters, and that is the cause of your errors, however there are a few other issues with the code.

Firstly, you should swap the order that Game and Player are defined. This will make it easier, as Player relies on Game fewer times than Game relies on Player .

Next, add a forward declaration for Game before the definition of Player :

class Game;

This tells the compiler that a class named Game exists and allows you to use it in scenarios where it doesn't need to know the contents (ie definition) of the class.

Next, make payMoney and buyProperty accept their engine parameter by reference instead of by value by changing the parameter specifier to Game &engine . This is important for two reasons. First, passing by value can only be done if you have already defined the type, which we have not (we've only declared it). Second, passing by value creates a copy of the object, which in this case means a completely new vector of completely new Player objects, and the changes will not synchronize back to the old object. See here for a better explanation of references.

Next, you need to extract the definition of payMoney to after the definition of Game . The reason is that while the parameter list of payMoney no longer relies on the definition of Game , the code in the function body does (because it calls functions on the engine object). See the end for what this looks like.

This fixes all the problems with declaration/definition order. You also should make payMoney return void as its return value is never provided and never used, pick a consistent type for IDs (either int or unsigned int , not a mix), and add the getPlayerAmount to Game .

Here's what the final code could look like:

namespace Monopoly {
    typedef enum { normal, train, company, incometax, luxurytax, start, chancecard, chestcard, jail } type;

    class Game;

    class Player {
    private:
        int playerID;
        int money;
        std::vector<int> propertiesOwned;
        void addProperty(int id) {
            this->propertiesOwned.push_back(id);
        }
    public:
        // Constructor
        Player(int pID, int sMoney) {
            this->playerID = pID;
            this->money = sMoney;
        }

        // Functions
        void payMoney(int payAmount, int destinationID, Game &engine);
        void buyProperty(int id, int price, Game &engine) {
            payMoney(price, 0, engine);
            addProperty(id);
        }
        void giveMoney(int payMoney) {
            this->money += payMoney;
        }

        // Returns
        inline int getMoney() { return this->money; }
        inline int getID() { return this->playerID; }
        inline auto getProperties(int index) {
            auto p = propertiesOwned[index];
            return p;
        }
        inline int getPropertyAmount() {
            int amount = std::size(propertiesOwned);
            return amount;
        }
    };

    class Game {
    private:
        bool running = false;
        int turn = 1;
        int currentPlayerID;
        int startingMoney = 1000;
        std::vector<Player> players;
    public:
        // Functions
        void createPlayer() {
            ++currentPlayerID;
            Player newPlayer(currentPlayerID, startingMoney);
            players.push_back(newPlayer);
            ++currentPlayerID;
        }
        void createPlayers(int playerAmount) {
            for (int i = 0; i <= playerAmount; ++i) {
                createPlayer();
            }
        }
        Player getPlayer(int index) {
            Player p = players[index];
            return p;
        }
        int getPlayerAmount() {
            int amount = players.size();
            return amount;
        }
    };

    void Player::payMoney(int payAmount, int destinationID, Game &engine) {
        this->money -= payAmount;
        if (destinationID > 0) {
            // Checks if you're paying to a player or bank
            bool playerFound = false;
            for (int i = 0; i <= engine.getPlayerAmount(); ++i) {
                if (engine.getPlayer(i).getID() == destinationID) {
                    playerFound = true;
                    break;
                }
            }
            if (playerFound) {
                // Player was found
                engine.getPlayer(destinationID).giveMoney(payAmount);
                return;
            }
            else {
                std::cout << "\nERROR: Invalid player ID at function payMoney\n";
                return;
            }

        }
        else {
            // You're paying to the bank
        }
        return;
    }
}

Side note: it's technically better C++ to use size_t instead of int for variables storing the size of vectors, as that is what the size functions return (and it's an unsigned integer type whereas int is signed), but that's not especially important.