Question

这是我母语的翻译。
你有一个班级：

class Boo : public SuperBoo {
  Foo* fFoo1;
  Foo* fFoo2;
}

Foo - 单形类和Boo拥有指针fFoo1，fFoo2。
为Boo重载赋值运算符。

我的解决方案是：

class Foo
{
public:
    Foo()
    {}
};

class SuperBoo
{
public:
    virtual ~SuperBoo()
    {}
};

class Boo : public SuperBoo
{
public:
    Boo(const int f1_id, const int f2_id)
    {
        f1 = new Foo(f1_id);
        f2 = new Foo(f2_id);
    }
    ~Boo()
    {
        delete f1;
        delete f2;
    }
    /* C++11 only
    Boo(Boo&& other)
    {
        std::swap(*this, other);
    }
    */
    Boo(const Boo& other)
    {
        f1 = new Foo(*(other.f1));
        f2 = new Foo(*(other.f2));
    }
    Boo& operator=(Boo other)
    {
        std::swap(f1, other.f1);
        std::swap(f2, other.f2);
        return *this;
    }
private:
    Foo* f1;
    Foo* f2;
};

但是雇主并不喜欢它。这有什么不对？谢谢你的帮助。

Answer 1

构造函数可以重写为：

Boo(const int f1_id, const int f2_id)
{
    std::unique_ptr<Foo> pf1 = new Foo(f1_id);
    f2 = new Foo(f2_id);

    f1 = pf1.release();
}

这样，如果f2构造函数抛出，f1将不会被泄露。

顺便说一下，复制构造函数应遵循相同的规则。

我的解决方案有什么问题？

1 个答案: