Move a vector<T*> to vector<const T*>

Question

Is it possible to move a vector<T*> to a vector<const T*> without copying it and without relying on reinterpret_cast<>? I.e.

vector<int*> get() {
   return ...;
}

vector<const int*> getConst() {
   return whatgoeshere(get());
}

Answer 1

I'm going to attack this from another angle. And address a possible design issue. You didn't specify what comes in the ..., but assuming get populates a vector and then returns it, the solution in my view is to lift the code that does the populating outside of both functions.

template<typename Int>
void do_get(std::vector<Int*>& v) {
  // Populate v
}

auto get() {
   std::vector<int*> ret;
   do_get(ret);
   return ret;
}

auto getConst() {
   std::vector<const int*> ret;
   do_get(ret);
   return ret;
}

One source of truth for the populating logic. And while the two original functions are identical, it's negligible. Furthermore on a sane implementation it won't do any superfluous copies, because RVO is amazing.

Answer 2

No.

Although a T* may be trivially converted to a const T*, a container of T* is not "related" to a container of const T*, so there is simply no functionality to do what you ask.

Consider also that such functionality might hypothetically assign a int** to a const int**, which is not permitted (there is no special case provided for when the programmer intended this assignment to take place as part of a swap operation, as far as I know).

Furthermore, a reinterpret_cast would merely be hacking over these facts, giving your program undefined behaviour.

You are stuck with three options:

• Copy the vector (O(n))
• Make it so that you have the container you wanted in the first place (O(∞))
• Make it so that you don't need the new container type at all (O(?))