c++ - 0到1之间的数字类型

有没有自然的方法来定义介于0和1之间的数字类型？本质上，一个人可以用double做所有事情，问题是我应该在某些函数中定义一些绑定检查，并且我有（可能是愚蠢的）想法将绑定检查外包给一个类，例如

class Probability {

    // the value of the Probability
    double val;

    Probability(double val):value(val){
    // freak out if val > 1 or val < 0
    //...
    //
    };

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

这种方法的问题可能在于它会减慢每个操作的速度。有没有更快的绑定检查方法？我也想知道如何处理上面代码中的“怪胎”部分。

最佳答案

您可以使用类Probability强制执行边界，在内部存储一个double。如果希望像P(0.75) + P(0.5) - P(0.6)这样的操作起作用，则可以让运算符返回一个代理对象，该对象不进行边界检查。此代理对象将具有一个Probability的转换运算符，并且Probability构造函数将检查边界。如果仅直接使用Probability类型，并允许使用ProbabilityResultProxy形式的临时对象，则将获得所需的行为。

下面的示例概述了这种方法。显然，在实际实现中会缺少很多东西，但是我想专注于特定的解决方案，而不是提供完整的类。

Live example：

#include <iostream>

class Probability {
  public:

    Probability(double value) {
        if (value < 0 || 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+(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());
}

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 + p2 - p3;
    std::cout << result.value() << "\n";

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

    return 0;
}

此处，为Probability和ProbabilityResultProxy的每种组合定义了数学运算符。每个操作都会返回一个代理对象，最后的赋值将导致执行边界检查。



如果需要，可以将ProbabilityResultProxy设为Probability的私有成员类，并让Probability的操作员成为朋友。这样可以防止任何人直接实例化代理类。