Question

我有一个叫做游戏的类，这是它的运算符=：

的代码

Game& Game::operator=(const Game &other){
if(this==&other){
    return *this;
}else{
    for(unsigned i=0;i<other.players.size();i=i+1){
        Player* copy;
        int str= other.players.at(i)->getStr();
        if(str==1)
            copy = new PlayerType1(dynamic_cast<const PlayerType1&>(*other.players.at(i)));
        if(str==2)
            copy = new PlayerType2(dynamic_cast<const PlayerType2&>(*other.players.at(i)));
        if(str==3)
            copy = new PlayerType3(dynamic_cast<const PlayerType3&>(*other.players.at(i)));
        if(str==4)
            copy = new PlayerType4(dynamic_cast<const PlayerType4&>(*other.players.at(i)));
        players.push_back(copy);
    }
    winners = other.winners;
    state = vector<string>(other.state);
    deck = Deck(other.deck);
    verbal = other.verbal;
    highestNum = other.highestNum;
    turnNum = other.turnNum;
    currPlayer = other.currPlayer;
    lastAsker = other.lastAsker;
    lastAskee = other.lastAskee;
    lastAskedCard = other.lastAskedCard;
    return *this;
}

}

我试着在这里打电话：

char* cf= "../src/config1.txt";
Game* game = new Game(cf);
game->init();
Game game2=*game;
game->play();
game2.printState();

在这种情况下，我的operator =将不会被使用。但是如果game2已经初始化，例如：

Game* game = new Game(cf);
game->init();
Game game2=*(new Game());
game2=*game;
game->play();
game2.printState();

知道可能是什么问题吗？

Answer 1

在第一种情况下，copy elision避免调用赋值运算符，而支持复制构造函数。

在第二种情况下，对象已经构建，因此必须调用赋值运算符。

结论是你必须实现所有3个运算符：析构函数，赋值和副本（也称为rule of three）否则你可能会有不可预知的行为，具体取决于编译器。

避免以不一致的方式实现它们的最佳方法是使用copy & swap idiom

运算符=重载不起作用，除非对象已初始化

1 个答案: