c++ - 我应该如何在 C++ 中装箱整数类型？

Question

假设我的代码有

using foo = int32_t;

某处，和

using bar = int32_t;

然后，出于某种原因，我需要区分此类型和其他 int32_t(及其别名)。但是 - 我仍然希望它们的行为就像 int32_ts 一样。

现在，我可以写:

struct foo { int32_t value; }
struct bar { int32_t value; }

区分类型。但是 - 这些结构的行为根本不像 int；我什至无法将 foo 相互比较! (好吧，反正不是在 C++20 之前)

因为 int32_t 不是一个类，我不能做:

struct foo : public int32_t { }

虽然那会给我我所需要的。

看来我想要实现的是将普通整数“装箱”(a-la Java、C# 等)到类中，其余的将通过继承来处理。

当然有可能脱口而出大量样板文件并实现所有与整数相关的运算符:赋值、比较、算术等。但是，你知道的，DRY !

如果我可以 override operator dot ，这可以节省我所有的代码，但该提案被卡住了，看起来不会很快出现。

那么我可以利用其他方法来避免所有这些样板文件吗？

Answer 1

我尝试过一种方法(但未经过严格测试)来避免重复样板文件。它使用模板轻松创建新类型，只需提供不同的数字作为模板参数即可。生成的类型可以是类型别名以摆脱丑陋的模板定义:

namespace alt {

template<std::size_t TypeId, typename Number>
class typed_number
{
public:
    explicit typed_number(Number n): n(n) {}
    typed_number(typed_number const& tn): n(tn.n) {}

    typed_number& operator= (typed_number const& tn) { this->n  = tn.n; return *this; }
    typed_number& operator+=(typed_number const& tn) { this->n += tn.n; return *this; }
    typed_number& operator-=(typed_number const& tn) { this->n -= tn.n; return *this; }
    typed_number& operator*=(typed_number const& tn) { this->n *= tn.n; return *this; }
    typed_number& operator/=(typed_number const& tn) { this->n /= tn.n; return *this; }

    explicit operator Number() const { return n; }

    bool operator==(typed_number tn) const { return this->n == tn; }
    bool operator!=(typed_number tn) const { return this->n != tn; }
    bool operator<=(typed_number tn) const { return this->n <= tn; }
    bool operator>=(typed_number tn) const { return this->n >= tn; }
    bool operator< (typed_number tn) const { return this->n <  tn; }
    bool operator> (typed_number tn) const { return this->n >  tn; }

    typed_number operator+(typed_number const& tn) const { return typed_number(this->n + tn.n); }
    typed_number operator-(typed_number const& tn) const { return typed_number(this->n - tn.n); }
    typed_number operator*(typed_number const& tn) const { return typed_number(this->n * tn.n); }
    typed_number operator/(typed_number const& tn) const { return typed_number(this->n / tn.n); }

    friend std::ostream& operator<<(std::ostream& os, typed_number<TypeId, Number> n)
        { return os << n.n; }

    friend std::istream& operator>>(std::istream& is, typed_number<TypeId, Number>& n)
        { return is >> n.n; }

private:
    Number n;
};

}  // namespace alt

// give each incompatible type a different index
using dollars = alt::typed_number<0, int>;
using cents = alt::typed_number<1, int>;

int main()
{
    auto d1 = dollars(5);
    auto d2 = dollars(9);

    auto d3 = d1 + d2;

    std::cout << d1 << " + " << d2 << " = " << d3 << '\n';
}

您将样板一次创建为模板类，然后将其实例化为不同的类型，只需提供一个唯一索引作为第一个模板参数。