Re: Arguments in nested function calls

This is the implementation of class Field:
------------------------------------------------------------------
class Field {
friend std::ostream& operator <<(std::ostream&, const Field&);
public:
enum Format {F1, F2};

//...
Field& operator ()(Format f) { format = f; return *this; }

//...
private:
//...
Format format;
//...
};

std::ostream& operator <<(std::ostream& out, const Field& f)
{
 switch (f.format) {
 case Field::F1:
  return out << [f in F1 format];
 case Field::F2:
  return out << [f in F2 format];
 default:
  return out << [f in standard format];
 }
}
------------------------------------------------------------------
and this is an example of its intended use:
------------------------------------------------------------------
Field f;
std::cout << "Field in F1 format: " << f(Field::F1) << f << ", Field in F2
format: " << f(Field::F2) << f << std::endl;
------------------------------------------------------------------

The problem is that if written as above, class Field will not be output in
two different formats but two times in the same (first) format. If the
expression is split into two, so that the overloaded operator ()(Format)
is called only once per expression, then the output will be as intended.

I am trying to understand what is happening. As I see it, the above is
equivalent (roughly) to this:

operator <<(operator <<(std::cout, f(Field::F1)), f)
(or, in other words, to a set of nested function calls)

If it were only one function - something along these lines

Field f;
void function1(Field& f1, const Field& f2, Field& f3, const Field& f4);
function1(f(Field::F1), f, f(Field::F2), f);

then, since the order of argument creation is unspecified but they will
have to be created before the function call is made, I would really expect
one of the formats passed to get the upper hand, so that eventual output
will only display Field in one format. In the original example, however,
we have a number of nested functions called in the prescribed order, so
that even though within a single function call the creation of arguments
is unspecified, the order of function calls is set and so, I would
imagine, the creation of sets of arguments passed to each.

Also, from what I have observed, if an argument is a temporary, its
destructor is invoked when the function returns

void f1(A1);
A1 f2(A2);
A2 a2;
f1(f2(a2));

(so a2's destructor is invoked when f2 returns rather than f1)

If this is correct, a temporary's "scope" in a function call is until that
function returns, which again does not take me to some sort of a
conclusion as to why in the original example the argument appears to be
shared across function calls.

Paul