0

我有一个简单的容器类，它指向一个抽象类，并且我有函数来获取/设置容器类中的指针。更具体地说，这个类看起来像这样：

class Container
{
    Abstract* thing;
public:
    void set(Abstract &obj)
    {
        thing = &obj; //danger of dangling pointer
    }

    Abstract* get()
    {
        return thing;
    }
};

Abstract是一个抽象类。正如已经看到的那样，存在悬空指针的危险。我知道我可以复制对象（新）然后指向它。但我无法创建抽象类的实例。有什么解决方案？

以下只是更多信息：

类定义

class Abstract
{
public:
    virtual void something() = 0;
};

class Base : public Abstract
{
    int a;
public:
    Base() {}
    Base(int a) : a(a){}
    virtual void something()
    {
        cout << "Base" << endl;
    }
};

class Derived : public Base
{
    int b;
public:
    Derived() {}
    Derived(int a, int b) : Base(a), b(b){}
    virtual void something()
    {
        cout << "Derived" << endl;
    }
};

简单的测试

void setBase(Container &toSet)
{
    Base base(15);
    toSet.set(base);
}

void setDerived(Container &toSet)
{
    Derived derived(10, 30);
    toSet.set(derived);
}

int main()
{
    Container co;

    Base base(15);
    Derived derived(10, 30);

    Base *basePtr;
    Derived *derivedPtr;

    //This is fine
    co.set(base);
    basePtr = static_cast<Base *>(co.get());
    basePtr->something();

    //This is fine
    co.set(derived);
    derivedPtr = static_cast<Derived *>(co.get());
    derivedPtr->something();

    //Reset
    basePtr = nullptr;
    derivedPtr = nullptr;

    //Dangling pointer!
    setBase(co);
    basePtr = static_cast<Base *>(co.get());
    basePtr->something();

    //Dangling pointer!
    setDerived(co);
    derivedPtr = static_cast<Derived *>(co.get());
    derivedPtr->something();

    return 0;
}
4

3 回答 3

6

您需要做的是具体定义您的内存所有权。

Container::set通过引用接受一个实例Abstract，这通常并不意味着所有权转移：

 void set(Abstract &obj){...} // Caller retains ownership of obj, but now we have a weak reference to it

那么删除的责任不在你身上。

Container::get返回一个暗示所有权的指针，指示调用的人set不应使传递的对象无效。

Abstract* get(){...}

正如您所说，这可能是有问题的。

你有几个选择

  • Container使用适当的文档对这些内存所有权语义进行编码（按合同编写代码）
  • 使用智能指针，如std::shared_ptr

在前一种情况下，它是否有效取决于用户阅读和理解你的 API，然后表现得很好。在后一种情况下，指针对象拥有自己，并在最后一个实例超出范围时删除分配的内存。

 void set(std::shared_ptr<Abstract> obj){...} 
// now Container participates in the lifetime of obj, 
// and it's harder to nullify the underlying object 
// (you'd have to be intentionally misbehaving)
于 2016-07-25T22:21:46.843 回答
1

如果您担心对象在其他地方被释放导致悬空指针，您可以使用 boost 智能指针。

Boost 智能指针将为您提供簿记服务，并有助于避免这种情况。

一些信息可以在这里找到： 智能指针（升压）解释

于 2016-07-25T22:25:06.703 回答
1

这std::unique_ptr是为了：

class Container
{
    std::unique_ptr<Abstract> thing;
public:
    void set(std::unique_ptr<Abstract> obj)
    {
        thing = obj;
    }

    Abstract* get()
    {
        return thing.get();
    }
};

现在该Abstract对象是“拥有”的，并且在销毁Container时会自动清理。Conatiner

如果您想要一个可能寿命更长的指针，或者可能在多个容器之间共享，请std::shared_ptr改用。

于 2016-07-25T22:27:45.433 回答