0

让我们假设以下场景。我有一个如下定义的隐式共享类：

class MyClass
{
public:
    MyClass (void) {
        data = new Data();
        data->refs = 1;
        data->dummy = 32;
    }

    ~MyClass (void) {
        if (--data->refs == 0)
            delete data;
    }

    MyClass (const MyClass& c) {
        ++(data = c.data)->refs;
    }

    MyClass& operator = (const MyClass& c) {
        ++(data = c.data)->refs;
        return *this;
    }

private:
    struct Data {
        int refs;
        int dummy;
    } *data;
};

这个想法是，当这个类被复制时，指向数据的内部指针被复制，并且对该数据的引用数量增加。但是，请考虑以下事项：

int main (void)
{
    MyClass c1;
    c1 = MyClass();
    c1 = MyClass();
    return 0;
}

我的理解是 MyClass 有三个实例，只有最后一个实例被释放。如果是这种情况，我该怎么做才能避免这些情况并确保 MyClass 的每个实例都得到清理？

4

2 回答 2

3

在您的赋值运算符中，您需要确保在用新值覆盖其值之前清理分配给对象。毕竟，赋值的左边已经引用了一个值。编写赋值运算符的最简单方法是利用现有的复制构造函数和析构函数并使用函数swap()来交换两个对象：

MyClass& MyClass::operator = (MyClass c) {
    this->swap(c);
    return *this;
}

void MyClass::swap(MyClass& other) {
    std::swap(this->data, other.data);
}

这样，该值已经复制到该值中c，并且当前值与 . 持有的值交换c。当c被销毁时，引用计数会根据需要递减。

请注意，这std::share_ptr<T>已经使用一种相当花哨的机制进行引用计数：您可能希望使用标准类而不是滚动您自己的类。

于 2013-09-13T23:55:11.380 回答
2 
MyClass& operator = (const MyClass& c) {
    ++(data = c.data)->refs;
    return *this;
}

这已破了。在你 clobber 之前this.data，你需要减少它的引用，如果引用下降到零，则删除它。

于 2013-09-13T23:54:45.230 回答