Thread: How to use functions and variables from one class in another

Originally Posted by CH1156

I have the DrawMap() Function, in that function I need to set the player start position but since the player is not part of game class, I cannot use the function from the player class in the game class functions.

In the context of the DrawMap member function of the Game class, you can freely use public member functions of the Player class for a given Player object, e.g., perhaps you could call the SetPlayerOnMap member function of the Player class.

However, it is not clear to me how you would implement SetPlayerOnMap: the member function takes no arguments, the Player object does not store a pointer or reference to a Game object, so it seems that SetPlayerOnMap has no way to actually set the player on the map that is within the Game object.

By the way, one thing to consider is the idea of layers of components. For example, your Player object presently both models a Player and also performs interactive I/O with the user in CheckScreenBounds, i.e., it has logic to move the player on the map and write the result to standard output, and then does things like warn the user about exceeding the map boundaries. This should actually be separated into two components, e.g., a Player object that models a Player object such that you can change its position on the map, retrieve its map coordinates, etc. Then you can say, have a library of functions that operate on Player objects, and within this library you can then implement CheckScreenBounds to work with standard I/O, or perhaps you might have another library with a version of CheckScreenBounds that works with a graphical user interface because you want another version of this game that is GUI-based, reusing the same underlying Player object.

"In the context of the DrawMap member function of the Game class, you can freely use public member functions of the Player class for a given Player object, e.g., perhaps you could call the SetPlayerOnMap member function of the Player class."


So like this?

Code:

void Game::DrawMap()
{
        for(int col = 0; col < mapColSize; col++)
        {
            for(int row = 0; row < mapRowSize; row++)
            {
                mapArray[col][row] = mapGrid;
                Player::SetPlayerOnMap();
                cout << mapArray[col][row];
            }
            cout << endl;
        }
}

It says cant do it without a player object, but when i create one it gives me more errors.

||=== Build: Debug in double vector map (compiler: GNU GCC Compiler) ===|
C:\Users\thund\Desktop\double vector map\main.cpp||In function 'int main()':|
C:\Users\thund\Desktop\double vector map\main.cpp|23|warning: unused variable 'rockObstacle' [-Wunused-variable]|
obj\Debug\src\Game.o||In function `ZN4Game7DrawMapEv':|
C:\Users\thund\Desktop\double vector map\src\Game.cpp|24|undefined reference to `Player::SetPlayerOnMap()'|
||error: ld returned 1 exit status|
||=== Build failed: 2 error(s), 1 warning(s) (0 minute(s), 0 second(s)) ===|

Ok so i made a simpler example of the problem, So I have this code:

Code:

#include <iostream>

using namespace std;


class A
{
    public:
        A() = default;
        ~A() = default;


        int AddX();


    private:
        int x = 10;
};






int A::AddX()
{
    return x;
}




class B
{
    public:
        B() = default;
        ~B() = default;


        int AddY();
        int SumXY();


    private:
        int y = 35;
};






int B::AddY()
{
    return y;
}






int B::SumXY()
{
    A a;


    int sum = AddY() + a.AddX();


    return sum;
}


int main()
{
    B b;


    cout << b.SumXY();
    return 0;
}

It works, but is there a cleaner way of creating an object instead of doing it like that in every function? also to achieve that I have to have getters and setters for almost every variable which is bad practice.

You need to think about the relationships between the classes. Does a Game contain a Player? Does a Player play a Game, but could possibly play another Game?

If a Game contains a Player, then perhaps you would have a Player object be a member variable of Game. Then, in order to access Game from within Player member functions, perhaps Player could store a pointer to the Game object that owns the Player object. This could be passed as an argument in the Player constructor.

If a Player could play multiple Games, then perhaps it would be the opposite: a vector of Game objects might be a member variable of Game, or if it is a multiplayer Game, then maybe a vector of pointers to Game objects. Each Game object could also store a pointer to the corresponding Player object.

Originally Posted by CH1156

Ok, but if im going to make a player object a member of game, then why do i need to make a pointer to game from player? cant I just make a game object in player?

You can't do that. It's like saying that your lungs are part of your body, so why can't your body be part of your lungs? If it were at all possible to make a game object in player, then it means that each Game object contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains a Game object which contains a Player object which contains...

Okay, I'll stop here, but it actually goes on and on and on until the entire multiverse and beyond is consumed by your program. Hence, you need a way to refer to the Game object from within the Player object without actually storing the entire Game object within the Player object, and one way is to store a pointer to the Game object. If a Player object might deal with different Game objects, then passing a Game object (by reference) as an argument to the desired member function of Player could work too.

I would expect something like this instead:

Code:

class Game;

class Player
{
public:
    explicit Player(Game* game) : game(game) {}
private:
    int plr_XPos = 0;
    int plr_YPos = 0;
    Game* game;
};

class Game
{
public:
    Game() : player(this) {}
private:
    char gme_mapArray[10][10];
    Player player;
};

int main()
{
    Game game;
    return 0;
}

A forward declaration of the Game class is enough to declare a member variable of type Game* in the Player class definition. A forward declaration of the Player class would not be enough to declare a member variable of type Player in the Game class. That's why I forward declare Game, define Player, and then define Game.

Just an idea.
why not just put a player inside of the game itself? or make it so that if you are having players, and you come to a point whereas you create more player types, the constructor for the player itself is included inside of the game class so when that gets created it can ask how many players wanted, and the default would be one or two depending on what type of game it is. This way when ever starting the game that game class will always be creating the basic amount of players needed to play that game.

just a question.
Furthermore, wouldn't you only being needing one game class, and one player class, whereas the player class has its members to describe each players characteristics within the private part of the class? Then functions to give them characteristics substance?

Code:

class Player{
private:
char *name
char *hair_color;
int hair_length:
public:
void setHairColor(char *clr);
void setHairLength(int ln);
void setName(char *name);
char *getHairColor();
int getHairLength();
char *getName();
};

just set its properties for each separate player using just one class called player.

next, is the player interacting with the game, or is the game interacting with the player?

does a tree ( inanimate object ) interact with you, or do you interact with the (inanimate object) tree ? line of thought.

then write your functions that give it (as a whole) that functionality to show that process.

just a thought.
Ever read up on abstract and concrete classes?

as laserLight is basically trying to express to you as well. as far as her post #7 if you create one then you'll get put into a growing loop of same objects. so do correct my line of thought if wrong, but

and this is abstract writing of this so do not use it, but maybe the idea will be able to be used.

Code:

class player{
private:
arm
eyes
legs
feet
name
public:
functions to set them properties
and other needed functions
};

class Game{
private:
whatever is needed in here:
public:

creator for game class

a means to call to
create a player or two, and
another function that
asks how many players
if a multi player game more than 2
then provides a means
to call the creator for the class player, 
and funny enough to set its properties as well?

is that a friend ? 
};

then everything would have to be done through the game class to change the game items as well as the players within the game class?

I do not know, it is defiantly needed to be thought about.

the players, will they have a means to talk to the game, or is that game going to be talking to the players?

how to make the players aware of the items within the game?

how to make the players have an ability to manipulate same said
items?

how would you make that inanimate object within the game aware of a player if said player comes close to it?

that is if this is an animated game.

if it is just a game where a player can kick a bucket, then you have to do the math for force applied to the kick at point of contact then get distance that the bucket traveled, next player to see who can kick the bucket furthest.

it still has the same basics to it.