使用赋值运算符复制 std::vector

Question

std::vector<MyStruct*> v1;
std::vector<void*> v2;

I have stl vector of pointer of structure.

I want to copy std::vector<MyStruct*> to std::vector<void*> .

If I use v2 = v1 , I am getting below error:

error C2679: binary '=' : no operator found which takes a right-hand operand of
             type 'std::vector<_Ty>' (or there is no acceptable conversion).

How to resove this?

Answer 1

Actually, the OP left essential details out.

However, I dare to write an answer as it's actually quite clear.

Copy assignment of std::vector is possible when

• source and destination vector have equal element type
• element type provides copy assignment.

Example:

#include <iostream>
#include <vector>

struct T {
  int value;
};

struct U {
  int value;
  U& operator=(const U&) = delete;
};

int main ()
{
#if 1 // OK:
  { std::vector<T> v1(10), v2;
    v2 = v1;
    std::cout << "After v2 = v1; v2 has size " << v2.size() << '\n';
  }
#else // Wrong: (U has no assignment!)
  { std::vector<U> v1(10), v2;
    v2 = v1;
    std::cout << "After v2 = v1; v2 has size " << v2.size() << '\n';
  }
#endif // 1
  return 0;
}

Output:

After v2 = v1; v2 has size 10

Live demo on coliru

struct T has (default) copy assigment but in struct U I have explicitly deleted it.

Changing #if 1 to #if 0 , the code doesn't compile anymore.

---

After OP provided the missing info, an update of my answer:

std::vector::assign() is an alternative when

• element type of source vector may be assigned to element type of destination vector.

This is true for assigning MyStruct* to void* in the specific case of OP.

Example:

#include <iostream>
#include <vector>

struct T {
  int value;
};

struct U {
  int value;
  U& operator=(const T &t) { value = t.value; return *this; }
};

int main ()
{
  { std::vector<T> v1(10);
    std::vector<U> v2;
    v2.assign(std::begin(v1), std::end(v1));
    std::cout << "After v2.assign(std::begin(v1), std::end(v1)) v2 has size " << v2.size() << '\n';
  }
#if 1 // OK:
  { T t[] = { { 1 }, { 2 }, { 3 } };
    std::vector<T*> v1{ t + 0, t + 1, t + 2 };
    std::vector<void*> v2;
    v2.assign(std::begin(v1), std::end(v1));
    std::cout << "After v2.assign(std::begin(v1), std::end(v1)) v2 has size " << v2.size() << '\n';
  }
#else // Wrong: (Assignment from void* to T* not permitted!)
  { std::vector<void*> v1(10, nullptr);
    std::vector<T*> v2;
    v2.assign(std::begin(v1), std::end(v1));
    std::cout << "After v2.assign(std::begin(v1), std::end(v1)) v2 has size " << v2.size() << '\n';
  }
#endif // 1
  return 0;
}

Output:

After v2.assign(std::begin(v1), std::end(v1)) v2 has size 10
After v2.assign(std::begin(v1), std::end(v1)) v2 has size 3

Live demo on coliru

Answer 2

You are almost certainly trying to copy vectors containing elements of different types. Even if the types of the elements in the vectors are convertible by the compiler (eg double and int ), collections of them are not. You can manage it using the std::copy function, however:

#include <algorithm>
#include <iterator>
// ...
std::vector v1<int>;
// ...
std::vector v2<double>;
std::copy(v1.begin(), v1.end(), std::back_inserter(v2));

You mentioned that in your case, one of your vectors contains pointers. If the pointer types are convertible by the compiler, say, copying derived-class pointers to base-class pointers, std::copy will work as above.

If the pointers are not convertible, then you must use std::transform instead of std::copy , and supply the appropriate cast. For example, copying base-class to derived-class pointers:

class Y : public class X { ... };
std::vector v3<X*>;
// ...
std::vector v4<Y*>;
std::transform(v3.begin(), v3.end(), std::back_inserter(v4),
               [](X* arg) { return dynamic_cast<Y*>(arg); });