Re: Arguments in nested function calls
Paul <vhr@newsgroups.nospam> wrote:
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;
------------------------------------------------------------------
That's not guaranteed to work as you seem to intend. For example, it is
possible that f(Field::F2) is called first, then f(Field::F1), and then
all the operator<< calls in the order written.
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
That does not change anything. Consider:
func(x, y, z);
You acknowledge that x, y and z may be evaluated in an arbitrary order
before func() is called. Consider further:
func(func(x, y), z);
It is unspecified whether func(x, y) is evaluated before or after z. So
one possible evaluation order is z, y, x, func(x, y), func(func(x, y),
z). Now suppose x is cout, y is f(F1), z is f(F2) and func is
operator<<. You end up with f output twice in format F1.
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)
a2 is not even a temporary, it's destructor is called when it goes out
of scope. A temporary is created when a copy of a2 is passed to f2. From
C++ standard 5.2.2/4: "The lifetime of a parameter ends when the
function in which it is defined returns." Thus it is correct to destroy
the A2 temporary right after f2 returns.
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.
I fail to see how this discussion of temporaries applies to your
example, where everything is being passed by reference and no
temporaries are created.
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925