C++ 使用副本分配在不同对象的容器之间实现自动化

我有一个类型为

std:：vector

的稀疏向量，其中SparseElement是：

template<typename T, typename I = unsigned int>
struct SparseElement
{
    I index;
    T value;
    //............
    SparseElement &operator=(const std::pair<I,T> &pair);
 }

模板
结构稀疏元素
{
I指数；
T值；
//............
SparseElement和operator=（const std:：pair和pair）；
}

由于我正在使用填充稀疏向量a

std:：map

，该向量包含as元素

std:：pair

，因此我希望在不更改SparseElement的“index”和“value”成员的情况下解决此问题：

std::pair<I,T> a;
SparseElement<T,I> b;
b = a; // This is OK!
a = b; // Is there a solution on this problem?
// on containers:
std::vector<SparseElement<T,I>> vec;
std::map<I,T> m(vec.begin(), vec.end()); // Not working.
vec.assign(m.begin(), m.end()); // Working.

std:：对a；
稀疏元素b；
b=a；//这没关系！
a=b；//这个问题有解决办法吗？
//在集装箱上：
std:：vec；
映射m（vec.begin（），vec.end（））；//不工作。
向量赋值（m.begin（），m.end（））；//工作

改写答案以帮助社区

template<typename T, typename I = unsigned int>
struct SparseElement
{
    //..........
    I index;                //!< Index of element in vector
    T value;                //!< Value of element
    //..........
    //! Template copy constructor from a different type of \p std::pair
    //! This is useful for conversion from MapVector to SparseVector
    template<typename T2, typename I2>
    SparseElement(const std::pair<I2,T2> &s) : index(s.first), value(s.second) {}
    //..........
    //! Template copy assign from a different type of \p std::pair
    //! This is useful for conversion from MapVector to SparseVector
    template<typename T2, typename I2>
    SparseElement &operator=(const std::pair<I2,T2> &s) { index = s.first; value = s.second; return *this; }

    //! Implicit conversion from SparseElement to a \p std::pair
    //! This is useful for conversion from SparseVector to MapVector
    operator std::pair<const I,T>() { return std::pair<const I,T>(index, value); }
};

模板
结构稀疏元素
{
//..........
I index；/！<向量中元素的索引
T值；/！<元素的值
//..........
//！从不同类型的\p std:：pair复制模板构造函数
//！这对于从MapVector到SparseVector的转换非常有用
模板
SparseElement（const std:：pair&s）：索引（s.first），值（s.second）{
//..........
//！从不同类型的\p std:：pair分配模板副本
//！这对于从MapVector到SparseVector的转换非常有用
模板
SparseElement&operator=（const std:：pair&s）{index=s.first；value=s.second；返回*this；}
//！从SparseElement到\p std:：pair的隐式转换
//！这对于从SparseVector到MapVector的转换非常有用
运算符std:：pair（）{返回std:：pair（索引，值）；}
};

a=b可能
模板std:：pair&operator=（pair lhs，SparseElement const&SE）作为一个自由函数。@RedX-不，我也爱上了它
operator=
必须是由标准定义的非静态成员函数。@KirilKirov-Dang，如果可能的话，这会很好。然后可以将成员
operator std:：pair（）
转换成员添加到SparseElement类中。@RedX-nice，应该可以。