我最近正在阅读有关 C++ 源代码的系列文章，“反射(reflection)的暂停:五个列表中的五个”。在 Part V , Scott Meyers 讨论了单位问题的 Barton 和 Nackman 解决方案。作为航空航天业的嵌入式软件工程师，这个特别的啊哈!瞬间让我兴奋。到目前为止，我还没有听说过这种方法(这些作者也没有听说过)。

我进行了研究，试图找到有关该解决方案的更多信息。我在这里看到了这个演示文稿:http://se.ethz.ch/~meyer/publications/OTHERS/scott_meyers/dimensions.pdf

我想我了解我阅读过的有关此解决方案的所有内容。但我觉得好像少了一 block 拼图。这个漂亮、优雅的解决方案无处可寻。具体来说，我对不仅仅是乘数的转换感兴趣。例如，温度在开尔文、摄氏度和华氏度之间转换。我希望能够互换使用这些温度。

我的问题:

1. 我错过了什么吗？是否在某处引用我忽略的单位解决方案讨论讨论了比例？

2. 如果不是，我该如何进一步解决这个问题？是否存在可与 B&N 方法结合使用以完成解决方案的现有模式？

我的目标是能够编写类似于下面示例的代码，而无需过多的计算。在距离的情况下，我希望能够声明一个定义为英里的对象，并以英里为单位执行所有相关计算，而不必不断地来回转换为米。

例子:

typedef Units<double, miles>      uMiles;
typedef Units<double, kilometers> uKilometers;

uMiles      d1 (1.0);
uKilometers d2 (1.60934);

d1 += d2;
if (d1.val(miles) == 2.0) // PASS
if (d1.val(kilometers) == 3.21869) // PASS

注意: 我看过 BOOST UNITS 解决问题的方法，但我不喜欢它。对我来说，这是非常不可读的。我也不是，通常允许使用外部库，例如 boost。

备份数据:

描述的单位类:

template<class T, // Precision
    int m, // Mass
    int l, // Length
    int t, // Time
    int q, // Charge
    int k, // Temperature
    int i, // Luminous Intensity
    int a> // Angle

    class Units
    {
    public:
    // ------------------------------------------------------
    explicit
    Units (T initVal = 0)
        : val (initVal)
    {
    }

    // --------------------------------------------------------------------
    // Operator: Assignment from type T
    Units<T, m, l, t, q, k, i, a>&
    operator= (const T rhs)
    {
        val = rhs;
        return *this;
    }

    // --------------------------------------------------------------------
    // Operator: Type Converstion to T
    operator T () const
    {
        return val;
    }

    // --------------------------------------------------------------------
    // Operator: +=
    Units<T, m, l, t, q, k, i, a>&
    operator+= (const Units<T, m, l, t, q, k, i, a>& rhs)
    {
        val += rhs.val;
        return *this;
    }

    // --------------------------------------------------------------------
    Units<T, m, l, t, q, k, i, a>&
    operator-= (const Units<T, m, l, t, q, k, i, a>& rhs)
    {
        val -= rhs.val;
        return *this;
    }

    // --------------------------------------------------------------------
    Units<T, m, l, t, q, k, i, a>&
    operator*= (T rhs)
    {
        val *= rhs;
        return *this;
    }

    // --------------------------------------------------------------------
    Units<T, m, l, t, q, k, i, a>&
    operator/= (T rhs)
    {
        val /= rhs;
        return *this;
    }

    // --------------------------------------------------------------------
    // Get Reference
    T&
    Val ()
    {
        return val;
    }

    // --------------------------------------------------------------------
    // Get Value
    const T&
    Val () const
    {
        return val;
    }

    private:
    T val;
    };

// ----------------------------------------------------------------------------
// Operator: Addition
template<class T, int m, int d, int t, int q, int k, int i, int a>
    const Units<T, m, d, t, q, k, i, a>
    operator+ (const Units<T, m, d, t, q, k, i, a> & lhs,
           const Units<T, m, d, t, q, k, i, a> & rhs)
    {
    Units<T, m, d, t, q, k, i, a> result (lhs);
    return result += rhs;
    }

// ----------------------------------------------------------------------------
// Operator: Subtraction
template<class T, int m, int d, int t, int q, int k, int i, int a>
    const Units<T, m, d, t, q, k, i, a>
    operator- (const Units<T, m, d, t, q, k, i, a> & lhs,
           const Units<T, m, d, t, q, k, i, a> & rhs)
    {
    Units<T, m, d, t, q, k, i, a> result (lhs);
    return result -= rhs;
    }

// ----------------------------------------------------------------------------
// Operator: Multiplication
template<class T, int m, int d, int t, int q, int k, int i, int a>
    const Units<T, m, d, t, q, k, i, a>
    operator* (const Units<T, m, d, t, q, k, i, a> & lhs,
           const Units<T, m, d, t, q, k, i, a> & rhs)
    {
    Units<T, m, d, t, q, k, i, a> result (lhs);
    return result *= rhs;
    }

