Anfängerfrage: Zugriff auf Klassenobjekt aus mehreren Klassen

[AoC]

Hallo zusammen,

ich habe in meiner main Funktion ein Objekt meiner Klasse Player erstellt:

Game.cpp

int main(int argc, char *argv[])
{
    Monster monster; //erstelle Objekt von Monster
    Player player;   //erstelle Objekt von Player

    [...]
    player.createPlayer(pchooseClass);
    [...]
}

Soweit alles kein Problem, meine Player Klasse sieht wie folgt aus:

Player.h

#ifndef PLAYER_H
#define PLAYER_H
#include <string>

class Player
{
  public:                          
    Player();                      // der Default-Konstruktor
    Player(std::string chooseClass);       // weiterer Konstruktor mit Parameter
    ~Player();                     // der Destruktor

    std::string playerClass;
    std::string playerName;
    //Alle Attribute sind Standartmäßig auf 0 gesetzt und werden erst bei der Klassenwahl vergeben.
    int playerStrength;
    int playerIntellegence;
    int playerHP;
    int playerMP;
    int playerStamina;

    void createPlayer(std::string chooseClass);
    void ausgabePlayerAttribute();

};
#endif

Player.cpp

#include "Player.h"
#include <cstdlib>
#include <iostream>
#include <string>

Player::Player(){}
Player::Player(std::string chooseClass){}
Player::~Player(){}

void Player::createPlayer(std::string chooseClass){
     if (chooseClass == "1"  || chooseClass == "Eins" || chooseClass == "eins" || chooseClass == "Magier" || chooseClass == "magier"){ //wenn Eingabe 1 ODER Eins ODER eins ODER Magier ODER magier ist dann:
           //setze Attribute
           playerStrength = 2;            
           playerIntellegence = 8;
           playerHP = 70;
           playerMP = 130;
           playerStamina = 5;
           //setze Klasse
           playerClass = "Magier";

           }
        else if (chooseClass == "2"  || chooseClass == "Zwei" || chooseClass == "zwei" || chooseClass == "Krieger" || chooseClass == "krieger"){
           //setze Attribute
           playerStrength = 8;            
           playerIntellegence = 1;
           playerHP = 180;
           playerMP = 20;
           playerStamina = 6;
           //setze Klasse
           playerClass = "Krieger";

           }
        else if (chooseClass == "3" || chooseClass == "Drei" || chooseClass == "drei" || chooseClass == "Archer" || chooseClass == "archer"){
           //setze Attribute
           playerStrength = 6;            
           playerIntellegence = 6;
           playerHP = 120;
           playerMP = 80;
           playerStamina = 8;
           //setze Klasse
           playerClass = "Archer";

           }
        else {
             std::cout << "Da ist etwas schief gelaufen, es konnte keine Klasse erstellt werden!" << std::endl;
             }
     }

void Player::ausgabePlayerAttribute() {
     std::cout << "Ein maechtiger " << playerClass << " also. Ihr verfuegt ueber die folgenden Werte:" << std::endl;
     std::cout << "Staerke: " << playerStrength << std::endl;
     std::cout << "Intelligenz: " << playerIntellegence << std::endl;
     std::cout << "Ausdauer: " << playerStamina << std::endl;
     std::cout << "Lebenspunkte: " << playerHP << std::endl;
     std::cout << "Manapunkte: " << playerMP << std::endl;
     }

Mein Problem ist, ich möchte nun die Variablen vom Objekt player in einer anderen Klasse weiter verarbeiten. Nämlich um eine Aktion auszuführen

Action.h

#ifndef ACTION_H
#define ACTION_H
#include <string>

class Action
{
  public:                          
    Action();                      // der Default-Konstruktor
    Action(int chooseAction);       // weiterer Konstruktor mit Parameter
    ~Action();                     // der Destruktor

    void useAction(int chooseAction);

};
#endif

Action.cpp

#include <cstdlib>
#include <iostream>
#include "Action.h"
#include "Player.h"
#include "Monster.h"

Action::Action(){}
Action::Action(int chooseAction){}
Action::~Action(){}

void Action::useAction(int chooseAction){
     Player player;
     Monster m;     
     int stamina = 0;
     stamina = player.playerStamina;
     int playerMP = 0;
     playerMP = player.playerMP;
     double damage = 0;

     if (chooseAction == 1){ //Kämpfen
        if (player.playerStrength > player.playerIntellegence || player.playerStrength == player.playerIntellegence){
            damage = player.playerStrength * stamina;
            stamina = stamina - 1;
            std::cout << "Du machst: " << damage << " Schaden." << std::endl;
            }
        else if (player.playerIntellegence > player.playerStrength){
            damage = player.playerIntellegence * player.playerMP;
            playerMP = damage / player.stamina;  
            std::cout << "Du machst: " << damage << " Schaden." << std::endl;
            }
        else {
             std::cout << "Das hat nicht funktioniert!" << std::endl;
             }                  
          }
     else if (chooseAction == 2){ //Info

          }
     else if (chooseAction == 3){ //Laufen

          }
     else if (chooseAction == 4){//Warten

          }
     else {
          std::cout << "Etwas ist schiefgelaufen! Es konnte keine Aktion ausgeführt werden!" << std::endl;
          }

     }

Ich bin mir recht sicher, dass ich in Action.cpp ein neues Objekt player von Player erzeuge, ich möchte allerdings auf das Ursprüngliche zugreifen, welches ich in meiner main erstellt habe. Könnte mir jemand helfen?

//Offtopic: Sollte ich für solche Fragen wie jetzt einen neuen Thread erstellen, oder weiter in meinem alten posten, welcher damit aber nichts mehr zu tun hat?

[Th69]

Dann übergib den Player als (konstante) Referenz:

Action(int chooseAction, Player &player);
// oder
Action(int chooseAction, const Player &player); // wenn nur lesend auf Player zugegriffen wird

PS: Ich finde es kein gutes Design, die Spieler-Attribute als öffentliche Member zu deklarieren (denn diese setzt du ja schon in 'createPlayer' - außerdem ist m.E sogar diese Funktion überflüssig und sollte direkt durch einen Konstruktor ersetzt werden).

[DocShoe]

Oder jede Charakterklasse als eigene Charakterklasse implementieren, die von einer Basisklasse erbt. Dann müssen Krieger keine überflüssigen MagicPoints mit sich rumschleppen