why reture "const &"?

[zealotcat]

template <class T>
inline T const& max (T const& a, T const& b)
{
// if a < b then use b else use a
return a<b?b:a;
}

thanks very much!!

[Jonathan Mcdougall]

ze*******@gmail .com wrote:

why reture "const &"?

template <class T>
inline T const& max (T const& a, T const& b)
{
// if a < b then use b else use a
return a<b?b:a;
}

To prevent atrocities like

std::max(a, b) = 2;

and to allow passing and returning of rvalues.
Jonathan

[David White]

"Jonathan Mcdougall" <jo************ ***@DELyahoo.ca > wrote in message
news:Kc******** ************@we ber.videotron.n et...

ze*******@gmail .com wrote:

>
> why reture "const &"?
>
template <class T>
inline T const& max (T const& a, T const& b)
{
// if a < b then use b else use a
return a<b?b:a;
}

To prevent atrocities like

std::max(a, b) = 2;

Why is that an atrocity? You might want to assign the max of a and b to 2.

DW

[Niels Dekker - no reply address]

zealotcat at gmail.com wrote:

template <class T>
inline T const& max (T const& a, T const& b)
{
// if a < b then use b else use a
return a<b?b:a;
}

If you return by value (T) instead of by const reference (T const&), you
get a carbon copy of the maximum, not the original. When returning by
(const) reference, the class T doesn't need to have a copy contructor.

BTW, the "const" is necessary because your parameters are const
references as well. You might consider having a non-const version as
well:

template <class T>
inline T& max (T& a, T& b)
{
return a<b?b:a;
}

See also http://www.aristeia.com/Papers/C++Re...umns/jan95.pdf
Kind regards,

Niels Dekker
http://www.xs4all.nl/~nd/dekkerware

[Niels Dekker - no reply address]

zealotcat at gmail.com asked:

why return "const &"?
Jonathan Mcdougall replied: To prevent atrocities like

std::max(a, b) = 2;

What about calling some other non-const member function?

Suppose I'm programming a GUI, and I have an ordered group of buttons on
a window, so that I can say button A < button B. (E.g., based on tab
order.) I might want to do:

void MyFunc(Button & a, Button & b)
{
// Setting the "default property" (or whatever!)
// of the button that has the maximum value.
max(a, b).SetDefault(t rue);

}

Typically Button::SetDefa ult is a non-const member function. So I need
a max(a, b) that returns a non-const reference!
Kind regards,

Niels Dekker
http://www.xs4all.nl/~nd/dekkerware

[jeffc]

"David White" <[e-mail] ded> wrote in message
news:1_******** *********@nasal .pacific.net.au ...

To prevent atrocities like

std::max(a, b) = 2;

Why is that an atrocity? You might want to assign the max of a and b to 2.

Maybe so, but that code won't do it. max is a function that returns a value,
not a variable.

[Jonathan Mcdougall]

jeffc wrote:

"David White" <[e-mail] ded> wrote in message
news:1_******** *********@nasal .pacific.net.au ...

To prevent atrocities like

std::max(a , b) = 2;

Why is that an atrocity? You might want to assign the max of a and b to 2.

Maybe so, but that code won't do it. max is a function that returns a value,
not a variable.

std::max is a function that returns a const
reference, not a value nor a "variable".
Jonathan

[Jonathan Mcdougall]

Niels Dekker - no reply address wrote:

zealotcat at gmail.com asked:

why return "const &"?

Jonathan Mcdougall replied:

To prevent atrocities like

std::max(a, b) = 2;

What about calling some other non-const member function?

That is not what std::max was designed to do.
Suppose I'm programming a GUI, and I have an ordered group of buttons on
a window, so that I can say button A < button B. (E.g., based on tab
order.) I might want to do:

void MyFunc(Button & a, Button & b)
{
// Setting the "default property" (or whatever!)
// of the button that has the maximum value.
max(a, b).SetDefault(t rue);

}
That's quite an ugly function, imho. std::max
will do the correct thing if operator< is
implemented correctly, but getting the maximum or
minimum button makes no sense, whether they are
order by their text of tab stop order. That's a
misuse of std::max.
Typically Button::SetDefa ult is a non-const member function. So I need
a max(a, b) that returns a non-const reference!

Roll you own.
Jonathan

[Rolf Magnus]

simont wrote:

Writing
| max(5,7) = 2;
doesn't "assign the max of 5 and 7", because you can't change that.
That wouldn't work anyway, neither with a max that returns (and takes)
references (no matter whether they're const or not), nor with one that
returns by value. So that wouldn't be a problem anyway.
What would it mean to do so?
An error.
The function 'max' is usually considered to be returning the larger of
two values, rather than performing side-effects or anything else.
However, even std::max doesn't do this. It returns a const reference, not a
value.
Unless you meant something like

| template <typename T>
| T& larger_of( T& a, T& b ) { return a>b ? a : b; }

where

| int a(5);
| int b(7);
| // change the larger integer for some reason ...
| larger_of(a,b) /= 2;
might make sense. That isn't what max means, though.

max means whatever its programmer makes it mean. I don't see a need to call
it larger_of instead of max.

[David White]

"simont" <s_********@yah oo.co.uk> wrote in message
news:11******** **************@ z14g2000cwz.goo glegroups.com.. .

David White wrote:

"Jonathan Mcdougall" <jo************ ***@DELyahoo.ca > wrote in message

std::max(a, b) = 2;

Why is that an atrocity? You might want to assign the max of a and b

to 2.

You /can't/ "assign the max of a and b to 2" in any meaningful sense.
Writing
| max(5,7) = 2;
doesn't "assign the max of 5 and 7", because you can't change that.
What would it mean to do so? That I want globally to switch integer
arithmetic to modulo 5?

Of course not. I wasn't referring to constants. I was referring to a and b,
and you could have an l-value version of the template that would work in
that case. I'm not suggesting that such a template should be provided. I'm
just disagreeing that "std::max(a , b) = 2;" is an atrocity. It looks quite
neat and elegant to me, even if hardly anyone would ever need it.

DW