Passing std::shared_ptr by value or const ref and then storing in a container?

Question

Consider the following vector:

std::vector<std::shared_ptr<X>> myVector;

and the following two functions that add a given element to the vector:

void foo1(std::shared_ptr<X> x)
{
    myVector.push_back(x);
}

void foo2(const std::shared_ptr<X>& x)
{
    myVector.push_back(x);
}

My understanding is that both functions push a shared_ptr to X into the vector and thus increment the ref count of X. The first function results in an additional increment and decrement of the reference count but this is needless.

Is my understanding correct? Is the second option therefore preferable?

Since you pass by value you evoke the copy constructor. Thus, your understanding is correct. — 101010, Nov 05 '15 at 15:48
Possible duplicate of [shared\_ptr by reference or by value?](http://stackoverflow.com/questions/3310737/shared-ptr-by-reference-or-by-value) — eerorika, Nov 05 '15 at 15:50
@101010 I'm happy to accept your response if you put it as an answer. — ksl, Nov 05 '15 at 19:34

101010 · Accepted Answer · 2015-11-05T20:09:48.060

In foo1 you pass the parameter (i.e., shared pointer) by value. Thus, the copy constructor of std::shared_ptr<X> is going to be evoked (i.e., ref counter is going to be increased and then decreased when destructor of local copy is being called at } of foo1).

In foo2 you pass the parameter (i.e., shared pointer) by const reference. Thus, you pass a const qualified alias of the original object (i.e., ref counter is not going to be increased).

You can also see this in the following example:

struct X {};

void foo1(std::shared_ptr<X> x) { 
  std::cout << "count in foo1(): " << x.use_count() << std::endl;
}

void foo2(const std::shared_ptr<X>& x) {
  std::cout << "count in foo2(): " << x.use_count() << std::endl;
}

int main() {
  std::shared_ptr<X> x(new X);
  std::cout << "count in main(): " << x.use_count() << std::endl;
  foo1(x);
  foo2(x);
}

Output:

count in main(): 1
count in foo1(): 2
count in foo2(): 1

As you can see in foo1 the number of different shared_ptr instances is 2. That is the original shared_ptr defined in main and the copy in foo1. Whereas, in foo2 the ref counter remains 1.

Consequently, your reasoning is correct.

@ksl basically I would use option 2 most of the time. I would use option 1 only if I wanted at some point of the function the copied shared pointer to point to somewhere else. — 101010, Nov 06 '15 at 12:59

score 3 · Answer 2 · answered Nov 05 '15 at 15:52

3

You should rewrite your functions as:

void foo1(std::shared_ptr<X> x)
{
    myVector.emplace_back(std::move(x));
}

void foo2(const std::shared_ptr<X>& x)
{
    myVector.emplace_back(x);
}

then both versions should be more efficient, which one would depend on situation and particular compiler, most probably difference would be very small if any.

answered Nov 05 '15 at 15:52

Slava

43,454
1
47
90

Or even `void foo1(std::shared_ptr &&x)` – Thomas Sparber Nov 05 '15 at 15:56
3

`emplace_back` isn't going to be any more efficient than `push_back` in this situation. – Simple Nov 05 '15 at 16:10

score 1 · Answer 3 · answered Nov 05 '15 at 15:59

1

Generally it is better to pass shared pointer by reference, as atomic increments tend to degrade performance. In your case, it will not be noticeable, since you copy it afterwards anyways.

answered Nov 05 '15 at 15:59

SergeyA

61,605
5
78
137

Only the `foo1` copies doesn't it? – ksl Nov 05 '15 at 19:30
@ksl What do you think `foo2` does internally? Do you think it does the equivalent of `new_vector_slot = x;` or do you think it does the equivalent of `new_vector_slot = std::shared_ptr(x);`? – David Schwartz Nov 05 '15 at 19:57
@DavidSchwartz The latter. – ksl Nov 05 '15 at 20:10
@ksl Then `foo2` copies as well. – David Schwartz Nov 05 '15 at 20:12
@ksl You said both that only `foo1` copies and that you think `foo2` is implemented in a way that necessarily copies. Both of those things can't be true. – David Schwartz Nov 05 '15 at 20:24

Passing std::shared_ptr by value or const ref and then storing in a container?

3 Answers3

Output: