结构/类包装器中的 C++ 重载自动运算符

Question

假设您有一个简单的 2D Point 对象，其中包含两个 setter 和 getter。

template <typename T>
class Point
{
public:
    Point(T x, T y);

    T getX() const;
    T getY() const;

    void setX(T x);
    void setY(T y);

private:
    T _x;
    T _y;
};

但我想以更“类似脚本”的语法使用这个类。类似的东西：

auto point = Point<double>(10, 10);
point.x = 20;
point.y = point.x + 10;

你会说，只需使用带有公共变量的结构：

template <typename T>
struct Point
{
    T x;
    T y;
};

是的，但我想保留参数的隐私并使用一些方法扩展类。所以另一个想法是制作一个包装器帮助器，将操作符别名添加到 setter/getter 中：

template <typename T, typename Get,  Get(T::*Getter)() const,
                      typename Set, void(T::*Setter)(Set)>
struct ReadWrite
{
    ReadWrite(T& ptr) : ptr(ptr) {}

    inline void operator= (Set const& rhs)
    {
        (ptr.*Setter)(rhs);
    }

    inline Get operator()()
    {
        return (ptr.*Getter)();
    }

private:
    T& ptr;
};

好的，我只是修改我的 Point 类来完成这项工作：

template <typename T>
class Point
{
public:
    Point(T x, T y);

    T getX() const;
    T getY() const;

    void setX(T x);
    void setY(T y);

private:
    T _x;
    T _y;

public:
     ReadWrite<Point<T>, T, &Point<T>::getX, T, &Point<T>::setX> x;
     ReadWrite<Point<T>, T, &Point<T>::getY, T, &Point<T>::setY> y;
};

通过添加一些算术运算符 ( + - * / )，我可以这样使用它：

auto point = Point<double>(10, 10);
point.x = 20;
point.y = point.x + 10;

这里，point.x 在表单中运算符重载的情况下是可以的：

template <typename T, typename V> inline T operator+(ReadWrite<T> const& lhs, V const& rhs) { return lhs() + rhs; }
template <typename T, typename V> inline T operator-(ReadWrite<T> const& lhs, V const& rhs) { return lhs() - rhs; }
template <typename T, typename V> inline T operator*(ReadWrite<T> const& lhs, V const& rhs) { return lhs() * rhs; }
template <typename T, typename V> inline T operator/(ReadWrite<T> const& lhs, V const& rhs) { return lhs() / rhs; }

如果我想使用这种语法，但在 point.x getter 上没有括号：

auto point = Point<double>(10, 10);
auto x = point.x();

我扩展了 ReadWrite 助手：

template <typename T, typename Get,  Get(T::*Getter)() const,
                      typename Set, void(T::*Setter)(Set)>
struct ReadWrite
{
    ReadWrite(T& ptr) : ptr(ptr) {}

    inline void operator= (Set const& rhs)
    {
        (ptr.*Setter)(rhs);
    }

    inline Get operator()()
    {
        return (ptr.*Getter)();
    }

    inline operator auto() -> Get
    {
        return operator()();
    }

private:
    T& ptr;
}; 

现在没有括号：

double x = point.x; // OK, x is my x value (Point).
auto x = point.x;   // Wrong, x is my ReadWrite<T> struct.

auto 运算符重载有什么问题？

非常感谢您的回答。

Answer 1

你的课没有问题。问题是 auto 如何推断类型。关于 auto 你必须记住的一点是它基本上遵循模板参数推导的规则，主要是不会进行隐式转换。这意味着在

auto x = point.x;

你说编译器，给我一个名为x 的变量，它具有初始化表达式的类型。在这种情况下，point.x 是 ReadWrite<Point<T>, T, &Point<T>::getX, T, &Point<T>::setX>，所以这就是 x 的类型。改变它的唯一方法是改变初始化表达式返回的内容。

很遗憾，我不确定您是如何做到这一点的。代理对象不能很好地使用自动类型推断，因为我们选择了它们的类型，而不是它们正在模仿的类型。