blocks|key|1706424|text|“变态”选项很简单：throw+std::invalid_argument。抛出有一点慢并不重要；你无论如何都得不到答案。优点是不抛出很快，因为优化器可以假设非异常路径的可能性要大得多。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1706425|在性能方面，最好是有一个IntermediateResult类，这样只对返回给Probability的最终赋值进行范围检查。这就绕过了0.75%2B0.5-0.6示例。|1706426|entityMap^0|A|R|0|C|I|13|B|1V|C|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

The "freak out" option is simple: <code>throw std::invalid_argument</code>. It doesn't matter that throwing is a bit slow; you're not getting an answer anyway. The upside is that not throwing is fast as the optimizer can assume the non-exception paths are far more likely.

Performance-wise it might be beneficial to have a <code>IntermediateResult</code> class such that only the final assignment back to <code>Probability</code> is range-checked. This sidesteps the <code>0.75+0.5-0.6</code> example.

blocks|key|109956|text|您可以使用类Probability来强制执行边界，在内部存储一个双精度值。如果你想要像P(0.75)+%2B+P(0.5)+-+P(0.6)这样的操作，你可以让操作符返回一个代理对象，它不做边界检查。这个代理对象将有一个到Probability的转换操作符，并且Probability构造函数将检查边界。如果您只直接使用Probability类型，并允许ProbabilityResultProxy形式的临时函数，那么您将获得所需的行为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|109957|下面的示例概述了这种方法。显然，您在实际实现中会遗漏很多东西，但我想专注于一个特定的解决方案，而不是提供一个完整的类。|109958|Live+example|109959|#include+<iostream>

class+Probability+{
++public:

++++Probability(double+value)+{
++++++++if+(value+<+0+%7C%7C+value+>+1)+throw+std::runtime_error("Invalid+probability");
++++++++value_+=+value;
++++}

++++double+value()+const+{+return+value_;+}

++private:
++++double+value_;
};

class+ProbabilityResultProxy+{
++public:
++++explicit+ProbabilityResultProxy(double+p)+:+value_(p)+{}

++++double+value()+const+{+return+value_;+}

++++operator+Probability()+{
++++++++return+Probability(value_);
++++}

++private:
++++double+value_;
};

ProbabilityResultProxy+operator%2B(const+Probability&+lhs,+const+Probability&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+%2B+rhs.value());
}
ProbabilityResultProxy+operator%2B(const+ProbabilityResultProxy&+lhs,+const+Probability&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+%2B+rhs.value());
}
ProbabilityResultProxy+operator%2B(const+Probability&+lhs,+const+ProbabilityResultProxy&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+%2B+rhs.value());
}
ProbabilityResultProxy+operator%2B(const+ProbabilityResultProxy&+lhs,+const+ProbabilityResultProxy&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+%2B+rhs.value());
}

ProbabilityResultProxy+operator-(const+Probability&+lhs,+const+Probability&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+-+rhs.value());
}
ProbabilityResultProxy+operator-(const+ProbabilityResultProxy&+lhs,+const+Probability&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+-+rhs.value());
}
ProbabilityResultProxy+operator-(const+Probability&+lhs,+const+ProbabilityResultProxy&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+-+rhs.value());
}
ProbabilityResultProxy+operator-(const+ProbabilityResultProxy&+lhs,+const+ProbabilityResultProxy&+rhs)+{
++++return+ProbabilityResultProxy(lhs.value()+-+rhs.value());
}

int+main()+{
++++Probability+p1(0.75);
++++Probability+p2(0.5);
++++Probability+p3(0.6);

++++Probability+result+=+p1+%2B+p2+-+p3;
++++std::cout+<<+result.value()+<<+"\n";

++++try+{
++++++++Probability+result2+=+p1+%2B+p2;
++++++++std::cout+<<+result2.value();
++++}+catch+(const+std::runtime_error&+e)+{
++++++++std::cout+<<+e.what()+<<+"\n";
++++}

++++return+0;
}|code-block|syntax|javascript|109960|这里，为Probability和ProbabilityResultProxy的每种组合定义了数学运算符。每个操作都返回一个代理对象，最终的赋值会导致执行边界检查。|109961|109962|如果您愿意，可以使ProbabilityResultProxy成为Probability的私有成员类，并使运算符成为Probability的朋友。这可以防止任何人直接实例化代理类。|109963|entityMap|0|LINK|mutability|MUTABLE|url|http://coliru.stacked-crooked.com/a/bebb708d70493720^0|6|B|17|P|31|B|3L|B|4E|B|4V|M|0|0|0|C|0|0|0|4|B|G|M|0|0|9|M|X|B|1M|B|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|J|3|K|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

