ansaurus

Question

passing a string literal to a function that takes a std::string&

Answer 1

+11 A:

Your function needs to take const std::string& for you to use it like that.

C++ has a rule that an rvalue (in your case, a temporary std::string which is created from the string literal) can be bound with a const reference, but not a non-const reference.

As far as I know, this restriction isn't due to any fundamental implementation problem, since temporary values can be modified in other ways. But a function which takes a non-const reference is assumed to do so because its main purpose is to modify that argument. It doesn't usually make a lot of sense to do that with a temporary, so possibly banning it catches errors far more than it prevents people doing something worthwhile. Anyway, not all rvalues are temporaries: some are literals which really cannot be modified.

If you can't change the function AddNodeValue, then you can work around it:

std::string valstr("modvalue");
document.AddNodeValue(modvalue, valstr);
// valstr might have changed, check the documentation of AddNodeValue

Steve Jessop 2010-10-28 15:14:39

The limitation basically exists to enforce the reference semantics. Reference is meant to be used with valid and persistent objects. Sure you can create an invalid reference by returning a reference to local value but that is a semantic error.

Let_Me_Be 2010-10-28 15:28:38

@Let_Me_Be: right (assuming by "reference" you mean "non-const reference" - obviously const references are not meant to be used only with persistent objects). The next question, then, is *why* non-const references are meant to be used with valid and persistent objects, and AFAIK it's because it usually doesn't make a lot of sense to modify objects which aren't. C++0x provides a new kind of reference for objects which are valid but not persistent, which is nice for those occasions when it does make sense to modify such objects.

Steve Jessop 2010-10-28 15:34:36

@Steve Yes, C++0x provides l-value references. The whole point of reference (internally is still a pointer) is that it is heavily limited (by being bound to some existing object, non-null, etc...). Therefore much more interesting optimizations can be provided by the compiler.

Let_Me_Be 2010-10-28 15:38:22

@Let_Me_Be: right, but nothing you have said is any different for const and non-const references, so nothing you have said can possibly account for the rule that one can be bound to an rvalue, and the other cannot. The explanation of that lies elsewhere, and that's what I'm (I admit) guessing at. Whether references are "still pointers" internally is an implementation detail, and the situations where good optimizations are possible with references are precisely the situations where there will *not* be any pointer under the covers.

Steve Jessop 2010-10-28 16:01:12

@Steve For const this rule doesn't matter. You can only read from a constant therefore it doesn't matter if it stops existing after the command.

Let_Me_Be 2010-10-28 16:03:21

ansaurus

tags:

views:

answers:

passing a string literal to a function that takes a std::string&

related questions