Is using std::vector< std::shared_ptr<const T> > an antipattern?

Question

For a long time I was using std::vector and std::shared_ptr hand in hand. Recently I started using std::shared_ptr<const T> whenever a pointer to a const object was needed. This is all OK, since std::shared_ptr<T> can be cast to std::shared_ptr<const T> and then they share the same reference counter and everything feels natural.

But when I try to use constructs such as std::vector< std::shared_ptr<const T> > I run into troubles. To simplify I will denote the two structures:

template <class T> using SharedPtrVector = std::vector< std::shared_ptr<T> >;  template <class T> using SharedConstPtrVector = std::vector< std::shared_ptr<const T> >; 

The problem is that although SharedPtrVector and SharedConstPtrVector are very similar, SharedConstPtrVector cannot be cast to SharedPtrVector.

So each time I want to be a const correct and write a function such as:

void f(const SharedConstPtrVector<T>& vec); 

there is no way I can pass const SharedPtrVector<T> to f.

I was thinking about this a lot and considered several alternatives:

1. Write conversion functions

   template <typename T> SharedConstPtrVector<T> toConst(const SharedPtrVector<T>&); 

2. Write code in generic form:

   template <typename T> void f(const std::vector< std::shared_ptr<T> >& vec); 

   or

   template <typename TIterator> void f(TIterator begin, TIterator end); 

3. Abandon the idea of std::vector< std::shared_ptr<const T> >

The problem with 1. is the computational overhead and increased uglyness of code, while 2. gives the code an "everything is a template" flavor.

I am an inexperienced programmer and I don't want to set out in the wrong direction. I would like to hear advice from someone who has experience with this problem.

Answer 1

I would suggest reviewing your design with a view to establish a clear owner of those object. This is the absence of clear ownership that lead people to use shared smart pointers.

Bjarne Stroustrup recommends using smart pointers only as a last resort. His recommendations (best to worst) are:

1. Store an object by value.
2. Store many objects in a container by value.
3. If nothing else works, use smart pointers.

See Bjarne Stroustrup - The Essence of C++: With Examples in C++84, C++98, C++11, and C++14 at 0:37:40.