哪种方法更适合实现 get/set？

Question

有两种方法可以实现 get/set。

方法一：

分别定义get和set。

class my_class
{
  // ...
};

class main_class
{
public:

  my_class get_data() const
  {
    return m_data;
  }

  void set_data(my_class value)
  {
    m_data = value;
  }

private:

  my_class m_data;
};

注意：在此方法中 get 足够快： http://cpp-next.com/archive/2009/08/want-speed-pass-by-value

另一种方法是（方法2）：

定义两个get body，首先const和另一个非常量。

class my_class
{
  // ...
};

class main_class
{
public:

  const my_class& get_data() const
  {
    return m_data;
  }

  my_class& get_data() // Works like set.
  {
    return m_data;
  }

private:

  my_class m_data;
};

使用这些方法：

void main()
{
  main_class cls;

  // For method 1.
  my_class data;
  data = cls.get_data();
  cls.set_data(data);

  // For method 2.
  const my_class data1;
  my_class data2;
  data1 = cls.get_data();  // const get invoked.
  cls.get_data() = data2; // Like set beacuase non const get invoked.

}

我的问题是，这些实现 get/set 的方法中哪一个更好？

你知道更好的方法吗？

---

编辑： 对于认为方法 1 更好的答案，在以下情况下您会怎么说：

void main()
{
  main_class cls;

  // For method 1.
  cls.get_data().do_something_else(); // Not effictive for cls, because data losts.

  // For method 2.
  cls.get_data().do_something_else(); // Effictive for cls.    
}

Answer 1

您应该始终使用任何自定义类的引用来仅传递地址而不是值类。您还应该避免传回非常量引用进行编辑。请参阅下面的我的建议。

class my_class
{
  // ...
};

class main_class
{
public:

  const my_class & get_data() const
  {
    return m_data;
  }

  void set_data(const my_class & data)
  {
    m_data = data;
  }

private:

  my_class m_data;
};

Answer 2

我知道这不会是 C++ 纯粹主义者的流行答案，在我学习 Python 和 Ruby 之前，我不会提出这种可能性...但是...由于您提供的 getter 和 setter 不进行范围检查或特别的计算为什么不公开成员呢？

 class main_class
 {
  public:
    my_class my_data;
 }

当然，您将丢失 getter 上的 const，并且无法保证受到保护，但无论如何都不能保证这一点，因为您提供了一个修改成员的 set 函数。

Answer 3

第二个非常糟糕，因为它放弃了封装：您也可以将相应的字段公开，任何人都可以访问它，而您的对象不知道它。您无法根据正在更改的数据等执行范围检查或状态更新。

Answer 4

第二个将是一个非常糟糕的选择。拥有setter的原因是能够控制用户如何修改成员变量。如果您只是向用户提供对您的会员的引用，您将失去所有控制权。

所以你几乎只剩下第一种方法了。以下是您可能喜欢也可能不喜欢的两种变体：

// First Variation
// ---------------
// In this one both the setter and the getter have the same name
// (which is the same as the member they control). To get a
// variable you do `int i = foo.var()` and to set it you do
// `foo.var(6)`. 

class Some
{
  public:
    int var() const {
        return var_;
    }

    void var(int v) {
        var_ = v;
    }

  private:
    int var_;
};

// Second Variation
// ----------------
// You can also make the setter return a reference to `this`.
// This allows you to chain setters, which can _sometimes_ be
// more readable but it also has a few disadvantages.

class Employee
{
  public:
    Employee& salary(double dollars) {
        salary_ = dollars;
        return *this;
    }

    Employee& name(const string& n) {
        name_ = n;
        return *this;
    }

  private:
    double salary_;
    std::string name_;
};

// You can now do this...
Employee emp;
emp.name("John Barlick").salary(500.00);

// ... But this can become quite ugly if you chain a large amount
// of setters (you'd then probably have to break the lines in
// order to keep the code readable). It also is (technically)
// less efficient. 

// In case you have lots of setters you could probably do this:
// emp.name("John Barlick")
//    .salary(500.00)
//    .some(787);
//    .another('g');  

Answer 5

通常 getter/setter 定义为：

  const my_class& get_data() const
  {
    return m_data;
  }

  void set_data(const my_class& _data)
  {
    m_data = _data;
  }

Answer 6

首先，我认为这不是很有效

void set_data(my_class value)
{
  m_data = value;
}

您可能应该通过引用传递

void set_data(const my_class& value)
{
  m_data = value;
}

至于您应该选择哪种方法，请这样想 - 在您的第二种方法中，您返回对内部对象的引用，并且用户绝对可以自由地执行任何操作与它。使用第一种方法，您可以控制用户可以做什么或不能做什么。

Answer 7

虽然像方法 1 这样的标准 getter 和 setter 可以提供“封装”，但除非这些函数内联在标头中，否则它们会增加大量开销。例如，在紧密循环中，即使您使用引用而不是按值传递（这需要昂贵的内存复制操作），仍然必须在 x86 中为每次调用 getter/setter 添加大约 8 个指令在堆栈上设置其激活记录以及函数的序言和结尾会占用宝贵的 CPU 时间，并且确实会损害性能。由于你是 getter 而 setter 并没有做太多事情，所以你真的不需要它们。

方法 2 实际上是许多 STL 容器所做的事情，例如带有 operator[] 的 std::vector，您可以重载相同的函数，但为常量操作定义一个函数，另一个用于非常量操作......但是，当您可以公开访问数据成员时，您会增加不必要的开销（即，它不像您是来自的一些底层指针和其他内存管理数据成员）我们就像一个STL容器）。如果您传递给它的函数需要一个常量引用，那么它无论如何都不会更改该成员，因此实际上没有必要创建这样的接口，除非您尝试创建一个通用接口来跨主机访问成员类。如果您这样做，那么您应该研究纯虚拟基类来定义公共接口。

Answer 8

恕我直言，第二种方法看起来很尴尬。