blocks|key|1291372|text|有一种“更好”的方式，这取决于你对更好的定义。(我猜你的意思是“更短”)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1291373|Warrior::Warrior(unsigned+int+health,+unsigned+int+maxHealth)+:
++++m_health(std::min(health,+maxHealth)),
++++m_maxHealth(maxHealth)
{
}|code-block|syntax|javascript|1291374|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There is a "better" way, depending on your definition of better. (And I'm guessing you mean "shorter" here)

<pre><code>Warrior::Warrior(unsigned int health, unsigned int maxHealth) :
 m_health(std::min(health, maxHealth)),
 m_maxHealth(maxHealth)
{
}
</code></pre>

blocks|key|1469055|text|template+<typename+T>
class+RangeBoundValue
{
public:
++++RangeBoundValue(const+T+_min,+const+T+_max)+:+_min(_min),+_max(_max)+{}

++++void+setValue(T+val)
++++{
++++++++if+(val+<+_min)+_value+=+_min;
++++++++else+if+(val+>+_max)+_value+=+_max;
++++++++else+_value+=+val;
++++}

++++T+value()+const+{return+_value;}

private:
++++const+T+_min;
++++const+T+_max;
++++T+++++++_value;
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1469056|在Warrior中使用此帮助器类|unstyled|offset|length|style|CODE|1469057|class+Warrior
{
...
private:
++++RangeBoundValue<uint>+_health;
};|1469058|entityMap^0|0|1|7|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>template &lt;typename T&gt;
class RangeBoundValue
{
public:
 RangeBoundValue(const T _min, const T _max) : _min(_min), _max(_max) {}

 void setValue(T val)
 {
 if (val &lt; _min) _value = _min;
 else if (val &gt; _max) _value = _max;
 else _value = val;
 }

 T value() const {return _value;}

private:
 const T _min;
 const T _max;
 T _value;
};
</code></pre>

Use this helper class inside <code>Warrior</code>

<pre><code>class Warrior
{
...
private:
 RangeBoundValue&lt;uint&gt; _health;
};
</code></pre>

blocks|key|329105|text|我只会在前提条件不满足的情况下放一个断言或抛出异常：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329106|Warrior::Warrior(uint+health,+uint+maxHealth)+:
++++m_health(health),
++++m_maxHealth(maxHealth)
{
++++assert(health+<=+maxHealth);+
++++//+or+throw+exception
++++throw+std::logic_error("explanation");
}|code-block|syntax|javascript|329107|我的意思是，调用者决定取哪个值的理性是什么？如果调用者设置的健康值大于maxHealth+-这违反了您的类逻辑，所以我建议立即失败并通知调用者这一点。这应该是软件中的问题，所以我认为隐藏它是不可取的。|329108|异常或断言是一种明确的机制，可以帮助您及早发现和识别此类问题。|329109|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would just put an assertion or throw exception in case precondition is not met:

<pre><code>Warrior::Warrior(uint health, uint maxHealth) :
 m_health(health),
 m_maxHealth(maxHealth)
{
 assert(health &lt;= maxHealth); 
 // or throw exception
 throw std::logic_error("explanation");
}
</code></pre>

I mean, what is the rational to decide for the caller which value to take? If caller puts health value bigger than maxHealth - it's violation of your class logic, so I would propose to fail immediately and inform caller about this. It should be problem in the software, so I think it's not desirable to hide it.

Exception or assertion is an explicit mechanism that will help you to find and recognise such problems early.

blocks|key|329114|text|如果您打算在游戏期间设置健康，您可能需要考虑如下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329115|Warrior::Warrior(unsigned+int+health,+unsigned+int+maxHealth)+:
++++m_maxHealth(maxHealth)
{
++++setHealth(health);
}

void+Warrior::setHealth(unsigned+int+health)
{
++++m_health+=+std::min(health,+m_maxHealth);
}|code-block|syntax|javascript|329116|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you intended to set the health during the game you might want to consider something like this:

<pre><code>Warrior::Warrior(unsigned int health, unsigned int maxHealth) :
 m_maxHealth(maxHealth)
{
 setHealth(health);
}

void Warrior::setHealth(unsigned int health)
{
 m_health = std::min(health, m_maxHealth);
}
</code></pre>

blocks|key|3416772|text|这实际上更多的是关于接口设计的问题，而不是实际实现的问题。您的代码中的这两个实现是相似的，并且都实现了一个宽接口的设计，该接口允许参数的任意组合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3416773|一种不同的方法是在构造函数上使用一个狭义的约定，在这个约定中，对象的行为只有在明显的约束health+<+maxHealth为真的情况下才会得到很好的定义。在这种情况下，您需要记录构造函数并实现它：|offset|length|style|CODE|3416774|Warrior::Warrior(unsigned+int+health,+unsigned+int+maxHealth)
++:+m_health(health),+m_maxHealth(maxHealth)
{
+++assert(health+<=+maxHealth);
}|code-block|syntax|javascript|3416775|在我看来，这是一个更好的设计。没有充分的理由将错误的参数接受给构造函数。通过在那里添加该assert，您可以在开发周期的早期检测到您的类型在合同外使用。对于具有相同类型的多个参数的函数，这一点尤其重要，因为它有助于检测是否错误地传递了乱序的参数。在那里使用宽合约会将maxHealth减少到与当前的health相同，以后您会遇到问题，试图找出为什么Warrior比您想象的更弱……狭义合约会立即告诉你参数是无序的。|3416776|entityMap^0|0|18|I|0|0|18|6|3P|9|45|6|4U|7|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

This is really more of a question on the design of the interface than the actual implementation. Both of the implementations in your code are similar and implement a design with a wide interface that allows for any combination of arguments.

A different approach would be to use a narrow contract on your constructor, in which the behavior of the object is well defined only if the obvious constraint that <code>health &lt; maxHealth</code> is true. In that case you would document the constructor as such and implement it:

<pre><code>Warrior::Warrior(unsigned int health, unsigned int maxHealth)
 : m_health(health), m_maxHealth(maxHealth)
{
 assert(health &lt;= maxHealth);
}
</code></pre>

Which in my opinion is a better design. There is no good reason to accept the wrong arguments to the constructor. By adding that <code>assert</code> there you can detect early in the development cycle when your type is used out of contract. This is specially important with functions that have multiple arguments of the same type, as it will help detect if by mistake you pass the arguments out of order. The use of a wide contract there would reduce the <code>maxHealth</code> to be the same as the current <code>health</code>, and at a later time you will have problems trying to figure out why the <code>Warrior</code> is weaker than you thought it should be... the narrow contract will tell you the arguments are out of order immediately.

blocks|key|1291641|text|当构造函数的参数列表与health>max_health一起提供时，有人建议抛出异常，这让我非常惊讶。最大健康通常是作为健康的上限来实现的，并且考虑到这是一个简单的约束，与其他任何东西无关，它应该是勇士的责任来强制实施自己的约束。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1291642|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I am quite surprised that people are suggesting to throw exceptions when an argument list to the constructor is supplied with health>max_health. For instance, say you have some resurrection implementation where all creatures are resurrected with a fixed amount of health up to their maximum health and in some cases this exceeds maximum health, to avoid coupling you don't want this method to have to store every object's maximum health, you could add methods to test for it before submitting these arguments to the constructors but again this complicates things. Max health is usually implemented as a ceiling on health and given that this is a simple constraint, uncoupled from anything else, it should be the warrior's responsibility to enforce its own constraints.

I have a class called <code>Warrior</code> that has <code>uint m_health</code> and <code>uint m_maxHealth</code> attributes.
I want my constructor to take parameters <code>Warrior(uint health, uint maxHealth)</code>.

Now I've studied C++ a lot and I know all the syntax etc, but it's hard to find tutorials on how to use the stuff etc. so I don't really know how should I define <code>health</code> and <code>maxHealth</code> when <code>health</code> obviously can't be higher than <code>maxHealth</code> :/

Here are few methods I thought of:

<pre><code>// method 1
Warrior::Warrior(uint health, uint maxHealth) :
 m_health((health &gt; maxHealth) ? maxHealth : health),
 m_maxHealth(maxHealth)
{}

// method 2
Warrior::Warrior(uint health, uint maxHealth) :
 m_maxHealth(maxHealth)
{
 if (health &gt; maxHealth) {
 m_health = maxHealth;
 }
 else {
 m_health = health;
 }
}
</code></pre>

I'm sure there are other ways too.
Sorry if this is just an opinion question, but if there's a "preferred" way in C++, what would it be?

How to define `health` and `maxHealth` in one object, when `healt` can't be higher than `maxHealth`?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个名为Warrior的类，它有uint m_health和uint m_maxHealth属性。我想让我的构造函数接受参数Warrior(uint health, uint maxHealth)。现在我已经学习了C++很多，我知道所有的语法等，但是很难找到关于如何使用这些东西的教程，所以我真的不知道当health...

问当`healtht`不能大于`maxHealth`时，如何在一个对象中定义`health`和`maxHealth`？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当`healtht`不能大于`maxHealth`时，如何在一个对象中定义`health`和`maxHealth`？EN