A question about passing arguments

Hi all, I just start learning c++ and I'm a little bit confused with passing parameters to function. hope you can help me out

Check the example:

Code:

//definition of a function
vector<int> sub_vec( const vector<int> &vec, int val )
{
       vector<int> local_vec( vec );   
        //do operations on local_vec,
       ......
}

to get a local copy of vec which is passed from the caller function, can I just instead write

Code:

vector<int> sub_vec( vector<int> local_vec, int val) 
{   
        //do operations on local_vec;
        ......
}

in the second case, what is passed? an address? the whole object "
vec"? when passing parameters, what is actually processed? an assignation (then second case is illegal, cuz local_vec may not be big enough) or just an initialization?

Thanks for help

In the second case a copy of the vector is made. In the first, a reference to the vector is passed.

Thanks.
so the result of the second case is exactly same as the result of the first one?

This is better to do

Code:

//definition of a function
vector<int> sub_vec( const vector<int> &local_vec, int val )
{
        //do operations on local_vec,
       ......
}

...I think

Originally Posted by AntiScience

Thanks.
so the result of the second case is exactly same as the result of the first one?

In both cases, a copy of the vector is made. The difference is WHEN the copy is made. In the first version (pass by reference), you make the copy manually, once you've already entered the function. In the second version (pass by value), the copy is made automatically when the argument is passed, BEFORE you enter the function.

I'd say the two versions are equivalent. But I would prefer to pass by reference for the following reason: your code may change so that you no longer need to operate on a copy of the vector. In the pass-by-reference case, you simply stop making the copy. But in the pass-by-value case, the copy is still made, even if you don't need it. And at that point, if you change the function to take a reference instead of a value, you break the interface for all users of that function (not at a compile-level -- it would still compile. But users may have come to rely on the pass-by-value semantics in some way)

I would only pass by value if the object was sufficiently "simple" -- a vector isn't.

The two code snippets you posted are functionally identical. In both cases, local_vec is a member-by-member copy of the original vector.

Both code snippets make a copy, and they do the same thing. Either choice will be fine.

You can use the first one (with the reference) in case you might change the implementation of the function later so that it doesn't require a copy. If you make it a reference from the start, calling code won't have to be recompiled for the change.

You can use the second one if you know you will always make a copy and you want to document that by doing the copy directly on the parameter.

Originally Posted by AntiScience

btw, the first definition is an example in lippman's book essential c++. what he wanted is to change the local_vec without changing the original vec. I posted this thread because I thought there must be something wrong with the second definition for which he didn't use the shorter one in the book....

There's nothing really wrong with it, it is just less robust against changes in the implementation. "Brittle," if you will.

Originally Posted by AntiScience

Thanks.
so the result of the second case is exactly same as the result of the first one?

Depends on exactly what you mean by "exactly same"

Creating a copy of a large object, such as a vector with a considerable number of elements that each consume significant amounts of memory, imposes a performance and memory penalty. That can translate into the second form introducing performance penalties in comparison with the first: it can run slower or, if the code is executing on a machine with limited memory resources, the copying operation can fail.

The second form also relies on being able to create a copy. That means objects contained in the vector must support suitable copy semantics (copy constructor, assignment operator) to ensure the elements are copied as expected. That is normally a requirement when using a vector, but does actually depend on how the class of objects is implemented.

In practice, you are better off passing a const reference for reasons like these: fewer potential penalties on performance and/or memory usage and lower likelihood of encountering a run-time error if machine resources are limited.

Originally Posted by brewbuck

There's nothing really wrong with it, it is just less robust against changes in the implementation. "Brittle," if you will.

Thanks. your answer is really helpful
and Thanks to all too

>> This is better to do ...I think
>> In the second case a copy of the vector is made. In the first, a reference to the vector is passed.
>> In practice, you are better off passing a const reference for reasons like these.

In both cases a copy is made, the question was whether it is better to do that in the function parameter list or inside the body of the function.


BTW, another reason to do it inside the body is that you might add code later to exit the function early on some error condition. If you can do that before making the copy then you can gain the performance benefit of skipping the copy only if the copy is inside the function body.