Question

我对编程有些新意，我正在开发一个小型RPG战斗系统来练习我的技能。我不确定如何从逻辑上解决这个看似简单的问题。以下是我正在努力做的一个例子：

class ExampleClass{

public:

int getDamage(int SwordPower)
{
    Weapon = SwordPower;
    cout << Damage;
    return Damage;
}

private:
int Weapon = 0;
int Strength = 5;
int Damage = (Weapon*Strength);
};

int main()
{
    ExampleClass Character;
    Character.getDamage(45);
}

当伤害输出应为225时最终为0，大概是因为Damage变量返回其最初定义的值0而不是返回预期的新值，因为getDamage没有要求它使用武器的新值重新计算由参数定义。

到目前为止，我所做的工作是：

int getDamage(int SwordPower)
    {
        Weapon = SwordPower;
        Damage = (Weapon*Strength);
        cout << Damage;
        return Damage;
    }

    private:
    int Weapon = 0;
    int Strength = 5;
    int Damage = 0;
    };

这输出225，正确的数字，因为新的武器值用于重新计算伤害。但是，这意味着我必须在每个函数中声明Damage = (Weapon*Strength);，而不是简单地为类中的每个函数预定义它。这是一个很大的问题，因为我已经制作的几十个类有几十个更长和更复杂的函数，并且每个函数都有几十个这些方程定义的变量，所以这样做这样做感觉真的很低效。

我错过了更好，更明显的方式吗？

Answer 1

对于这个例子，你根本不需要武器和伤害成员。

//...

int getDamage(int weapon)
{
    int damage = weapon * Strength;
    cout<<damage<<endl;
    return damage;
}

//...

Answer 2

您编写的第一个代码无法正常工作，因为它并不完全符合您的想法。

class ExampleClass{
    int Weapon = 0;
    int Strength = 5;
    int Damage = (Weapon*Strength);
};

将值赋予此类变量仅意味着此计算是在从类创建对象期间完成的。因此，当您从Character实例化ExampleClass时，Damage设置为0

所以你应该重新计算代码中的伤害。

class ExampleClass{
    int Weapon = 0;
    int Strength = 5;
    //int Damage = 0; is practically the same thing 
    int Damage = (Weapon*Strength);

    public void setWeaponDamage(int SwordDamage){
          Weapon = SwordDamage;
    }
    public int getDamage(){
          return (Weapon * Strength);
    }
    //Maybe something like this if you need to use the "Damage" variable
    //although doesn't seem like you would need.
    public void setDamage(int damage){
          Damage = damage;
    }
};

考虑@Thomas Matthews＆＃39;评论，我删除了（this-＆gt;）符号。

Answer 3

您可以定义每次将新值分配给武器时重新计算损坏的成员函数setWeapon。

例如

void setWeapon( int w )
{
   if ( this->Weapon != w )
   {
      this->Weapon = w;
      this->Damage = this->Weapon * thsi->Strength;
   }
}

然后可以在getDamage

中使用此成员函数

int getDamage( int SwordPower )
{
    setWeapon( SwordPower );
    return Damage;
}

至于初始化

private:
int Weapon = 0;
int Strength = 5;
int Damage = 0;

或者

private:
int Weapon = 0;
int Strength = 5;
int Damage = (Weapon*Strength);

然后在创建类的对象时调用默认构造函数只执行一次。

所以写

是没有意义的

int Damage = (Weapon*Strength);

如果武器被初始化为0。

我认为将C＃用于提供属性的程序会更好。：）

Answer 4

使用名为getSomething的函数来设置某些内容（在这种情况下为Weapon）是不寻常的C ++风格。

如果成员职能只有一个责任，通常被认为是一种良好做法。我建议你有两个成员函数，一个叫setWeapon之类的东西，什么都不返回，另一个叫getDamage，它计算损坏并且不修改类：

class ExampleClass{
public:
    void setWeapon(int newWeapon)
    {
        weapon = newWeapon;
    }

    int getDamage() const 
    {
        return weapon*strength;
    }
private:
    int weapon = 0;
    int strength = 5;
};

int main()
{
    ExampleClass character;
    character.setWeapon(45);
    std::cout << character.getDamage() << "\n";
}

然后计算损坏的代码写在一个地方，即getDamage成员函数。这样可以最小化类的大小（两个整数）。

如果事实证明你正在计算很多伤害，那么优化可能是为伤害添加缓存，但是如果武器或力量发生变化，你必须确保更新你的缓存，并且要注意这会增加你的班级有三个整数：

class ExampleClass{
public:
    void setWeapon(int newWeapon)
    {
        weapon = newWeapon;
        updateDamage();
    }

    void setStrength(int newStrength)
    {
        strength = newStrength;
        updateDamage();
    }    

    int getDamage() const 
    {
        return damage;
    }

private:
    void updateDamage() const {
        damage = weapon*strength;
    }

    int weapon = 0;
    int strength = 5;
    mutable int damage = 0;
};

但是如果你有一些证据需要，我只会这样做。

您可以通过仅在需要时计算损坏并将其存储以供后续使用来进一步优化。

C ++ - 我是否必须为每个函数重新计算私有变量方程？

4 个答案: