How is this code working?

I am working with the company code and I see this:

ClassName(/* bunch of parameters */)
  .someFunc(/* bunch of parameters */)
  .someFunc(/* bunch of parameters */)
  .someFunc(/* bunch of parameters */)
  ;

开发者_运维百科Now I have never seen this and didn't know something like this could work (the code compiles in the company solution) so I tried it out but I had no such luck. The code failed to compile due to incorrect syntax. I am baffled as to how it is working on the company's solution...? Maybe I am overlooking something?

This technique is called Method Chaining. It basically works by returning a reference to *this in every method that you call. This allows you to directly call another method on the returned object (called chaining).

Huh? What's strange about this? Doesn't this just mean that someFunc() is declared like so:

ClassName& someFunc(/*arguments*/)
{
  /*do stuff*/
  return *this;
}

in order to support chaining? Just like the stream operators?

someObj.someFunc() may return a reference to someObj, like this:

class ClassName {
    ClassName &someFunc() {
        return *this; // return current object, nothing created
    }
};

ClassName someObj;

someObj.someFunc().someFunc(); // chain function calls on same object
ClassName().someFunc().someFunc(); // same, but now object is a temporary

This also works with a direct object return type, as opposed to a reference. In this pattern, the object may be modified at each step.

class ClassName {
    ClassName increment() const {
        return *this + 1; // return a newly created object
    }
};

ClassName someObj;
someObj.increment().increment(); // does not modify someObj, returns temporary

The key to understanding such code always lies in looking at the declaration of the function of interest.