用管理器注册一个类，然后调用子类被覆盖的方法

好的，所以我有一些问题。1. 我需要能够注册的子类时，它与游戏广播创建。2. 我需要能够从GameObject指针数组中调用子类的方法。3.我需要的是真实的课程，而不是它们的副本。在文件systemvars.h中，我有我的全局方法和一些变量。

#pragma once
    //=================================
    // include guard
    #ifndef _SYSTEMVARS_H_
    #define _SYSTEMVARS_H_
//=================================
// forward declared dependencies
class Game;
//=================================
// included dependencies
#include <iostream>
using namespace std;
//global enums
const enum CLASSTYPE{CLASSTYPE_NULL,CLASSTYPE_PLAYER,CLASSTYPE_DUNGION,CLASSTYPE_ENTITY,CLASSTYPE_MAP,CLASSTYPE_MENU};
//Global methods
void setGameRefrence(Game*);
Game* getGameRefrence();

systemvars.cpp:定义

#include "SystemVars.h"
    static Game* curentgame;
    void setGameRefrence(Game* mygame)
    {
        curentgame = mygame;
    }
Game* getGameRefrence()
{
    return curentgame;
}

In my Game.h: a holder for gameobjects

#pragma once
    //=================================
    // include guard
    #ifndef _GAME_H_
    #define _GAME_H_
//=================================
// forward declared dependencies
class GameObject;
//class Player;
//=================================
// included dependencies
#include "SystemVars.h"
#include "GameObject.h"
//#include "Player.h"
#include <iostream>
using namespace std;
//=================================
// the actual class
class Game
{
public:
    Game(void);
    void registerGameObject(GameObject*);
    void unregisterGameObject(GameObject*);
    void sendMessageToAllObjects(string message,CLASSTYPE recipeint);
    ~Game(void);
private:
    GameObject *gameobjects2[1000];
    int numberofobject;
};
#endif

game.cpp游戏类定义

#include "Game.h"
    //#include "Player.h"
Game::Game(void)
{
    setGameRefrence(this);
    //logHelperMessage(INFO,1,"Registerd game");
    numberofobject = 0;
}
void Game::registerGameObject(GameObject* newobj)
{
    //logHelperMessage(INFO,1,"Registerd");
    newobj->setId(numberofobject);
    gameobjects2[numberofobject] = newobj;
    numberofobject++;
    //gameobjects.push_back(newobj);
}
void Game::unregisterGameObject(GameObject* objtodie)
{
    //logHelperMessage(INFO,1,"Unregister");
    for(int i = objtodie->getId();i < numberofobject - 1;i++)
    {
        gameobjects2[i] = gameobjects2[i+1];
        gameobjects2[i]->setId(i);
    }
    gameobjects2[numberofobject-1] = nullptr;
    numberofobject--;
}
void Game::sendMessageToAllObjects(string message,CLASSTYPE recipeint)
{
    for(int i = 0; i < numberofobject;i++)
    {
        cout << "Sent the message from game");
        //((Player *)gameobjects2[i])->sendMessage(message);
        //static_cast<Player*>(gameobjects2[i])->sendMessage(message);
    }
} 
Game::~Game(void)
{
}

Gameobject.h:我的内部游戏类的父类。

#pragma once
    //=================================
    // include guard
    #ifndef _GAMEOBJECT_H_
    #define _GAMEOBJECT_H_
//=================================
// forward declared dependencies
enum CLASSTYPE;
//=================================
// included dependencies
#include <iostream>
#include "SystemVars.h"
using namespace std;
//=================================
// the actual class
class GameObject
{
public:
    GameObject();
    GameObject(CLASSTYPE mytype);
    ~GameObject(void);
    virtual void sendMessage(string data);
    virtual CLASSTYPE getMyClassType();
    virtual void setMyClassType(CLASSTYPE newrecip);
    void setId(int val);
    int getId();
protected:
    CLASSTYPE _MYCURRENTCLASSTYPE;
    int myid;
};
#endif

Gameobject.cpp

#include "GameObject.h"
GameObject::GameObject() : _MYCURRENTCLASSTYPE(CLASSTYPE_NULL)
{
    //do not register
}
GameObject::GameObject(CLASSTYPE mytype): _MYCURRENTCLASSTYPE(mytype)
{
    //register this object into the gameobject list.
    getGameRefrence()->registerGameObject(this);
}

GameObject::~GameObject(void)
{
    getGameRefrence()->unregisterGameObject(this);
}
void GameObject::sendMessage(string data)
{
    //logHelperMessage(INFO,1,"Recived te message in GameObject");
    cout << "Recived te message in GameObject";
}
CLASSTYPE GameObject::getMyClassType()
{
    return _MYCURRENTCLASSTYPE;
}
void GameObject::setMyClassType(CLASSTYPE newrecip)
{
}
void GameObject::setId(int val)
{
    myid = val;
}
int GameObject::getId()
{
    return myid;
}

Player.h:

pragma once
    //=================================
    // include guard
    #ifndef _PLAYER_H_
    #define _PLAYER_H_
//=================================
// forward declared dependencies
//=================================
// included dependencies
#include "SystemVars.h"
#include "GameObject.h"
//=================================
// the actual class
class Player : public GameObject
{
public:
    Player();
    void sendMessage(string data) override;
    void test();
}

Player.cpp:

Player::Player() : GameObject(CLASSTYPE_PLAYER)
    {
    }
void Player::sendMessage(string data)
{
    //logHelperMessage(INFO,1,"Recived the message in Player");
    cout << "Recived the message in Player";
    //logHelperMessage(INFO,1,data.c_str());
    cout << data;
}
void Player::test()
{
cout << "Sent message";
    getGameRefrence()->sendMessageToAllObjects("Test",CLASSTYPE_PLAYER);
}

main.cpp

#pragma once
#include "SystemVars.cpp"
#include "Player.h"
#include "Game.h"
Game mygame;
int main(int argc, char **argv)
{
    setGameRefrence(&mygame);
    Player newplayer = Player();
    newplayer.test();
}

现在这些都解决了。预期输出为:

Sent message
    Sent message from game
    Recived message in Player

但是我得到:

Sent message
    Sent message from game
    Recived message in Gameobject

我很确定我有一个切片问题，但我不知道该怎么做，或者它在哪里。有什么主意吗，先生们?

同时，我试着减少一些类，所以我没有发布2000~行代码。如果少了什么，告诉我。大约有十几个类继承自gameobject。我需要他们以这样或那样的方式互相交流。