Why not non-const reference to temporary objects? [duplicate]

Question

Possible Duplicate:
Does a const reference prolong the life of a temporary?
prolonging the lifetime of temporaries

C++ allows assignment of temporary objects only to const reference. It wont allow assignement of temporary objects to reference.

For example:

String& a = String("test");         // Error const String& a = String("test");   // Ok 

Everywhere I google for this result, i only see the following answers

1. Modifying temporary objects would cause unidentifiable problems
2. Modifying temporary objects is dangerous
3. At some point of time, you will forget it is a temporary variable

It's been said, temporary objects vanishes after the statement. So you should not modify it.

If C++, is so keen in blocking modifying the temporary objects, it should have blocked reading the temporary objects right? If the temporary object is vanished, then there is no point in reading contents from there right? The possible cases, where a right can occur, could also involve the read too.

Then why its been blocking write alone and allowing read?

Please give me a solid c++ code explanation.

Please dont deviate the question by pointing some alternatives. Please give me solid answer with code why const int & is allowed and int & is not allowed for temporary objects.

One says && is there.. My question different.. ANother say,changing will not reflect.. Changing will not reflect even when it is const int & too. Eg: double a; Const int & i = a; a++; will not affect i..

Answer 1

The original case for not allowing references to temporaries was for function parameters. Suppose this was allowed:

void inc(double& x) { x += 0.1; }  int i = 0; inc(i); 

Why isn't i changed?

Answer 2

If C++, is so keen in blocking modifying the temporary objects, it should have blocked reading the temporary objects right? If the temporary object is vanished, then there is no point in reading contents from there right?

No, reading the object is perfectly sensible. Just because it's going to vanish in the future doesn't mean reading the data now is pointless.

open_file(std::string("foo.txt")); 

std::string("foo.txt") is a temporary which will stop existing after the call to open_file() but the data it contains while it does exist matters very much.

The rational for not allowing temporaries bind to non-const references isn't actually some fundamental problem with writing to temporaries. In fact in many places C++ is perfectly happy to allow temporaries to be modified:

std::string("foo") = "bar"; 

It's just that the designers felt that it would cause a sufficient number of problems (probably due to the common idiom of 'out parameters') without enabling anything of similar value, so they simply made a design decision to prohibit temporaries binding to non-const references.

With rvalue references now you can do exactly what was prohibited before:

void foo(int &&output) {     output = 1; }  foo(2); 

This works fine, it's just not very useful.