通过价值传递或通过引用传递

Question

void Subroutine1(int Parameter1)

void Subroutine2(const int &Parameter1) 

In Subroutine1 we have to get a copy of the parameter while in Subroutine2 we don't have to make the copy, which may save some overhead.

In practice Subroutine1 seems being used more often than the other. Why is that the case?

Answer 1

In practice Subroutine1 seems being used more often than the other. Why is that the case?

Because copying an int has is better over creating a reference (or pointer) and then accessing it.

More generally, all primitive types should be passed by value.

Answer 2

Because when you are dealing with primitive types (such as int ), passing by reference is actually worse performance-wise than passing by value. It also doesn't offer you anything.

Answer 3

One passes an int, the other passes a reference. As others have said, creating and accessing a reference to an int isn't much difference than just copying the int.

(Edited as per correct comment)

Answer 4

Passing by reference is (almost always) implemented by passing a pointer. This means that, for simple types like int , the second version may be less efficient - passing a pointer has more or less the same cost as passing a simple object, and then the function needs to dereference that pointer.

Answer 5

For primitive data types (like int , double , char ) which are typically of smaller size, the 1st case is usually faster (accessibility) and cheaper compared to the 2nd one. Remember that references are implemented more or less similar to pointers.

On side note, if Parameter1 is not going to be modified then, personally I will choose the 3rd alternative,

void Subroutine3(const int Parameter1);

Answer 6

Pass-by-reference to some extent implies that the callee can mutate whatever is referenced and have that mutation take effect in the caller. If that's the case you probably want to wrap the int an object and pass that into the function by reference. This provides more explicit code.

Answer 7

Firstly, for int type, pass by value is faster than pass by reference. But for your own class and struct, pass by ref is faster.

The overhead difference between these two method for primitive types is actually very very small, you can ignore it in most cases.

In my opinion, const ref of primitive type parameter is useless for normal functions. And it makes the code a little bit obscurer, so do not use it.