is there any specific case where pass-by-value is preferred over pass-by-const-reference in C++?

Question

I read that they are conceptually equal. In practice, is there any occasion that

foo(T t) 

is preferred over

foo(const T& t)

? and why?

---

Thanks for the answers so far, please note I am not asking the difference between by-ref and by-val.

Actually I was interested in the difference between by-const-ref and by-val.

I used to hold the oipinion that by-const-ref can replace by-value in call cases since even Herb Sutter and Bjarne said they are conceptually equal, and "by ref"(be it const) implies being faster. until recently, I read somewhere that by-val may be better optimized in some cases.

Then when and how?

Answer 1

Built-in types and small objects (such as STL iterators) should normally be passed by value.

This is partly to increase the compiler's opportunities for optimisation. It's surprisingly hard for the compiler to know if a reference parameter is aliasing another parameter or global - it may have to reread the state of the object from memory a number of times through the function, to be sure the value hasn't changed.

This is the reason for C99's restrict keyword (the same issue but with pointers).

Answer 2

If you want to locally modify t (without affecting the original) in the body of your method (say in the process of calculating something), the first method would be preferential.

Answer 3

If the object being passed is a smart pointer (i.e. it does its own reference counting) then passing by value might be more reasonable.

I realize that's sort of a sideways answer to your question - the object wrapped by the smart pointer is not copied when passed by value, so it's more similar to passing by reference in that case. Nevertheless, you don't need "by reference" semantics in this case.

There is a problem with my line of reasoning so far, though - you'll lose the "const-ness" of the argument by passing by value. Perhaps you should just use the "by reference" semantics after all...

Answer 4

Don't forget that there are cases where there is a difference - when you're dealing with objects that have strange copy/assignment semantics.

auto_ptr<> is the classic example - pass those around by value without thinking about the consequences and you may end up with a mess.

Answer 5

In addition, foo(T t) is normally used when T is a simple type (int, bool, etc).

Answer 6

Another case that hasn't been mentioned is heavy use of the object. Let's say you pass a struct with 5 ints as members. If you are going to be accessing all 5 quite a lot in your function, there comes a point when the dereference cost outweighs the copy cost. However, you'd have to run a profiler to know when that is.

I should point out, though, that things like STL containers, which allocate memory on the heap, should almost never be passed by value if avoidable, because heap allocation is very slow compared to stack allocation.

Answer 7

Here is a case when you don't have other option but only to pass a parameter by value. Of course boost does handle this. But without boost we have to pass a Value to function by value.

class Test
{
public:
    Test()
    {
        std::set<std::string> values;
        values.insert("A");
        values.insert("V");
        values.insert("C");

        std::for_each(values.begin(), values.end(), 
                bind1st(mem_fun(&Test::process), this));
    }

private:
    void process( std::string value )
    {
        std::cout << "process " << value << std::endl;
    }
};

Answer 8

The reason pass by const reference and by value are conceptually the same is that neither can modify the original.

Normally, I am big fan of pass by value because it creates code that avoids many of the complexities that occur when multiple threads are sharing access to common data.

That said, it does potentially make you're code slower. My take in the past has always been to prefer pass by value unless I know their is (or will be) a performance problem by doing so. I may have to modify this slightly to include pass by const reference as an even better option.

Answer 9

If the most straightforward implementation of the function involves modifying the parameter value locally, then it makes sense to pass it by value rather than by const reference

For example, the one line version of strcpy:

char *strcpy(char *dest, const char *src)
{
   while (*dest++ = *src++);

   return s1;
}

If you took in the pointers as const references, you would need to copy them to temporaries in the body of your program, rather than letting the paramater passing mechanism do it for you.

Answer 10

Two very specific cases:

When you are writing assignment operators with strong exception guarantees you can either write them like

X& X::operator=(const X& orig)
{
    X tmp(orig);
    swap(this, tmp);
    return *this;
}

or you can recognize that the first thing that happens is that you make a copy and just have it done as part of the call

X& X::operator=(X tmp)
{
    swap(this, tmp);
    return *this;
}

If you have a smart pointer with ownership semantics, e.g. auto_ptr, and you want to transfer ownership to the called function you should pass it by value. Of course 8 people will now quickly point out that you probably don't want to use auto_ptr and they're probably right, but sometimes you don't make that choice.

While not at all specific, I frequently end up passing smallish objects around by value when that saves me an allocation on the heap. Not only does the actual allocation and eventual deallocation take time but referencing everything through a pointer does nothing to improve your data locality. It might in other words make a difference to your performance. Exactly where the break-even point is will depend on your application, but I would personally don't hesitate to pass an object that is a few pointer sizes large.

Answer 11

They're not conceptually equal at all...

The former creates a copy of the object inside the function. This implies that the value can be modified in the function safely. It also implies that a full copy of the object occurred, which can be a problem if the object is large.

The latter creates an alias to the object and states that it cannot be modified within the object. No copying occurs, but each access to the object inside the function will require a dereference. The compiler takes care of this for us, but it's still important to know.

The difference becomes very important if you have a type that is normally passed in registers. For example, integers, floating point numbers, and even 4-float vectors on some platforms. Performance concerns dictate that you want to object to stay in a register for as long as possible without writing itself back to memory, and pass by value makes this much more likely.

So for basic types (char, short, int, long, float, double), you should always prefer pass by value unless you specifically need to use a reference to store a value for use after the function exits. For full objects, generally prefer to pass by const reference.

Answer 12

1. As previously noted, prefer pass-by-value if you want a copy of the object in your function.
2. I usually use pass-by-value if copying T is cheaper than creating/copying a reference, e.g. T=char, T=short. The benefit here could be platform dependent, and you'd probably still want const where applicable to help the optimizer.

Answer 13

Some routines require a copy, and so should not be pass by reference. For example, a chess playing program's move generator might need a copy of the current position to work on (recursively) rather than actually modifying the original instance of the position.

Answer 14

Answered in this answer. This is a SymLink to that answer. Please vote there, if anywhere :)

Answer 15

Boost.CallTraits is a lesser-known but helpful facility for doing parameter and result passing with what should be the most efficient method available for the type in question.