Assignment question in c++

Question

Hello. Coming from c#, where classes instances are passed by reference(this is, a copy of the reference is passed when you call a function, instead of the integral value), I'd like to know how this works in c++. In the following case, _poly = poly; is copying the value of poly to _poly, or what? Thanks

#include <iostream>
#include <stdio.h>
#include <stdarg.h>
#include <vector>
using namespace std;

class polynomial {
private:
    vector<int> _poly;
public:
    void Set(vector<int> poly);
};

void polynomial::Set(vector<int> poly) {
    _poly = poly;                             <----------------
}

Answer 1

This will copy the entire vector. Assignment is by value in C++. If you are assigning a pointer, the pointer value is assigned. References may not be reassigned to refer to another object once initialized, so assignment of them alters the referent object.

Answer 2

The copy operator for vectors will copy the contents of the vector over.

Answer 3

This will do a shallow-copy of the vector of ints. This will generally work as you would expect (_poly will end up containing the same values as poly).

You would see some strange behaivor if you had pointers (as they would be copied by value).

In general, you would want to pass that parameter by const reference:

void polynomial::Set( const vector<int>& poly )

In this case, passing by const reference will not affect the outcome and will be more efficient since it will eliminate an unneeded copy of the vector being passed into the method.

Answer 4

poly's values will be copied into _poly -- but you will have made an extra copy in the process. A better way to do it is to pass by const reference:

void polynomial::Set(const vector<int>& poly) {
    _poly = poly;                      
}

EDIT I mentioned in comments about copy-and-swap. Another way to implement what you want is

void polynomial::Set(vector<int> poly) { 
    _poly.swap(poly); 
}

This gives you the additional benefit of having the strong exception guarantee instead of the basic guarantee. In some cases the code might be faster, too, but I see this as more of a bonus. The only thing is that this code might be called "harder to read", since one has to realize that there's an implicit copy.

Answer 5

Yes, the line you point to is copying the entire vector. Furthermore, there will be a copy on the function call, as well, since that's not const.

Basically, if the vector has any size to it, this is VERY expensive.

Answer 6

Unless you assign or pass a parameter by reference (using the & prefix) you are passing by value. For classes, this means that a copy of the object is constructed using either a supplied or implicitly generated (shallow) copy constructor for the type. This can be expensive - and is often undesirable.

In your example, the vector is copied twice - once when it is passed as a parameter to the Set() method, and again when it is assigned to the _poly member.

You could avoid the first copy by passing the vector by reference:

void polynomial::Set(const vector<int>& poly) // passes the original parameter by reference
{
    _poly = poly; // still makes a copy
}

Answer 7

There are three possibilities:

Pass by value

void someFunction(SomeClass theObject);

Pass a pointer

void someFunction(SomeClass *theObject);

Pass by reference

void someFunction(SomeClass &theObject);

Answer 8

Your vector will be copied.

What's actually going on is that the "=" operator of vector has been overloaded to do the actual copy.