CODEWITHSUNDEEP
c++c++11
Bartek Banachewicz
Bartek Banachewicz

Reputation: 39390

What happens if I return literal instead of declared std::string?

Say we have an utility function:

std::string GetDescription() { return "The description."; }

Is it OK to return the string literal? Is the implicitly created std::string object copied?

I thought about always returning it like this:

std::string GetDescription() { return std::move(std::string("The description.")); }

But it's of course longer and more verbose. We could also assume that compiler RVO will help us a bit

std::string GetDescription() { return std::string("The description."); }

Yet still, I don't know what it really has to do, instead of what can it do.

Upvotes: 8

Views: 556

Answers (2)

utnapistim
utnapistim

Reputation: 27385

Is it OK to return the string literal? Is the implicitly created std::string object copied?

It is OK. What you get, is the (implicit) constructor for std::string, creating a local copy, returned then as a rvalue reference. Taking the result in client code into a string, will set that string from an rvalue reference.

If you use the second piece of code, you "say too much". The code is correct, and they are (almost) equivalent (they should be equivalent, but the optimizations that the compiler is permitted to perform in the first case are better*).

I would go for:

std::string GetDescription() { return std::string("The description."); }

This way it is explicit that you return a string, and the code is (almost) minimal: you rely on the std::string move-construction.

*) edited accordingly, after comment by @SteveJessop.

Upvotes: 1

Sarfaraz Nawaz
Sarfaraz Nawaz

Reputation: 361622

std::string GetDescription() { return "XYZ"; }

is equivalent to this:

std::string GetDescription() { return std::string("XYZ"); }

which in turn is equivalent to this:

std::string GetDescription() { return std::move(std::string("XYZ")); }

Means when you return std::string("XYZ") which is a temporary object, then std::move is unnecessary, because the object will be moved anyway (implicitly).

Likewise, when you return "XYZ", then the explicit construction std::string("XYZ") is unnecessary, because the construction will happen anyway (implicitly).

So the answer to this question:

Is the implicitly created std::string object copied?

is NO. The implicitly created object is after all a temporary object which is moved (implicitly). But then the move can be elided by the compiler!

So the bottomline is this : you can write this code and be happy:

std::string GetDescription() { return "XYZ"; }

And in some corner-cases, return tempObj is more efficient (and thus better) than return std::move(tempObj).

Upvotes: 14

Related Questions