Why the standard does not allow to pass temporaries by non-const reference?

Question

I've read a lot about how the standard does not allow temporaries to be passed by non-const reference, but I could find anything convincing on why is that.

The usual argument I encounter is that it is unsafe because the lifetime of the value is unknown. But in reality it is not, it is bound to the function, whose parameter it is, and will remain "alive" until that function returns, so it is safe to use it inside that function, pass it to another function inside it and another... Basically as long as it is all synchronous execution, it should be safe, since the object will remain there until the first function receiving it returns.

What is the fundamental difference between the two approaches?

doSomething(createSomething());

{
    something s = createSomething();
    doSomething(s);
}

aside from the second one unnecessarily polluting the scope with an identifier for an object you will only use once.

The way I see it, the fact that it is a temporary only limits the potential to do damage, since it will no longer be used after that function call.

Can someone provide a snipped with what kind of bad things may happen in practice by passing a temporary by reference?

Also, my question is strictly pre-c++11, so rvalue references are outside its scope.

EDIT: From the linked question, sbi's answer:

// this doesn't compile: 
g(getx()); // g() would modify an object without anyone being able to observe

But that implies that the only reason one would ever pass something by reference is to be able to observe changes made in that function after it has returned. Now, OBVIOSLY, if you use a temporary it goes without saying this is not part of your intent, nor is the reason just mentioned the only reason one would pass by reference. Which is why the scope of that question is not the same as the one labeled duplicate. You are just as likely to pass by reference to avoid a costly copy and your design can involve use of that object which is entirely encapsulated within that function and functions called within.

That other question focuses on one use of pass by reference and doesn't explain what could go wrong, nor does it take into consideration the very fact that using a temporary negates that one concern the answers address. It basically answers "because it would modify an object without anyone being able to observe", which is rightfully presented as pointless, but which is CLEARLY not the intent when you use a temporary in the first place.

To put it in other words, the answer says "You can't do it, because you can't observe the changes when you don't want to observe the changes"... DO'H How can the limitation be the inability to do something you clearly don't want to do?

Answer 1

The reason is that Mr Stroustrup reasoned that passing a reference to a mutable temporary would in all likelihood be the result of a programming error - since the result of any computation in the temporary cannot be accessed after the function call.

example:

struct foo {...};

func(foo());
// the foo has already been destroyed here, so any modified state is inaccessible.

In fairness, despite this looking short-sighted since the development of r-value references his reasoning was sound. Although it might require one more line of code, there is always a way to achieve the same effect.

examples:

{
  foo f;
  func(f);
}

or

foo_func();

where:

void foo_func() {
  foo f;
  func(f);
}

and here's a requote of the example that I have seen cited as the reason you can't bind a mutable temporary to an l-value in a function call. The bug is subtle, but serious and very difficult to find:

void inc(int& arg) { arg++; }

typedef long MyInt;

int main() {
  MyInt i = 0;
  inc(i);  // <<-- HINT: implicit conversion from long to int creates a temporary COPY, not reference
  if (i == 1) {
     // Life-saving logic
  }
}

source: comp.lang.c++.moderated