References to temporaries and function-calls

struct foo {
  int i;
};

int bar(foo& f) {
  return f.i++;
}

int main() {
  bar(foo());
}

The above code does not compile since you can't bind a reference to a
temporary, you could solve this by using a 'const foo&' parameter
instead but then you have other problems (like trying to change the
value of a const). This much I understand, what I don't understand is
how come this is considered trying to bind a reference to a temporary,
are not all parameters supposed to be evaluated before the function is
executed? And these evaluations should take place in the same scope as
in which the function is called? While the function, including its
parameters, are executed in its own scope?

The way I see things the foo()-part of bar(foo()); should already have
executed (and thus have created a foo-object on the stack) when the
parameter f comes into scope* and thus, from the point of view of
bar() be non-temporary.

Or put another way, I can't quite see the difference between the
following two:
  bar(foo());
and
  foo f;
  bar(f);

Can someone please explain?

* Or is declared, or defined or whatever it is called.

--
Erik Wikstr=F6m