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.