what happens to the last return *this c++?

Question

  Time &Time::setHour( int h ) 
  {
     hour = ( h >= 0 && h < 24 ) ? h : 0; 
     return *this; 
  } 


  Time &Time::setMinute( int m ) 
  {
     minute = ( m >= 0 && m < 60 ) ? m : 0; 
     return *this;  
  } 


  Time &Time::setSecond( int s ) 
  {
     second = ( s >= 0 && s < 60 ) ? s : 0; 
    return *this; 
   }

int main()
{
    Time t;     
    t.setHour( 18 ).setMinute( 30 ).setSecond( 22 );
    return 0;
}

I understand the cascaded member function call, but I don't understand how t.setHour( 18 ).setMinute( 30 ).setSecond( 22 ); is left hanging, doesn't it have to be assigned to something since it still returns *this after it's done cascading? Why is it ok to leave it like that?

It allows you to keep chaining IF you want, else the value is ignored in main() since there are no lvalues in your chain. — xd6_, Mar 06 '14 at 19:14
It's kinda like pullin' a train on the captain of the cheer team. Everybody does it. — Captain Obvlious, Mar 06 '14 at 19:31

Ben Voigt · Accepted Answer · 2014-03-07T00:05:56.363

10

The value of the expression which is used as a statement is discarded. It's the same thing that happens when you write

scanf("%d", &i);

You did know that scanf has a return value, right? And so does ++i in

for( int i = 0; i < 10; ++i )

And even

x = 5;

is throwing away the result of the expression.

There are lots of expressions and functions with return values that are only marginally useful. If you want to write the code in a way that makes it clear the return value is ignored intentionally and not by accident, cast to void:

(void) scanf("%d", &i);

This should silence compiler warnings about ignored return values.

These variations are also valid but a bit sillier:

(void)++i;
(void)(x = 5);

edited Mar 07 '14 at 00:05

answered Mar 06 '14 at 19:15

Ben Voigt

277,958
43
419
720

do you have a Standard quote, in particular are you sure that there is also no code being generated for the return value? – TemplateRex Mar 06 '14 at 20:25
I never claimed the return value won't be calculated. In practice it will be when there is a real function call, and code for determining return value will be optimized away when the call is inlined. – Ben Voigt Mar 06 '14 at 20:58
Didn't mean to imply that you claimed that, sorry, I was just asking whether you know if the Standard has anything to say about it? Perhaps it's under the as-if rule, and in QoI territory? – TemplateRex Mar 06 '14 at 21:00
A better example than `scanf` is "Hello, world" in C++: `std::cout << "Hello, world!" << std::endl;` The return value from the stream insertion operator is `*this`. The last one is dropped on the bit floor, just as is the 5 returned by `x = y = z = 5;` – David Hammen Mar 06 '14 at 21:06

Moo-Juice · Answer 2 · 2014-03-06T21:00:10.617

7

This is called a "fluent syntax", "fluent interface", or "method chaining". You are utterly free to ignore/throw-away/don't bother with a return value if it is provided (but you're not interested in it). It makes chaining function calls together easier (and which boat you sit in on whether that is good or bad is entirely up to you).

Therefore, each method is returning *this to allow you to chain these calls together, but the last one is just dumped, ignored, not used.

This is perfectly fine.

edited Mar 06 '14 at 21:00

answered Mar 06 '14 at 19:13

Moo-Juice

38,257
10
78
128

2

Also called "fluent interface" – user703016 Mar 06 '14 at 19:17

score 2 · Answer 3 · answered Mar 06 '14 at 20:43

Since someone asked for a standard citation in a comment...

This is called an "expression statement". The C++11 standard says this about it:

6.2 Expression statement [stmt.expr]

Expression statements have the form
expression-statement:
    expression (opt);
The expression is a discarded-value expression (Clause 5). All side eﬀects from an expression statement are completed before the next statement is executed. An expression statement with the expression missing is called a null statement. [Note: Most statements are expression statements — usually assignments or function calls. A null statement is useful to carry a label just before the } of a compound statement and to supply a null body to an iteration statement such as a while statement (6.5.1). — end note]

Regarding the "discarded-value expression", Clause 5 says:

In some contexts, an expression only appears for its side eﬀects. Such an expression is called a discarded-value expression. The expression is evaluated and its value is discarded. ...

score 1 · Answer 4 · answered Mar 06 '14 at 19:26

It is just an expression statement, doing meaningful stuff via the side effects within the function calls.

You don't have to do anything with the value of an expression.

int f(int x) { return x * x; } 
int main(int argc, char* argv[]) { f(2); }

is legal C++.

If you want to verify it, check a C++ grammar, e.g. http://homepages.e3.net.nz/~djm/cppgrammar.html

statement:
  labeled-statement
  expression-statement
  compound-statement
  selection-statement
  iteration-statement
  jump-statement
  declaration-statement
  try-block
// ..
expression-statement:
    expression;  // opt.

what happens to the last return *this c++?

4 Answers4