Question

调用循环的代码：

Foo temp = Foo(token.substr(0,i));
this->leftExpression = temp;

将Foo声明为：

class Foo{
    private:
        std::string expr;
        std::vector <Bar*> tokens;
        std::vector <std::string> stringtoken;

CCTOR调用循环：

Foo::Foo(const Foo& a_expr){
    this->expr = a_expr.expr;
    this->tokens = a_expr.tokens;
    this->stringtoken = a_expr.stringtoken;
}

什么是调用此循环？

编辑：

作业运营商：

Foo& Foo::operator=(const Foo& a_expr){
    Foo temp(a_expr);
    std::swap(*this, temp);
    return (*this);
}

Answer 1

问题在于：

std::swap(*this, temp);

std::swap的默认实现使用赋值，因此从赋值运算符调用它时会产生无限递归。

如果您确实需要编写自己的赋值运算符，请编写自己的swap，例如：

void Foo::swap(Foo & other) {
    using std::swap;
    swap(expr, other.expr);
    // and for all other members
}

Foo& Foo::operator=(Foo temp){
    this->swap(temp);
    return (*this);
}

在这种情况下，看起来所有成员都可以正确复制（尽管您可能需要注意tokens中的哑指针）。如果是这种情况，则根本不需要编写自己的析构函数，复制构造函数或复制赋值运算符 - 只需让隐式函数执行正确的操作。

Answer 2

Aaaand那里有你的问题：分配操作员创建一个副本并调用std::swap，然后调用赋值运算符。

您可以在不使用std::swap的情况下实现赋值运算符，也可以在不使用默认实现的情况下实现swap，而是使用"copy-and-swap"-idiom。

复制构造函数调用无限循环，尽管通过引用调用

2 个答案: