在成员函数中返回 *this

发布于 2024-10-15 15:38:58 字数 290 浏览 2 评论 0原文

我最近使用了一个允许以下类型语法的库：

MyClass myObject;
myObject
    .setMember1("string value")
    .setMember2(4.0f)
    .setMember3(-1);

显然，这是通过让设置器返回 MyClass & 来完成的。类型;像 return *this 这样的东西。我喜欢这段代码的外观，但我不常看到它。当这种情况发生时，我通常会怀疑为什么。

那么，这是一个不好的做法吗？这样做有什么影响？

原文

I recently used a library that allows the following type of syntax:

MyClass myObject;
myObject
    .setMember1("string value")
    .setMember2(4.0f)
    .setMember3(-1);

Obviously this is accomplished by having the setters return a MyClass & type; something like return *this. I like the way this code looks, but I don't see it a lot. When that happens I'm usually suspicious as to why.

So, is this a bad practice? What are some of the implications of doing it like this?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

烟酒忠诚 2024-10-22 15:38:58

这有时被称为命名参数惯用语或方法链接。这不是坏习惯，它可以提高可读性。考虑这个来自 C++ FAQ 的示例

File f = OpenFile("foo.txt")
            .readonly()
            .createIfNotExist()
            .appendWhenWriting()
            .blockSize(1024)
            .unbuffered()
            .exclusiveAccess();

另一种方法是使用 OpenFile 方法的位置参数，要求程序员记住每个参数的位置。

This is sometimes referred to as the Named Parameter Idiom or method chaining. This isn't bad practice, it can aid readability. Consider this example lifted from the C++ FAQ

File f = OpenFile("foo.txt")
            .readonly()
            .createIfNotExist()
            .appendWhenWriting()
            .blockSize(1024)
            .unbuffered()
            .exclusiveAccess();

The alternative would be to use positional arguments to the OpenFile method, requiring the programmer to remember the position of each argument.

回复收藏 0 原文

划一舟意中人 2024-10-22 15:38:58

有些人称之为流畅编程（或流畅界面）。其他人称之为一团糟。

我倾向于后一个阵营。特别是，我的经验是，在许多情况下，人们以这种方式编写代码依赖于“流畅的接口”来初始化对象。换句话说，尽管进行了伪装，但它仍然是两步初始化。同样，尽管在许多情况下它可能是可以避免的，但它似乎经常导致相当多本应完全属于类的私有内容通过操纵器公开修改。

就我个人而言，我更喜欢对象在创建后是不可变的。显然这并不总是可能的，在某些情况下你甚至无法非常接近。尽管如此，您对外部操作开放的对象内部越多，您对该对象保持一致状态的把握就越少（通常，您需要做更多的工作来维持一致状态）。

回复收藏 0 原文

空名 2024-10-22 15:38:58

您的示例不是命名参数习惯用法。

使用命名参数习惯用法，可链接设置器设置参数（参数）包的属性。

相反，您的代码有一堆用于修改您正在构造的最终对象的设置器，称为两阶段构造。

一般来说，两阶段构造只是 Bad™，而通过向客户端代码公开属性来实现的两阶段构造（如您的示例中）是 Very Bad™。

例如，一旦文件对象被构造（并且可能文件被打开），您通常不希望能够修改该对象的属性。

干杯&呵呵，

回复收藏 0 原文

隱形的亼 2024-10-22 15:38:58

这是一种常见的做法。 operator= 的重载意味着对链调用执行此操作：

class Foo {

public:
   Foo& operator=(const Foo& f) { 
      if (this != &f) { // check for self-assignment
         // do some stuff...
      }
      return *this;
   }

};

此代码允许执行以下操作：

Foo a, b, c;
a = b = c;

请注意，检查自分配是强制性的，因为您经常必须释放当前对象中的内容，因此允许 a = a 会破坏你的代码。

根据 @Fred Nurk 的评论，我想补充一点，您应该看看复制和交换习惯用法，以避免代码重复并发出无异常代码。
请查看下面的链接以获取更多信息：

什么是复制和-交换习语？
http://gotw.ca/gotw/059.htm

It's a common practice. The overloading of operator= implies to do so to chain calls:

class Foo {

public:
   Foo& operator=(const Foo& f) { 
      if (this != &f) { // check for self-assignment
         // do some stuff...
      }
      return *this;
   }

};

This code allows to do things like:

Foo a, b, c;
a = b = c;

Please note that checking for self-assignment is compulsory because you often have to deallocate stuffs in the current object, so allowing a = a would break your code.

Following @Fred Nurk's comment, I'd like to add that you should have a look at the Copy-and-Swap idiom in order to avoid code duplication and issue an exception-free code.
Have a look at the links hereunder for more information:

What is the copy-and-swap idiom?
http://gotw.ca/gotw/059.htm

回复收藏 0 原文