定义非常量“get”成员函数的原因？

Question

我正在通过 Stroustrup 的（使用 C++ 的编程原理和实践）一书学习 C++。在练习中，我们定义了一个简单的结构：

template<typename T>
struct S {
  explicit S(T v):val{v} { };

  T& get();
  const T& get() const;

  void set(T v);
  void read_val(T& v);

  T& operator=(const T& t); // deep copy assignment

private:
  T val;
};

然后要求我们定义一个 const 和一个非 const 成员函数来获取 val。

我想知道：在任何情况下让非常量 get 函数返回 val 有意义吗？

在我看来，我们不能在这种情况下间接地改变价值。哪些用例需要 const 和非 const get 函数来返回成员变量？

Answer 1

首先让我重新表述你的问题：

为什么要为成员设置一个非常量的 getter，而不仅仅是将成员公开？

几个可能的原因原因：

1。易于检测

谁说非常量 getter 必须是公正的：

T& get() { return val; }

？很可能是这样的：

T& get() { 
   if (check_for_something_bad()) {
       throw std::runtime_error{
           "Attempt to mutate val when bad things have happened");
   }
   return val;
 }

然而，正如@BenVoigt 所建议的那样，等到调用者真正尝试通过引用改变值时再发出错误更合适。

2。文化大会/“老板是这么说的”

一些组织强制执行编码标准。这些编码标准有时是由可能过度防御的人编写的。因此，您可能会看到如下内容：

除非您的班级是 "plain old data" type，否则任何数据成员都不得公开。您可以根据需要对此类非公共成员使用 getter 方法。

然后，即使特定类只允许非常量访问是有意义的，它也不会发生。

3。也许val 不存在？

您已经给出了一个示例，其中val 实际上存在在类的一个实例中。但实际上 - 它不必！ get() 方法可以返回某种proxy object，它在分配、变异等时执行一些计算（例如，在数据库中存储或检索数据；或者翻转一点，它本身不像对象需要的那样可寻址是）。

4。允许稍后更改类内部而不更改用户代码

现在，阅读上面的第 1. 或第 3 项，您可能会问“但我的 struct S确实有val！”或“我的get() 没有做任何有趣的事情！” - 嗯，真的，他们没有；但是您将来可能希望更改此行为。如果没有get()，您班级的所有用户都需要更改他们的代码。有了get()，只需要修改struct S的实现即可。

现在，我不提倡这种设计方法，但有些程序员会这样做。

Answer 2

非常量吸气剂？

Getter 和 setter 只是约定俗成的。有时使用的习惯用法不是提供 getter 和 setter，而是提供类似的东西

struct foo {
    int val() const { return val_; }
    int& val() { return val_; }
private:
    int val_;
};

这样，根据实例的常量，您可以获得引用或副本：

void bar(const foo& a, foo& b) {
    auto x = a.val(); // calls the const method returning an int
    b.val() = x;      // calls the non-const method returning an int&
};

这是否是一般的好风格是一个见仁见智的问题。在某些情况下，它会导致混淆，而在其他情况下，这种行为正是您所期望的（见下文）。

无论如何，更重要的是根据类应该做什么以及你想如何使用它来设计一个类的接口，而不是盲目地遵循关于 setter 和 getter 的约定（例如，你应该给方法一个有意义的名称，它表达了它的作用，而不仅仅是“假装被封装，现在让我通过 getter 访问你所有的内部结构”，这就是在任何地方使用 getter 的实际含义）。

具体例子

考虑到容器中的元素访问通常是这样实现的。作为一个玩具示例：

struct my_array {
    int operator[](unsigned i) const { return data[i]; }
    int& operator[](unsigned i) { return data[i]; }
    private:
        int data[10];
};

向用户隐藏元素并不是容器的工作（即使data 也可以是公开的）。您不希望根据您是要读取还是写入元素来访问元素的不同方法，因此在这种情况下提供 const 和非常量重载非常有意义。

来自 get vs encapsulation 的非 const 引用

也许不是那么明显，但是提供 getter 和 setter 是否支持封装还是相反，这有点争议。虽然总的来说，这件事很大程度上是基于意见的，但对于返回非 const 引用的 getter 来说，这与意见无关。他们确实打破了封装。考虑

struct broken {
    void set(int x) { 
        counter++;
        val = x;
    }
    int& get() { return x; }
    int get() const { return x; }
private:
    int counter = 0;
    int value = 0;
};

顾名思义，此类已损坏。客户可以简单地获取一个引用，并且该类没有机会计算该值被修改的次数（正如set 所建议的那样）。一旦您返回一个非常量引用，那么关于封装，将成员公开几乎没有什么区别。因此，这仅用于此类行为是自然的情况（例如容器）。

附言

请注意，您的示例返回 const T& 而不是值。这对于模板代码是合理的，因为您不知道副本的成本，而对于 int，您不会通过返回 const int& 而不是 int 获得太多收益。为了清楚起见，我使用了非模板示例，但对于模板代码，您可能更愿意返回 const T&。

Answer 3

get() 可以被允许变异的非 const 对象调用，你可以这样做：

S r(0);
r.get() = 1;

但是如果您将r const 设置为const S r(0)，则r.get() = 1 行不再编译，甚至无法检索值，这就是为什么您需要一个const 版本const T& get() const 至少能够检索const 对象的值，这样做可以：

const S r(0)
int val = r.get()

成员函数的 const 版本尽量与被调用的对象的 constness 属性保持一致，即如果对象通过 const 是不可变的并且成员函数返回引用，它可以通过返回一个常量引用来反映调用者的常量，从而保留对象的不变性。

Answer 4

没有。如果 getter 只是简单地返回对成员的非常量引用，如下所示：

private:
    Object m_member;

public:
    Object &getMember() {
         return m_member;
    }

那么m_member 应该是公共的，并且不需要访问器。绝对没有必要将此成员设为私有，然后创建一个访问器，让 all 访问它。

如果你调用getMember()，你可以将结果引用存储到一个指针/引用，然后，你可以对m_member做任何你想做的事情，封闭类对此一无所知。就好像m_member 是公开的一样。

注意，如果getMember() 做了一些额外的任务（例如，它不只是简单地返回m_member，而是懒惰地构造它），那么getMember() 可能有用：

Object &getMember() {
    if (!m_member) m_member = new Object;
    return *m_member;
}

Answer 5

这取决于S 的用途。如果它是某种薄包装器，则允许用户直接访问底层值可能是合适的。

现实生活中的一个例子是std::reference_wrapper。