// ----------------------------------------------------------------------------
// Operator: Division
template<class T, int m, int d, int t, int q, int k, int i, int a>
    const Units<T, m, d, t, q, k, i, a>
    operator/ (const Units<T, m, d, t, q, k, i, a> & lhs,
           const Units<T, m, d, t, q, k, i, a> & rhs)
    {
    Units<T, m, d, t, q, k, i, a> result (lhs);
    return result /= rhs;
    }

// ----------------------------------------------------------------------------
// Operator: Multiplication (Creates New Type)
template<class T,
        int m1, int d1, int t1, int q1, int k1, int i1, int a1,
    int m2, int d2, int t2, int q2, int k2, int i2, int a2>

    // Return Type
    Units<T, m1 + m2, d1 + d2, t1 + t2, q1 + q2, k1 + k2, i1 + i2, a1 + a2>
    operator* (const Units<T, m1, d1, t1, q1, k1, i1, a1>& lhs,
           const Units<T, m2, d2, t2, q2, k2, i2, a2>& rhs)
    {
        // New Return type
    typedef Units<T,
        m1 + m2,
        d1 + d2,
        t1 + t2,
        q1 + q2,
        k1 + k2,
        i1 + i2,
        a1 + a2> ResultType;

    return ResultType (lhs.Val() * rhs.Val());
    }

// ----------------------------------------------------------------------------
// Operator: Division (Creates New Type)
template<class T,
        int m1, int d1, int t1, int q1, int k1, int i1, int a1,
    int m2, int d2, int t2, int q2, int k2, int i2, int a2>

    // Return Type
    Units<T, m1 - m2, d1 - d2, t1 - t2, q1 - q2, k1 - k2, i1 - i2, a1 - a2>
    operator/ (const Units<T, m1, d1, t1, q1, k1, i1, a1>& lhs,
           const Units<T, m2, d2, t2, q2, k2, i2, a2>& rhs)
    {
        // New Return type
    typedef Units<
        T,
        m1 - m2,
        d1 - d2,
        t1 - t2,
        q1 - q2,
        k1 - k2,
        i1 - i2,
        a1 - a2> ResultType;

    return ResultType (lhs.Val() / rhs.Val());
    }

这个类允许我们编写如下代码:

//  Base Types
typedef Units<double, 1,0,0,0,0,0,0> uMass;
typedef Units<double, 0,1,0,0,0,0,0> uLength;
typedef Units<double, 0,0,1,0,0,0,0> uTime;
typedef Units<double, 0,0,0,1,0,0,0> uCharge;
typedef Units<double, 0,0,0,0,1,0,0> uTemperature;
typedef Units<double, 0,0,0,0,0,1,0> uIntensity;
typedef Units<double, 0,0,0,0,0,0,1> uAngle;

//  Derived Types
typedef Units<double, 0,2, 0,0,0,0,0> uArea;
typedef Units<double, 0,3, 0,0,0,0,0> uVolume;
typedef Units<double, 0,1,-1,0,0,0,0> uVelocity;
typedef Units<double, 0,1,-2,0,0,0,0> uAcceleration;
typedef Units<double, 1,1,-2,0,0,0,0> uForce;


uMass         mass;
uTime         time;
uForce        force;
uLength       length;
uVelocity     velocity;
uAcceleration acceleration;

// This will compile
mass = 7.2;
acceleration = 3.5;
force = mass * acceleration;

// These will not compile ** Enforcing Dimensional Unit Correctness
force = 7.2 * acceleration;
force = mass; 
force *= acceleration;

最佳答案

根据我从您的代码和解释中了解到的情况，您似乎可以定义转换常量“Units”，例如

Units<double,0,0,0,0,0,0,0> K2C(243.15);
Units<double,0,0,0,0,1,0,0> uCelsius;
Units<double,0,0,0,0,1,0,0> uKelvin;

uCelsius = uKelvin - K2C;

以上代码与重载运算符一起工作，同时保持模板化单元的一致性。您必须为要使用的任何常量创建伪 Unit。

另一种我能看到的工作方式是编写一个像

typdef enum {
    CELSIUS,
    KELVIN,
    FAHRENHEIT
} temp_t;

void Units::convertTemp(const temp_t from, const temp_t to) {

    switch(from) {
        case KELVIN:
            val -= 243.15;
        case CELSIUS:
            if(to == FAHRENHEIT)
                //conversion
            else if(to == KELVIN)
                val += 243.15;
            break;
        case FAHRENHEIT:
            // convert to celsius
            if(to == KELVIN)
                //convert to Kelvin
     }
}

关于C++ 维度分析(Barnes 和 Nackman)与 Scale，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28698558/