Re: Rationale of non-const reference to temporaries
On 1 Dez., 20:52, eca <enrico.ecam...@gmail.com> wrote:
I would like to submit the following code to your attention:
#include <string>
#include <iostream>
void f(std::string& s)
{ std::cout << s << std::endl; }
int main(int argc, char* argv[])
{
std::string s("Hello world");
f(s); // <- This is ok
f(std::string("Hello world")); // <- This is incorrect (g++)
return 0;
}
It compiles without errors on VC++ 8.0 (2005), while on gcc 4.1.2
(and later) it gives the following error:
g++ -O2 -g -Wall -fmessage-length=0 -c -o main.o main.cpp
main.cpp: In function 'int main(int, char**)':
main.cpp:11: error: invalid initialization of non-const reference of
type 'std::string&' from a temporary of type 'std::string'
main.cpp:4: error: in passing argument 1 of 'void f(std::string&)'
make: *** [main.o] Error 1
What I know is that temporaries can be passed as const references
and that VC allows passing them as non-const references as an
extension to the standard.
What I don't know precisely is whether there is any potential risk
of error in doing as above.
Could you help me understand the rationale of the two approaches?
Let me first add that you can enforce the VC compiler to
use the standard-conforming behavior to reject your code
example by activating the "Disable language extensions"
mode (Add /Za).
The reason why standard C++ decided the rules is to provide
a safety belt for you: Usually an object addressed per mutable
lvalue reference as above is supposed to modify this thingee
and that this changed state in this thingee can be evaluated
later. Now consider the following example, which was the
showstopper for allowing rvalues (like temporaries) to be
acceptable arguments for lvalue-references:
void inc(int& arg) { arg++; }
typedef long MyInt;
int main() {
MyInt i = 0;
inc(i);
if (i == 1) {
// Life-saving logic
}
}
Should this program be well-formed? If yes, how do you
estimate the chances, that this kind of *error* - hidden
in some complex software, will be finally found and fixed?
What happens in my example is that i is converted into
a *temporary* of type int, which is the actual argument
of inc. So, the seemingly induced change i never happens,
because *only* the temporary itself is modified here!
And this kind of code example was the reason, why C++
decided for the current rules in this regard.
Now, as your example implies: Sometimes we would really
like the behavior, that the compiler accepts a temporary
as a mutable references (e.g. in those cases, where we
are not interested in the final result of the temporary.
C++0x added so-called rvalue-references which would
make your snippet well-formed:
#include <string>
#include <iostream>
void f(std::string&& s) // <- Note the && here!
{ std::cout << s << std::endl; }
int main(int argc, char* argv[])
{
std::string s("Hello world");
f(s); // <- This is ok
f(std::string("Hello world")); // <- This is *now* also ok!
return 0;
}
HTH && Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]