Question

想象一下，您有一个简单的2D点对象，其中包含两个设置器和获取器。

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;
};

是的，但是我想保留参数的私密性并使用某些方法扩展类。因此，另一个想法是制作一个包装助手，将操作符别名添加到setters / getters中：

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 x = point.x;

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

不幸的是，我不确定您怎么做。代理对象在自动类型推断中不能很好地发挥作用，因为我们选择它们的类型，而不是模仿它们。

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

1 个答案: