C++ 中访问器方法（getter 和 setter）的约定；

Question

关于 C++ 中的访问器方法的几个问题已经在 SO 上被问到了，但没有一个能够满足我对此问题的好奇心。

我尽可能避免访问器，因为像 Stroustrup 和其他著名程序员一样，我认为一个类中有很多访问器是糟糕的 OO 的标志。在 C++ 中，在大多数情况下，我可以向类添加更多责任或使用friend 关键字来避免它们。但在某些情况下，您确实需要访问特定的类成员。

有几种可能性：

1。根本不使用访问器

我们可以将相应的成员变量公开。这在 Java 中是不允许的，但在 C++ 社区中似乎没问题。但是，我有点担心应该返回对象的显式副本或只读（const）引用的情况，这是否夸张？

2.使用 Java 风格的 get/set 方法

我不确定它是否来自 Java，但我的意思是：

int getAmount(); // Returns the amount
void setAmount(int amount); // Sets the amount

3.使用目标 C 风格的 get/set 方法

这有点奇怪，但显然越来越常见：

int amount(); // Returns the amount
void amount(int amount); // Sets the amount

为了使其工作，您必须为您的成员变量找到一个不同的名称。有些人附加下划线，其他人则附加“m_”。我也不喜欢。

您使用哪种风格？为什么？

Answer 1

让我告诉你另一种可能性，这似乎是最简洁的。

需要阅读&修改

只需声明该变量 public:

class Worker {
public:
    int wage = 5000;
}

worker.wage = 8000;
cout << worker.wage << endl;

只需要 read

class Worker {
    int _wage = 5000;
public:
    inline int wage() {
        return _wage;
    }
}

worker.wage = 8000; // error !!
cout << worker.wage() << endl;

这种方法的缺点是，当您想要更改访问模式时，您需要更改所有调用代码（即添加括号）。

Answer 2

#3 的变体，我被告知这可能是“流畅”的风格

class foo {
  private: int bar;
  private: int narf;
  public: foo & bar(int);
  public: int bar();
  public: foo & narf(int);
  public: int narf();
};

//multi set (get is as expected)
foo f; f.bar(2).narf(3);

Answer 3

从我的角度来看，从维护的角度来看，拥有 400 万行 C++ 代码（这只是一个项目），我会说：

• 如果成员是不可变的（即 const) 或没有依赖关系的简单（如具有成员 X 和 Y 的点类）。

• 如果成员是私有，那么跳过 getters/setters 也是可以的。如果 . cpp 单元很小。

• 如果成员是public或protected（protected与public一样糟糕code>) 和非 const、非简单或具有依赖项，则使用 getter/setter。

作为一名维护人员，我想要拥有 getter/setter 的主要原因是因为这样我就有地方放置断点/日志记录/其他东西。

我更喜欢替代方案 2. 的风格，因为它更易于搜索（编写可维护代码的关键组成部分）。

Answer 4

2）是最好的IMO，因为它让你的意图最清晰。 set_amount(10) 比 amount(10) 更有意义，并且一个很好的副作用是允许名为 amount 的成员。

公共变量通常是一个坏主意，因为没有封装。假设您需要在更新变量时更新缓存或刷新窗口？如果你的变量是公共的那就太糟糕了。如果您有设置方法，则可以将其添加到此处。

Answer 5

1. 我从不使用这种风格。因为它会限制类设计的未来，并且显式的 getter 或 setter 与良好的编译器一样高效。

   当然，实际上，内联显式 getter 或 setter 会创建对类实现同样多的底层依赖。它们只是减少语义依赖性。如果更改它们，您仍然必须重新编译所有内容。

2. 这是我使用访问器方法时的默认样式。

3. 这种风格对我来说似乎太“聪明”了。我确实在极少数情况下使用它，但仅在我真正希望访问器尽可能感觉像变量的情况下。

我确实认为有一个简单的变量袋可能带有构造函数的情况，以确保它们都被初始化为正常的东西。当我这样做时，我只需将其设为一个struct 并将其全部公开。

Answer 6

1. 如果我们只想表示纯数据，这是一个很好的风格。

2. 我不喜欢它:)因为当我们可以在C++中重载它们时，get_/set_实际上是不必要的。

3. STL 使用这种样式，例如 std::streamString::str 和 std::ios_base::flags，除非应该避免！什么时候？当方法的名称与其他类型的名称冲突时，则使用 get_/set_ 样式，例如 std::string::get_allocator 因为 std::allocator< /code>.

Answer 7

总的来说，我觉得系统中太多的实体使用太多的 getter 和 setter 并不是一个好主意。这仅表明设计不良或封装错误。

话虽如此，如果这样的设计需要重构，并且源代码可用，我更愿意使用访问者设计模式。原因是：

a.它让班级有机会
决定允许谁访问其
私人国家

b.它给了一个类一个
有机会决定访问什么
允许每个实体
对其私有状态感兴趣

c.它
清楚地记录此类外部访问
通过清晰的类接口

基本思想是：

a) 如果可能的话重新设计，

b)
重构使得

1. 对类状态的所有访问都是通过众所周知的个人主义
   界面

2. 应该可以配置某种该做和不该做的事情
   到每个这样的接口，例如所有
   来自外部实体的访问好
   应该允许，所有访问来自
   外部实体BAD应该是
   不允许，外部实体确定
   应该允许获取但不允许设置（例如）

Answer 8

1. 我不会排除访问器的使用。对于某些 POD 结构可能是这样，但我认为它们是一件好事（某些访问器也可能有额外的逻辑）。

2. 如果代码保持一致，命名约定并不重要。如果您使用多个第三方库，它们可能会使用不同的命名约定。所以这是一个品味问题。

Answer 9

我已经看到类的理想化而不是整数类型来引用有意义的数据。

像下面这样的东西通常没有很好地利用 C++ 属性：

struct particle {
    float mass;
    float acceleration;
    float velocity;
} p;

为什么？因为 p.mass*p.acceleration 的结果是浮点数，而不是预期的力。

指定用途的类定义（即使它是一个值，如前面提到的 amount）更有意义，并允许我们执行以下操作：

struct amount
{
    int value;

    amount() : value( 0 ) {}
    amount( int value0 ) : value( value0 ) {}
    operator int()& { return value; }
    operator int()const& { return value; }
    amount& operator = ( int const newvalue )
    {
        value = newvalue;
        return *this;
    }
};

您可以通过运算符隐式访问 amount 中的值国际。此外：

struct wage
{
    amount balance;

    operator amount()& { return balance; }
    operator amount()const& { return balance; }
    wage& operator = ( amount const&  newbalance )
    {
        balance = newbalance;
        return *this;
    }
};

Getter/Setter 用法：

void wage_test()
{
    wage worker;
    (amount&)worker = 100; // if you like this, can remove = operator
    worker = amount(105);  // an alternative if the first one is too weird
    int value = (amount)worker; // getting amount is more clear
}

这是一种不同的方法，并不意味着它是好还是坏，而是不同。

Answer 10

另一种可能性是：

int& amount();

我不确定我是否会推荐它，但它的优点是不寻常的符号可以阻止用户修改数据。

str.length() = 5; // Ok string is a very bad example :)

有时这可能是一个不错的选择：

image(point) = 255;  

---

另一种可能性是，使用函数符号来修改对象。

edit::change_amount(obj, val)

这样，危险/编辑功能就可以通过它自己的文档放在一个单独的命名空间中。这似乎是泛型编程中自然而然的事情。