Working with vectors

[pmatos]

Hi all,

I have a few question regarding standard C++ and the use of vectors.

Imagine:
void foo(vector<int> x);
vector<int> c;
vector<int> x;

----------

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?

If so, then I wish this to be more efficient so I should probably pass
a reference right? How can I do this in both cases? In calling foo, how
can I make sure the body of foo won't try to change x? (probably const&
or &const, but I never know...)

Cheers,

Paulo Matos

[Rolf Magnus]

pmatos wrote:

Hi all,

I have a few question regarding standard C++ and the use of vectors.

Imagine:
void foo(vector<int> x);
vector<int> c;
vector<int> x;

----------

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?
Yes.
If so, then I wish this to be more efficient so I should probably pass
a reference right?
Yes.
How can I do this in both cases?
For the first case, you can't unless you declare c as a reference to
vector<int> and initialize it with c.
In calling foo, how can I make sure the body of foo won't try to change x?
Let it take a refernce to const vector<int>.
(probably const& or &const, but I never know...)

const vector<int>&. The & is always the last part.

[Cy Edmunds]

"pmatos" <po**@sat.ine sc-id.pt> wrote in message
news:11******** **************@ g44g2000cwa.goo glegroups.com.. .

Hi all,

I have a few question regarding standard C++ and the use of vectors.

Imagine:
void foo(vector<int> x);
vector<int> c;
vector<int> x;

----------

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?

If so, then I wish this to be more efficient so I should probably pass
a reference right? How can I do this in both cases? In calling foo, how
can I make sure the body of foo won't try to change x? (probably const&
or &const, but I never know...)

Cheers,

Paulo Matos

What Rolf said. But I would add one more thing: if all you really need is a
sequence of values, consider writing foo
as

template <typename ITER>
foo(ITER first, ITER last);

Then you can call it with

foo(my_vector.b egin(), my_vector.end() );

but also

foo(my_list.beg in(), my_list.end());

This technique is used extensively in the standard library (see <algorithms>
for instance) because it is both efficient and flexible.

--
Cy
http://home.rochester.rr.com/cyhome/

[davidrubin]

Rolf Magnus wrote:

pmatos wrote:

Hi all,

I have a few question regarding standard C++ and the use of vectors.

Imagine:
void foo(vector<int> x);
vector<int> c;
vector<int> x;

----------

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?

Yes.

If so, then I wish this to be more efficient so I should probably pass
a reference right?

Yes.

How can I do this in both cases?

For the first case, you can't unless you declare c as a reference to
vector<int> and initialize it with c.

It's not that you can't. The copy constructor for std::vector already
takes a non-modifiable reference to the object being copied. So,

c = x;

calls 'c's copy constructor with a const reference to 'x'. 'x' is not
copied to a temporary, as is the case with 'foo'; only the value of 'x'
is copied to 'c'. The call is already as efficient as it can be.

/david

[Rolf Magnus]

da********@warp mail.net wrote:

Rolf Magnus wrote:

pmatos wrote:

> Hi all,
>
> I have a few question regarding standard C++ and the use of vectors.
>
> Imagine:
> void foo(vector<int> x);
> vector<int> c;
> vector<int> x;
>
> ----------
>
> What happens when I do:
> c = x;
>
> and
> foo(x);
>
> Will it copy all x behind the scenes in both cases?
Yes.

> If so, then I wish this to be more efficient so I should probably pass
> a reference right?

Yes.

> How can I do this in both cases?

For the first case, you can't unless you declare c as a reference to
vector<int> and initialize it with c.

It's not that you can't. The copy constructor for std::vector already
takes a non-modifiable reference to the object being copied. So,

c = x;

calls 'c's copy constructor with a const reference to 'x'.

Yes, and that will copy x to c. As I understood the OP, he wanted to get rid
of that copy. The only way to do that would be - as I mentioned - to make c
a reference to x instead of an own vector.
Anyway, it is very well possible that I misunderstood the OP here.
'x' is not copied to a temporary, as is the case with 'foo'; only the
value of 'x' is copied to 'c'. The call is already as efficient as it can
be.

That was actually my point.

[Krishanu Debnath]

da********@warp mail.net wrote:

[snip]

How can I do this in both cases?

For the first case, you can't unless you declare c as a reference to
vector<int> and initialize it with c.

It's not that you can't. The copy constructor for std::vector already
takes a non-modifiable reference to the object being copied. So,

c = x;

calls 'c's copy constructor with a const reference to 'x'. 'x' is not
copied to a temporary, as is the case with 'foo'; only the value of 'x'
is copied to 'c'. The call is already as efficient as it can be.

/david

I could not make any sense out of your post. 'c = x; ' exactly calls
vector's assignment operator. If you want to avoid this 'copy' you need
to do what Rolf Magnus had suggested in his previous post.

Can you please elaborate more (optionally with an example) to prove your
point?

Thanks
Krishanu

[davidrubin]

Krishanu Debnath wrote:

da********@warp mail.net wrote:

[snip]

How can I do this in both cases?

For the first case, you can't unless you declare c as a reference to
vector<int> and initialize it with c.

It's not that you can't. The copy constructor for std::vector already
takes a non-modifiable reference to the object being copied. So,

c = x;

calls 'c's copy constructor with a const reference to 'x'. 'x' is not
copied to a temporary, as is the case with 'foo'; only the value of 'x'
is copied to 'c'. The call is already as efficient as it can be.

/david

I could not make any sense out of your post. 'c = x; ' exactly calls
vector's assignment operator. If you want to avoid this 'copy' you need
to do what Rolf Magnus had suggested in his previous post.

Can you please elaborate more (optionally with an example) to prove your
point?

The question was:

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?

My point is, no, 'x' will not be copied in both cases. In the case of
'c = x', 'x' is passed by const reference, whereas in the case of
'foo(x)', 'x' is passed by value, and hence is copied (to a temporary).

Given the context, I do not think OP's question was about how to avoid
copying 'x' altogether. However, you are correct to point out my error:
it is the assignment operator that is called, not the copy constructor.
/david

[Krishanu Debnath]

da********@warp mail.net wrote:
[snip]

The question was:

What happens when I do:
c = x;

and
foo(x);

Will it copy all x behind the scenes in both cases?

My point is, no, 'x' will not be copied in both cases. In the case of
'c = x', 'x' is passed by const reference, whereas in the case of
'foo(x)', 'x' is passed by value, and hence is copied (to a temporary).

Makes much sense. Thanks for the clarification.

Krishanu

[John Dibling]

You could also templatize foo and pass iterators to the container,
rather than the container itself. Here's some psudocode to illustrate:

template<class iter> foo(iter itBegin, iter itEnd);

vector<int> c;
foo(c.begin(), c.end());

Take care,

John Dibling

[pmatos]

John Dibling wrote:

You could also templatize foo and pass iterators to the container,
rather than the container itself. Here's some psudocode to illustrate:

template<class iter> foo(iter itBegin, iter itEnd);

vector<int> c;
foo(c.begin(), c.end());

Take care,

John Dibling

Thanks for the suggestion. Will that work for constructors?

Cheers,

Paulo Matos