C++ 如何使用不同的文件使用重载构造函数初始化对象

我尝试了所有的方法来初始化构造函数，这样当我创建一个对象并传入参数时，它不会给我一个疯狂的负数，但它仍然不起作用

为了测试它是否有效，我使用了getHp和attack函数。例如，如果我说Hero Hi（100200300400），那么我说

Hi.getHP（）

，它应该是100（第一个参数）

//main.cpp
int main（）
{
英雄Me（100,20,30,40）；//使用重载构造函数创建
怪物m（100,16,18,20）；//创建怪物对象并使用重载构造函数
初始化
Hero
类中的cout
HeroHp
和
Characters
类中的
hp
是单独的变量。
Hero
的构造函数从不初始化
hp
，这是
getHp
返回的变量

您可能希望在
Hero
类中删除
HeroXXX
变量，并在
Characters
基类中使用相应的变量。
如果取消对Characters构造函数的注释：

你确定编译成功了吗？你留下了一些可能会欺骗你的警告…这是删除所有警告的一个很好的理由。
但是为什么呢？因为英雄和怪物都是“角色”，我不需要字符构造函数吗？@BigD我取消了对字符构造函数的注释，它在您的代码中被注释。是的，但我仍然没有得到预期的结果：（@BigD正如其他人已经指出的那样，您的代码中存在一些问题。基类中的变量应该受到
保护
，而不是
私有
，否则它们对子类不可见。我认为您不需要所有这些变量
MosterHp
或
HeroHp
。请将它们全部删除，因为你不需要它们，清理你的代码，避免所有的警告，你会发现，如果还有任何问题，它会更容易发现。我认为你需要类似于“英雄”的“怪物”构造函数实现，其中基类构造函数被正确调用。我尝试过，但它说字符类的变量无法访问！因为它们是私有的。请对它们进行保护，然后派生类可以访问它们。
//main.cpp
    int main()
    {
        Hero Me(100,20,30,40);//Created using overloaded constructor
        Monsters m(100,16,18,20);//creates a monster object and uses overloaded constructor
     to initialize
        cout << "\ntest1\n";
        Me.getHp();//expecting 100
        Me.getAttack();//expecting w.e is in parameters

        m.getHp();//expecting 100
        m.getAttack();//same as hero


        cin.sync();
        cin.get();
        return 0;
    }

    //Characters.h
    class Characters
    {
    private:
        int level;
        int hp;
        int attack;
        int defense;
    protected:
        Characters(); // zero everything by default
        Characters(int, int, int, int); // populate explicitly
        ~Characters();
    public:
        int getAttack() const { return attack; }
        int getDefense() const { return defense; }
        int getHp() const { return hp; }
        int getlevel() const { return level; }

        void setAttack(int);
        void setDefense(int);
        void setStrength(int);
        void setHp(int);
        void setlevel(int);
        void damageTaken(int);
    };

    //Characters.cpp
    Characters::Characters() : level(0), hp(0), attack(0), defense(0) {}
    //
    //Characters::Characters(int seed)
    //{
    //    // NB. your code still doesn't initialize hp, strength etc.
    //    // it also logs level before initializing it, so that will be garbage
    //}

    //Characters::Characters(int hit, int lvl, int att, int def)
    // : level(lvl), hp(hit), attack(att), defense(def){}

    Hero::Hero(int newHp, int newLevel, int newAttack, int newDef)
        : Characters(newHp, newLevel, newAttack, newDef)
    {
        cout << "Hero created using Overloaded function!\n";
        HeroHp = newHp;
        cout << "Hp is: "<< HeroHp << endl;
        Herolevel = newLevel;
        cout << "level is: " << Herolevel << endl;
        HeroAttack = newAttack;
        cout << "Attack is: " << HeroAttack << endl;
        HeroDefense = newDef;
        cout << "Defense is: " << HeroDefense << endl;
        // logging goes here
        // note that you don't need HeroLevel etc. at all any more, just use level
    }

    Monsters::Monsters(int newHp, int newLevel, int newAttack, int newDef)
        : MonsterHp(newHp), Monsterlevel(newLevel), MonsterAttack(newAttack)
    , MonsterDefense(newDef)//initialize list
    {
        cout << "Monster created using Overloaded function!\n";
        MonsterHp = newHp;
        cout << "Hp is: "<< MonsterHp << endl;
        Monsterlevel = newLevel;
        cout << "level is: " << Monsterlevel << endl;
        MonsterAttack = newAttack;
        cout << "Attack is: " << MonsterAttack << endl;
        MonsterDefense = newDef;
        cout << "Defense is: " << MonsterDefense << endl;
    }


    Characters::~Characters()
    {
        cout << "Character has been destroyed!\n";
    }

    void Characters::setAttack(int att)
        {
            attack = att;
        }

    void Characters::setDefense(int def)
        {
            defense = def;
        }

    void Characters::setHp(int health)
        {
            hp = health;
        }

    void Characters::damageTaken(int damage)
        {
            hp -= damage;
        }

    void Characters::setlevel(int lvl)
        {
            level = lvl;
        }

    //Monsters.h
    class Monsters:
        public Characters //Hero
    {
    private:
        int Monsterlevel;
        int MonsterHp;
        int MonsterStrength;
        int MonsterAttack;
        int MonsterDefense;
    public:
        Monsters(int, int, int, int); //explicit
        ~Monsters();
    };

    //Monsters.cpp
    Monsters::~Monsters()
    {
        cout << "\nMonster Destroyed";
    }

    //Hero.h
    class Hero:
        public Characters
    {
    private:
        int Herolevel;
        int HeroHp;
        int HeroStrength;
        int HeroAttack;
        int HeroDefense;

    public:
        //Hero();
        Hero(int, int, int, int);
        ~Hero();

    };

    //Hero.cpp
    Hero::~Hero()
    {
        cout << "Hero destroyed!\n";
    }