Question

我目前正在设计一个API，我希望用户能够编写如下代码：

PowerMeter.forceVoltage(1 mV);
PowerMeter.settlingTime(1 ms);

目前我们使用以下定义来执行此操作：

#define mV *1.0e-03

这使得用户编写代码非常方便，并且它也非常易读，但当然也有缺点：

int ms;

会抛出一些难以理解的编译器错误。所以我正在寻找更好的解决方案。

我尝试了新的C ++ 11文字，但是我能做到的就是：

long double operator "" _mV(long double value) {
  return value * 1e-3;
}
PowerMeter.forceVoltage(1_mV);

最后，API并不关心像Volt或第二个这样的单位，而只关注数字，所以我不想做任何检查，如果你真的输入了伏特强制电压。所以这也应该是可能的：

PowerMeter.forceVoltage(2 ms);

除了坚持定义之外还有什么想法？

Answer 1

如何通过为不同的电流创建类（ms，mV）来改变它的位置

e.g。

PowerMeter.forceVoltage( mV(1) );  
PowerMeter.settlingTime( ms(1) )

用户非常清楚，并且可以说难以阅读，而且您可以免费获得类型检查。具有不同单元的公共基类将使其更容易实现。

Answer 2

您可以从Calum Grant看到库“C++ Units”作为如何实现此目的的一个很好的示例。该库有点过时，但仍值得观看或可能会使用。

此外，我认为可能有趣的是：“Applied Template Metaprogramming in SI UNITS: the Library of Unit-Based Computation”

还有一个好的图书馆：UDUNITS-2：

包含物理量单位的C库以及单位定义和价值转换实用程序。

Answer 3

您可以使用C ++ 11的compile-time rational arithmetic支持单位，而不是为单位定义文字或宏。

Answer 4

看看Boost.Units。这是一些示例代码：

quantity<energy>
work(const quantity<force>& F, const quantity<length>& dx)
{
    return F * dx; // Defines the relation: work = force * distance.
}

...

/// Test calculation of work.
quantity<force>     F(2.0 * newton); // Define a quantity of force.
quantity<length>    dx(2.0 * meter); // and a distance,
quantity<energy>    E(work(F,dx));  // and calculate the work done.

Answer 5

这就是我提出的......与Anders K几乎相同的想法，但自从我编写代码后，我会发布它：

#include <iostream>

using namespace std;

class MilliVoltsValue;
class VoltsValue;

class VoltsValue
{
public:
   explicit VoltsValue(float v = 0.0f) : _volts(v) {/* empty */}
   VoltsValue(const MilliVoltsValue & mV);

   operator float() const {return _volts;}

private:
   float _volts;
};

class MilliVoltsValue
{
public:
   explicit MilliVoltsValue(float mV = 0.0f) : _milliVolts(mV) {/* empty */}
   MilliVoltsValue(const VoltsValue & v) : _milliVolts(v*1000.0f) {/* empty */}

   operator float() const {return _milliVolts;}

private:
   float _milliVolts;
};

VoltsValue :: VoltsValue(const MilliVoltsValue & mV) : _volts(mV/1000.0f) {/* empty */}

class PowerMeter
{
public:
   PowerMeter() {/* empty */}

   void forceVoltage(const VoltsValue & v) {_voltsValue = v;}
   VoltsValue getVoltage() const {return _voltsValue;}

private:
   VoltsValue _voltsValue;
};

int main(int argc, char ** argv)
{
   PowerMeter meter;

   meter.forceVoltage(VoltsValue(5.0f));
   cout << "Current PowerMeter voltage is " << meter.getVoltage() << " volts!" << endl;

   meter.forceVoltage(MilliVoltsValue(2500.0f));
   cout << "Now PowerMeter voltage is " << meter.getVoltage() << " volts!" << endl;

   // The line below will give a compile error, because units aren't specified
   meter.forceVoltage(3.0f);   // error!

   return 0;
}

Answer 6

考虑为您的单位使用enum并将其作为第二个参数传递：

namespace Units
{
    enum Voltage
    {
        millivolts = -3,
        volts = 0,
        kilovolts = 3
    };

    enum Time
    {
        microseconds = -6,
        milliseconds = -3,
        seconds = 0
    };
}

class PowerMeter
{
public:
    void forceVoltage(float baseValue, Units::Voltage unit)
    {
         float value = baseValue * std::pow(10, unit);
         std::cout << "Voltage forced to " << value << " Volts\n";
    }

    void settlingTime(float baseValue, Units::Time unit)
    {
         float value = baseValue * std::pow(10, unit);
         std::cout << "Settling time set to " << value << " seconds\n";
    }
}

int main()
{
    using namespace Units;
    PowerMeter meter;
    meter.settlingTime(1.2, seconds);
    meter.forceVoltage(666, kilovolts);
    meter.forceVoltage(3.4, milliseconds); // Compiler Error
}

在枚举周围包装Units命名空间可避免使用单元名称污染全局命名空间。以这种方式使用枚举也会在编译时强制将正确的物理单元传递给成员函数。

Answer 7

我更喜欢Anders K的解决方案，但是您可以使用模板来节省一些时间来实现所有单元作为separte类，这可能是耗时的并且容易出错，因为您可能需要手动编写大量代码： / p>

enum Unit {
    MILI_VOLT = -3,
    VOLT = 0,
    KILO_VOLT = 3
};

class PowerMeter
{
public:

    template<int N>
    void ForceVoltage(double val)
    {
        std::cout << val * pow(10.0, N) << endl;
    };
};

像这样使用：

        PowerMeter pm;
        pm.ForceVoltage<MILI_VOLT>(1);
        pm.ForceVoltage<VOLT>(1);
        pm.ForceVoltage<KILO_VOLT>(1);

Answer 8

我更喜欢在任何地方避免使用宏，这是一个应该可行的例子。一个为您提供正确尺寸的轻量级解决方案将是：

static double m = 1;
static double cm = 0.1;
static double mV = 0.001;

double distance = 10*m + 10*cm;

这也反映了单位与价值成倍增加的物理概念。

Answer 9

在你对任何更复杂的东西发疯之前，每当你编写一个以数量作为参数的新代码时，你应该像这样命名你的方法，以便100％明确：

PowerMeter.forceInMilliVolts( ... )
PowerMeter.settlingTimeInSeconds( ... )

同样使用具有正确名称的变量，例如：

int seconds(10);
int milliVolts(100);

这种方式无论你是否必须转换，你仍然清楚你在做什么，例如。

PowerMeter.settlingTimeInSeconds( minutes*60 );

当你准备好更强大的东西时，如果你真的需要，但要确保你不会失去使用哪个单位的清晰度。

如何在c ++接口中处理单位

9 个答案: