Const reference to extend object's life followed by const_cast, is it a good idea?

Question

Consider the following function that returns a big object:

std::list<SomethingBig> DoSomething()
{
    std::list<SomethingBig> TheList;
    //do stuff
    return TheList;
}

I want to get the list, not a copy of it. Because if I have to copy such objects, the performance price is expensive. I know return-value optimization may take care of this for me, but depending on optimizations to optimize bad code is not the best way to go (right?).

A clean way to avoid copying and extend the life of an object, is using a constant reference (and please test it before calling it a dangling reference, because it's not):

const std::list<SomethingBig>& theList = DoSomething();

In C++11, one could use std::move to avoid copying. However, I'm working on a C++03 program, and I have to do this:

const std::list<SomethingBig>& list1 = DoSomething();
const std::list<SomethingBig>& list2 = DoSomethingElse();

and now I need to splice the lists together. The only way for me to do that is either copy everything, or const_cast these lists and splice them. Is there a better solution?

Not sure, but I think that's a bad idea. And you can rely on RVO, why not? — Alexander Lapenkov, Apr 05 '17 at 11:20
@AlexanderLapenkov No particular reason except that I'd be depending on an optimization which may or may not exist to optimize some badly written code. I may do that if I don't have any other choice. — The Quantum Physicist, Apr 05 '17 at 11:22
@TheQuantumPhysicist Ok you splice the lists, what are you going to do with the data then? You either want to copy it somewhere or just iterate over the spliced list. Both operations can be done without even splicing the lists into one of these referenced. — Alexander Lapenkov, Apr 05 '17 at 11:38

Ap31 · Answer 1 · 2017-04-05T12:00:32.913

Just return it by value, it would be better than both reference and std::move due to NRVO, which is not an "optimization of a bad code", but a way to make good code work fast.

As far as I know NRVO is indeed not guaranteed to happen (as opposed to RVO, which will be a must since c++17), but it's extremely unlikely the compiler will not elide a copy here.

In any case, relying on copy elision is much safer than using const_cast tricks, and it's cheaper than a move.

Both clang and gcc elide the copy with -std=c++03 -O0

score 0 · Answer 2 · answered Apr 05 '17 at 14:49

0

What about changing interface of DoSomething...() to std::list<SomethingBig> & DoSomething(std::list<SomethingBig> &)? The life time of the list object would be controlled outside of DoSomething() and DoSomethingElse(). e.g.:

std::list<SomethingBig> list;
DoSomethingElse(DoSomething(list));

answered Apr 05 '17 at 14:49

Kuba Molski

86
3

Like I mentioned in the comments... it's not my function. – The Quantum Physicist Apr 05 '17 at 14:57

Const reference to extend object's life followed by const_cast, is it a good idea?

2 Answers2