C++ 为C+中的类创建赋值（=）运算符+；

可能重复：

编辑2

我错误地使用了insert（…），实际上不需要“=”运算符。对不起，浪费了人们的时间。我已投票决定结束。。还有2票。请投票

编辑

我需要“=”运算符的原因是，我可以对派生对象的向量使用insert（…）函数。此时，我的编译器说：

/usr/include/c++/4.2.1/bits/stl_algobase.h:283:错误：在'*.\u result=*.\u first'中的'operator='不匹配。

---

我已经创建了“==”和“来重载赋值运算符，您应该这样做

Derivation& operator=(const Derivation &d)  {
    // something....
   return *this
}

这将允许您执行以下操作

偏差a、b、c； //某物

---

c=b=a

这取决于你，真的。你需要接线员做什么？您是要返回引用，还是要副本

---

编辑：请注意这是一种修辞。您使用此向量的目的将决定您是否需要引用或副本。例如，如果插入的对象在从向量中删除之前的任何点都将超出范围，则需要一个副本。如果不是，并且希望在更改向量中的实例时影响原始对象，则需要引用。希望这能有所帮助。

既然-@jalf还没有给出答案，就在这里：）

您需要返回对此实例的引用

这是一个关键字，它包含一个指向操作员正在操作的实例的指针。
首先删除常量。。。
然后，如果您真的需要一个复制操作符，请执行类似操作并添加您自己的逻辑（这样它就不会像编译器生成的复制操作符那样执行操作）：

首先，赋值运算符可能不应该是常量--

其次，赋值运算符通常返回一个非常量引用，该引用指向被赋值的对象（*this）
您不需要。编译器生成的赋值运算符就可以了。
实现赋值运算符的标准方法是复制和交换。
这样做的优点是，它是生成赋值运算符的最简单方法，在遇到异常和自赋值时，赋值运算符是正确的。它还根据复制构造函数定义赋值操作，从而减少了在向类添加额外成员时需要更改代码的位置

无论如何-以下是您的案例中的情况：

class Derivation {
    public:
    string                  rc; 
    ImplementationChoice    Y; 
    vector<Derivation>      X;
    vector<string>          D;       
    vector<string>          C;       
    vector<Player>          P, O;   
    vector<Attack>          B;   

    //You need to add a swap function to your class
    void swap(Derivation& o) {
        rc.swap(o.rc);
        Y.swap(o.Y);//Assuming ImplementationChoice has a swap function (it should!)
        X.swap(o.X);
        D.swap(o.D);
        C.swap(o.C);
        P.swap(o.P);
        O.swap(o.O);
        B.swap(o.B);
    }
    Derivation& operator=(Derivation const& o) {
        Derivation copy(o);
        copy.swap(*this);
        return *this;
    }
    // various functions
    // ...
};

类派生{
公众：
字符串rc；
实施选择；
向量X；
载体D；
载体C；
向量P，O；
载体B；
//您需要向类中添加交换函数
无效掉期（衍生和o）{
rc.掉期（o.rc）；
Y.swap（o.Y）；//假设ImplementationChoice有一个交换函数（它应该！）
互换（o.X）；
D.互换（o.D）；
C.掉期（o.C）；
P.swap（o.P）；
O.swap（O.O）；
B.互换（o.B）；
}
派生和运算符=（派生常量和o）{
派生副本（o）；
副本。交换（*本）；
归还*这个；
}
//各种功能
// ...
};
至少，它应该返回一个引用（
派生&
），而不是对象的新副本。：）非常感谢。现在编辑帖子。很抱歉对于C++来说，我建议您阅读。如果ImplementationChoice已经提供了一个
操作符=
，那么很可能已经隐式声明了一个合适的
派生：：操作符=
。（没有给出答案，因为它并没有真正解决您的问题，只是把它作为一个提示。）我认为它不应该是一个常量方法，因为您正在更改对象的状态（将其赋值为
d
）。它可能是合法的C++，但实际上并没有意义。@ Martinho和@斯基兹。谢谢，我已经编辑好了谢谢。。我基本上使用了从'@alemaster remove what'粘贴的单参数参数（const-Derivation&d）。我不太清楚understand@Leon-别理我！我刚刚意识到“=”必须只有一个参数。我试图删除
常量派生&d
，但编译器抱怨。除了这正是编译器生成的复制赋值运算符所做的…@Armen-真的吗？我没有意识到编译器生成的赋值运算符也会调用
向量
成员的赋值？这取决于实现方式选择、玩家和攻击…真的吗？这个结构中有五个向量，请在帖子中编辑。我需要“=”操作符，这样我就可以在派生对象的向量上使用insert（…）。没有它就无法编译。它说，
/usr/include/c++/4.2.1/bits/stl_algobase.h:283:错误：在'*.\u result=*.\u first'中的'operator='不匹配。
请在post中编辑。我需要“=”运算符，以便在派生对象的向量上使用insert（…）。我希望能够做到这一点：
vector d
d.insert（d.end（），vec.begin（），vec.end（））从你编辑和看我想做什么，我相信这是一个参考，我需要。谢谢你，谢谢你，曼卡。你在我的帖子里看到我的编辑了吗？如果我想在派生对象的向量上使用向量插入（…）函数，这就是我需要的吗？谢谢。@alemaster-否，insert函数将使用复制构造函数将派生对象插入向量。编译器生成的复制构造函数应该适合此类。
Derivation& operator=(const Derivation &d)  {
    // something....
   return *this
}

Derivation& operator=(const Derivation &d) {
  // something....
  return *this;
}

Derivation& operator=(const Derivation& other) {
    this->rc = other.rc; 
    this->Y = other.Y; 
    this->X = other.X;
    this->D = other.D;       
    this->C = other.C;       
    this->P = other.P;
    this->O = other.O;   
    this->B = other.B;
    // ...
    return *this;
}  

class Derivation {
    public:
    string                  rc; 
    ImplementationChoice    Y; 
    vector<Derivation>      X;
    vector<string>          D;       
    vector<string>          C;       
    vector<Player>          P, O;   
    vector<Attack>          B;   

    //You need to add a swap function to your class
    void swap(Derivation& o) {
        rc.swap(o.rc);
        Y.swap(o.Y);//Assuming ImplementationChoice has a swap function (it should!)
        X.swap(o.X);
        D.swap(o.D);
        C.swap(o.C);
        P.swap(o.P);
        O.swap(o.O);
        B.swap(o.B);
    }
    Derivation& operator=(Derivation const& o) {
        Derivation copy(o);
        copy.swap(*this);
        return *this;
    }
    // various functions
    // ...
};