You can use the class <code>Probability</code> to enforce the bounds, storing a double internally. If you want operations such as <code>P(0.75) + P(0.5) - P(0.6)</code> to work, you can have the operators return a proxy object, which doesn't do the bounds checking. This proxy object would have a conversion operator to <code>Probability</code>, and the <code>Probability</code> constructor would check the bounds. If you only ever use the <code>Probability</code> type directly, and allow temporaries of the form <code>ProbabilityResultProxy</code>, you'll get the desired behaviour.

The example below outlines this approach. Obviously there's quite a lot missing that you'd want in a real implementation, but I wanted to focus on a specific solution, rather than providing a complete class.

<a href="http://coliru.stacked-crooked.com/a/bebb708d70493720" rel="nofollow">Live example</a>:

<pre><code>#include &lt;iostream&gt;

class Probability {
 public:

 Probability(double value) {
 if (value &lt; 0 || value &gt; 1) throw std::runtime_error("Invalid probability");
 value_ = value;
 }

 double value() const { return value_; }

 private:
 double value_;
};

class ProbabilityResultProxy {
 public:
 explicit ProbabilityResultProxy(double p) : value_(p) {}

 double value() const { return value_; }

 operator Probability() {
 return Probability(value_);
 }

 private:
 double value_;
};

ProbabilityResultProxy operator+(const Probability&amp; lhs, const Probability&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() + rhs.value());
}
ProbabilityResultProxy operator+(const ProbabilityResultProxy&amp; lhs, const Probability&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() + rhs.value());
}
ProbabilityResultProxy operator+(const Probability&amp; lhs, const ProbabilityResultProxy&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() + rhs.value());
}
ProbabilityResultProxy operator+(const ProbabilityResultProxy&amp; lhs, const ProbabilityResultProxy&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() + rhs.value());
}

ProbabilityResultProxy operator-(const Probability&amp; lhs, const Probability&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() - rhs.value());
}
ProbabilityResultProxy operator-(const ProbabilityResultProxy&amp; lhs, const Probability&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() - rhs.value());
}
ProbabilityResultProxy operator-(const Probability&amp; lhs, const ProbabilityResultProxy&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() - rhs.value());
}
ProbabilityResultProxy operator-(const ProbabilityResultProxy&amp; lhs, const ProbabilityResultProxy&amp; rhs) {
 return ProbabilityResultProxy(lhs.value() - rhs.value());
}

int main() {
 Probability p1(0.75);
 Probability p2(0.5);
 Probability p3(0.6);

 Probability result = p1 + p2 - p3;
 std::cout &lt;&lt; result.value() &lt;&lt; "\n";

 try {
 Probability result2 = p1 + p2;
 std::cout &lt;&lt; result2.value();
 } catch (const std::runtime_error&amp; e) {
 std::cout &lt;&lt; e.what() &lt;&lt; "\n";
 }

 return 0;
}
</code></pre>

Here, the mathematical operators are defined for each combination of <code>Probability</code> and <code>ProbabilityResultProxy</code>. Each operation returns a proxy object, and the final assignment causes the bounds check to be performed.

<hr>

If you want, you could make the <code>ProbabilityResultProxy</code> a private member class of <code>Probability</code>, and make the operators friends of <code>Probability</code>. This prevents anyone from instantiating the proxy class directly.

Is there a natural way to define a number type between 0 and 1? Essentially one could do everything with double, the problem is that I should define some bound checking in some functions and I had the (probably stupid) idea to outsource the bound checking to a class, something like 

<pre><code>class Probability {

 // the value of the Probability
 double val;

 Probability(double val):value(val){
 // freak out if val &gt; 1 or val &lt; 0
 //...
 //
 };

 // operators such as
 Probability operator + (Probability const &amp; a, Probability const &amp; b){
 double result a.val + b.val;
 if ((result &gt; 1) || (result &lt; 0)){
 // freak out
 result = 0
 }
 return result;
 }
 // ...
 //
}
</code></pre>

The problem with this approach is probably that it slows down every operation. Is there a faster way of bound checking? I also would like to know how to handle the "freak out" sections in the code above.

Number type between 0 and 1

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有没有一种自然的方法来定义一个介于0和1之间的数字类型？基本上，我们可以用double来做任何事情，问题是我应该在一些函数中定义一些边界检查，并且我有一个(可能很愚蠢的)想法，将边界检查外包给一个类，比如class Probability {    // the value of the Probability    ...

问0到1之间的数字类型
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问0到1之间的数字类型EN