用于自动 getter-setter 方法的 C++ 类模板 - 好的/坏的做法？

Question

为(几乎)POD 类中的属性使用带有隐式 getter 和 setter 的模板类对象是一种好习惯吗？

考虑以下模板示例:

template<typename T>
class Attribute
{
protected:
    T m_val;
public:
    T * getAddress() { return &m_val; }
    T get() { return m_val; }
    void set(T v) { m_val = v; }
};

及其用法:

class A
{
public:
    Attribute<float> floatAttr;
    Attribute<int> intAttr;
    Attribute<long> longAttr;
};

有了这个，就可以封装数据，但实现开销更少。

这是不好的做法还是好的做法(以及为什么)？

编辑:陈述我在这方面看到的优势。无需手动实现每个 getter setter 函数，但这些函数仍然具有通常的优点:

• 数据被封装，客户端需要使用getter setter函数，以后还是可以用不同的方式实现。
• 内部用法仍然是隐藏的，可以更改。
• Getter 和 Setter 函数可以作为 lambda 函数传递。

Answer 1

在其他一些语言中，getter 和 setter 是一种防止实现细节逃逸到接口(interface)中的方法；一旦直接公开一个字段，如果不更改访问该字段的代码中的所有站点，您以后可能无法将其重新实现为属性(使用 getter 和 setter 函数)。

在 C++ 中，这并不(非常)适用。您可以将任何字段的类型更改为覆盖 operator= 的类，并隐式转换为所需的类型(对于“get”端)。 (当然有一些不适用的用途；例如，如果在客户端代码中创建指向该字段的指针或引用 - 尽管我个人会避免这样做并认为这是可疑的做法)。

此外，由于 C++ 是静态类型的，如果您需要通过适当的调用将字段和相应的访问更改为 getter/setter 对，工具(IDE 等)也更容易提供自动重构。

作为证据，这里是您的 Attribute 的改动允许您的“属性”作为直接公开字段的模板(除了 & 将返回属性的地址而不是隐藏字段):

template<typename T>
class Attribute
{
protected:
    T m_val;
public:
    operator T() { return m_val; }
    T &operator=(const T &a) { m_val = a; return m_val; }
};

如果您真的想要，您也可以覆盖 operator& :

T *operator&() { return &m_val; }

...但是这样做在很大程度上破坏了封装(出于同样的原因，您可能会考虑将 operator= 的返回类型更改为 T 或 void)。

如果您最初直接公开该字段，则可以将其定义替换为上述模板的实例，并且大多数使用不会受到影响。这说明了为什么在 C++ 中并不总是需要 getter/setter 模式的原因之一。

您自己的解决方案虽然将原始字段封装在 getter/setter 函数后面，但实际上还公开了另一个字段:Attribute<T>成员(在您的示例中为 floatAttr 等)。为了将其用作封装方式，您依赖于用户不知道(或不关心)属性字段本身的类型；也就是说，您希望没有人这样做:

A a;
Attribute<float> & float_attr = a.floatAttr;

当然，如果他们不这样做并以您预期的方式访问字段，那么以后确实可以通过更改“属性”字段的类型来更改实现:

A a;
float f = a.floatAttr.get();

...所以从这个意义上说，您实现了一些封装；真正的问题是有更好的方法来做到这一点。 :)

最后，值得一提的是，您提出的 Attribute模板以及我上面显示的替代方案都将字段移动到与原始父类 ( Attribute<T> ) 分开的类 ( A 对于某些 T)。如果要更改实现，现在在某种程度上受此事实的限制；属性对象自然不会引用包含它的对象。例如，假设我有一个类 B它有一个属性 level :

class B {
    public:
    Attribute<int> level;
};

现在假设我稍后添加一个“最低级别”字段，min_level :

class B {
    public:
    Attribute<int> level;
    Attribute<int> min_level;
};

此外，假设我现在想约束 level , 在赋值时，值为 min_level .这不会是直截了当的!虽然我可以给level具有自定义实现的新类型，它将无法访问 min_level来自包含对象的值:

class LevelAttribute {
    int m_val;
    public:
    T &operator=(const T &a) {
        m_val = std::max(min_level, a); // error - min_level not defined
    }
}

要让它工作，您需要将包含对象传递到 LevelAttribute对象，这意味着存储一个额外的指针。典型的老式 setter 直接在保存字段的类中声明为函数，避免了这个问题。