Question

编辑：很难用英语解释自己，所以我会尝试使用'Sample'代码。

class Character {
    public:
        Character(void); //constructor
        int     getAttack(void) const; // return this->_attack;
        int     getDef(void) const; // return this->_def;
        int     getSpeed(void) const; // return this->_speed;
        void    setAttack(int val); //this->_attack = val;
        void    setDef(int val); //this->_def = val;
        void    setSpeed(int val); //this->_speed = val;

    private:
        int     _attack;
        int     _def;
        int     _speed;
};


Character::Character(void) : _attack(1), _def(1), _speed(1) {

    return ;
}

角色统计数据为：1/1/1

class Strong : public virtual Character {

    public:
        Strong(void); //constructor
};

Strong::Strong(void) : Character() {

    this->setAttack(100);
    this->setDef(100);
    this->setSpeed(1);
    return;
}

强劲的统计数据是：100/100/1

class Quick : public virtual Character {

    public:
        Quick(void); //constructor
};

Quick::Quick(void) : Character() {

    this->setAttack(1);
    this->SetDef(1);
    this->setSpeed(100);
    return;
}

快速统计数据：1/1/100

class Super : public Strong, public Quick {

    public:
        Quick(void); //constructor
};

Super::Super(void) : Character(), Strong(), Quick() {

    this->setAttack(Strong::getAttack());
    this->setDef(Strong::getDef());
    this->setSpeed(Quick::getSpeed());
    return;
}

超级统计数据总是等于快速（如果我交换订单，则为强者）。

知道为什么吗？

我如何初始化Super's Attack＆amp;从父母'Strong'的值中确定，并从Quick please的速度值初始化他的速度值？

Answer 1

您应该使用范围解析运算符::。

例如，如果您想使用Man来调用both.Man::punch("bad guy")版本，对另一个版本，请使用both.Woman::punch("bad guy")

Answer 2

编辑：既然你的编辑改变了问题，你的要求又回到了不明确的地步。但是这里有一种（可能是矫枉过成的）替换你无用的代码的方法，我在原来的答案（我在下面留下）中评论过。

Strong strong;  // Local variables to copy info from
Quick quick;
setAttack(strong.getAttack());
setDef(strong.getDef());
setSpeed(quick.getSpeed());

（早期答案，在问题发生变化之前）

这些操作都无济于事：

this->setAttack(Strong::getAttack());
this->setDef(Strong::getDef());
this->setSpeed(Quick::getSpeed());

规范Strong::与Quick::之间不执行任何操作，因为三个get函数都来自Character的同一副本，无论它们以何种方式继承。三个set调用只重写了读取的值。

但无论有没有那些无用的行，代码应该做你想要的，而不是你报告的。 Character构造函数仅在Strong或Quick之前调用一次，因此这是存储1值的唯一点。然后调用每个Strong和Quick构造函数（在您定义它们的序列中）将1更改为100 s。

因此，如果您的测试显示不正确，则问题出在您未发布的代码中。尝试发布测试的完整代码。

下面是对您发布的内容的测试，删除了无用的代码，其余代码完成了最小的测试程序：

你问：

我如何初始化Super's Attack＆amp;从他的价值观中剔除 parent'Strong'并从速度值初始化他的速度值快速

正如您通过运行此代码所看到的，这就是您的代码已经运行的方式。注意（从我添加的cout中）构造函数执行的顺序。并注意（同样来自那些cout的输出，Character的三个数据成员只存在于对象中的一个位置，并由构造函数按顺序逐步修改。

#include <iostream>


class Character {
    public:
        Character(void); //constructor
        int     getAttack(void) const { return this->_attack; }
        int     getDef(void) const { return this->_def; }
        int     getSpeed(void) const { return this->_speed; }
        void    setAttack(int val) {this->_attack = val; }
        void    setDef(int val) {this->_def = val;}
        void    setSpeed(int val) {this->_speed = val; }

    private:
        int     _attack;
        int     _def;
        int     _speed;
};


Character::Character(void) : _attack(1), _def(1), _speed(1) {

    std::cout << "Character: "<< getAttack() << " " << getDef() << " "<< getSpeed() << std::endl;
}

class Strong : public virtual Character {

    public:
        Strong(void); //constructor
};

Strong::Strong(void) : Character() {

    this->setAttack(100);
    this->setDef(100);
    std::cout << "Strong: "<< getAttack() << " " << getDef() << " "<< getSpeed() << std::endl;
}

class Quick : public virtual Character {

    public:
        Quick(void); //constructor
};

Quick::Quick(void) : Character() {

    this->setSpeed(100);
    std::cout << "Quick: "<< getAttack() << " " << getDef() << " "<< getSpeed() << std::endl;
}

class Super : public Strong, public Quick {

    public:
        Super(void); //constructor
};

Super::Super(void) : Character(), Strong(), Quick() {

    std::cout << "Super: "<< getAttack() << " " << getDef() << " "<< getSpeed() << std::endl;
}

int main()
{
  Super test;
  return 0;
}

在多个继承中从父级调用函数

2 个答案: