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

如何解决这个问题？

您几乎肯定在尝试复制包含不同类型元素的向量。即使向量中的元素类型可由编译器转换（例如，

double

和

int

），它们的集合也不是可转换的。您可以使用

std:：copy

功能进行管理，但是：

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

实际上，OP遗漏了一些重要的细节

然而，我敢写一个答案，因为它实际上很清楚

在以下情况下，可以复制

std:：vector

的赋值

• 源向量和目标向量具有相同的元素类型
• 元素类型提供副本分配

例如：

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); });

#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;
}

struct

具有（默认）复制配置，但在

struct U

中，我已明确删除了它

将

#if 1

更改为

#if 0

，代码不再编译

---

OP提供缺失信息后，更新我的答案：

std:：vector:：assign（）

是在

• 源向量的元素类型可以指定给目标向量的元素类型

在OP的特定情况下，将

MyStruct*

分配给

void*

时也是如此

例如：

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); });

#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;
}

---

请提供一个可重复的最小示例。请编辑您的问题，以包含问题是

v1=v2std:：vector

（并且

T

提供赋值运算符）的实例，则code>将起作用，但您在问题中遗漏了

T

。

#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;
}