支持两个具有不同语义的整数构造函数

Question

我正在设计一个具有两个构造函数的类，该构造函数带有具有不同语义的单个整数参数。

template <typename value_t>
class Numeric {
    value_t value_;
public:
    Numeric(value_t value) : value_(value) {}
    Numeric(long l) { /* computes value_ from l */ }
    Numeric(double d) { /* computes value_ from d */ }
    Numeric(std::string bstring) { /* computes value_ from binary string */ }
    // ...
};

value_t 必须 在这种情况下是一个整数类型，它甚至可以是long 的别名（在这种情况下甚至无法编译）。即使它不是long 的类型别名，我也不太确定整数提升会如何混淆这两个构造函数。

我的想法是我想通过提供基础表示来支持用户构建，或通过给它任何可能的数字表示，然后将其转换为基础表示（A.K.A value_t）。

分离构造函数的最佳方法是什么？

Answer 1

我强烈建议您重新考虑设计。为什么你需要两个看起来一样的构造函数，但是做两件不同的事情？

无论如何，你可以使用标签：

struct tag_a{};
struct tag_b{};

template <typename value_t>
class Example {
    value_t value_;
public:
    Example(value_t value, tag_a) : value_(value) {}
    Example(long l, tag_b) {  }
};

用法

long x = 123;
auto a = Example<long>(x,tag_a());
auto b = Example<long>(x,tag_b());

Answer 2

我建议创建构造函数private 并改用静态函数来“创建”您的实例。静态函数可以具有有意义的名称，以便明确地告诉用户每个函数的期望：

template <typename value_t>
class Example {
    value_t value_;
    //Prevent users to directly create instances
    Example(value_t value): value_(value)
    {
    }
public:
    static Example createFromValue(value_t value)
    {
        return Example(value);
    }
    static Example createComputingValueFromLong(long l)
    {
        return Example(/*Compute from l*/l);
    }
};

即使您仍然想使用这些构造函数而不是分配内部变量，您也可以将它们放在私有部分并从static 函数中调用它们，这样用户将永远无法直接调用它们。

Answer 3

我正在设计一个具有两个构造函数的类，该构造函数具有单个整数参数，它们具有不同的语义。

分离构造函数的最佳方法是什么？

---

您的代码应该反映您的语义。

---

当有人看到你的类的接口时，他们必须立即猜出它的正确用法是什么。由于我不知道您的用例背后的语义，因此我将自己进行说明。

处理群众的简单类

想象下面的类来处理群众；我们将对其进行增强以提供额外的可构建性：

template<class T>
class Mass
{
    T _kg;
public:
    Mass(T kg) : _kg(kg) {}
    T kg() const { return _kg; }
};

用法：

#include <iostream>
int main()
{
    Mass<double> one_litter_of_water(1.0);
    std::cout << "1 L of water is: " << one_litter_of_water.kg() << " kg\n";
}

Live demo.

现在让它能够处理奇怪的单位

现在，我想要一种简单的方法让用户用磅（或石头或其他东西）构造Mass：

template<class T>
class Mass
{
    T _kg;
public:
    Mass(T kg) : _kg(kg) {}
    Mass(double lb) : _kg(lb/2.2046) {} // ho no!
    T kg() const { return _kg }
};

Live demo.

这不起作用，因为T 可以是double。

使语义明显

解决方案就像命名事物一样简单。对于采用相同类型的多个参数的函数尤其如此。想象一下，有一天您阅读了一些晦涩难懂的旧代码并偶然发现：

draw(2.6, 2.8, 54.1, 26.0); // draw selection

它有什么作用？好吧，显然它画了一些东西。它需要四个双参数，它可能是一个矩形。你需要一些时间，去看看draw 的声明，找到它的文档，......然后弄清楚它在给定两个点的情况下绘制了一个矩形。它可能是一个点、一个宽度和一个高度，它可能是很多东西。

在另一种生活中，想象一下，而不是上面你找到的那条线：

draw(Point{2.6, 2.8}, Point{54.1, 26.0}); // draw selection

现在不是明显了吗？

在我们的大规模案例中使语义显而易见

struct pounds { double value; operator double() const { return value; } };

template<class T>
class Mass
{
    T _kg;
public:
    Mass(T kg) : _kg(kg) {}
    Mass(pounds lb) : _kg(lb/2.2046) {}
    T kg() const { return _kg; }
};

用户可以显然这样使用它：

#include <iostream>
int main()
{
    Mass<double> one_litter_of_water(pounds{2.2046});
    std::cout << "1 L of water is: " << one_litter_of_water.kg() << " kg\n";
}

Live demo.

改进

现在您已经命名了语义，您可以进一步提供丰富的重载集：

struct unit { double value; operator double() const { return value; } };
struct pounds : unit {};
struct stones : unit {};
struct grams  : unit {};

template<class T>
class Mass
{
    T _kg;
public:
    Mass(T kg) : _kg(kg) {}
    Mass(pounds lb) : _kg(lb/2.2046) {}
    Mass(stones st) : _kg(st/0.1575) {}
    Mass(grams  g)  : _kg(g/1000.0) {}
    T kg() const { return _kg; }
};

Live demo.

这里需要注意的是，逻辑（单位转换）还在Mass的实现中； pounds、stone、等只是名称：语义。在这种情况下，这可能无关紧要（一公斤会在很长一段时间内保持约 0.16 块石头），但一般来说，您应该更愿意将这些实施细节封装在同一个地方。