Question

我是一名Objective-C程序员，最近刚开始使用C ++，我在我的代码组织中偶然发现了这个问题：

std::list<char *> stuff = std::list<char *>();
thing *object = new thing(stuff);

stuff将成为我班级生命周期中所需的对象（也就是说，直到它被破坏），如何避免失去它？

在Objective-C上，我可以简单地在构造函数上调用-retain。在C ++上？

Answer 1

当你不需要时，不要使用指针，don't use owning raw pointers（除非你有非常的理由）。

使用自动存储时间：

std::list<char> stuff;
thing object{stuff};

thing的构造函数将std::list<char>作为其参数：

#include <utility> // for std::move

class thing {
public:
    explicit thing(std::list<char> stuff_) : stuff(std::move(stuff_)) {}

private:
    std::list<char> stuff;
};

如果你这样做，当thing超出范围时，将调用thing的析构函数，隐式调用stuff的析构函数。许多good C++ books非常详细地解释了这一点。

与Objective-C不同，C ++使用RAII而不是引用计数。基本规则是：尽可能使用自动存储持续时间，避免原始拥有指针，除非有充分理由，否则不要使用new。

Answer 2

通常的方法是在stuff的构造函数中将thing复制或移动到thing：

class thing {
public:
    thing(std::list<char*> stuff) : stuff(std::move(stuff)) {}
private:
    std::list<char *> stuff;
};

Answer 3

在您的示例中，您不清楚如何使用stuff，因此我将为您提供一些不同的选项。

thing存储自己的stuff副本在这种情况下，您的类存储类型为std::list<char*>的对象。
```
class thing
{
public:
  thing(std::list<char*>& aList):m_list(alist){}
  std::list<char*> m_list;
};
```
构建thing时，stuff的副本已制作并存储在课程中。当对象被破坏时，它将自动解除分配m_list。
thing存储对stuff的弱引用您的类将存储指针（std::list<char*>* m_list）或引用（std::list<char*>& m_list）。 thing将能够以任何方式使用您的列表，但它不应该负责资源管理。如果列表的范围小于thing，那么您将留下悬挂参考。
```
thing getThing()
{
std::list<char*> list1;
thing object1(list1);
return object1; //bad - list will be deallocated, object1 will have a hanging reference
}
```
thing存储指向stuff的共享指针。这是与Objective C中最像retain的方法.C ++没有自动引用计数。如果要存储具有共享所有权的对象引用，可以使用std::shared_ptr。 thing存储std::shared_ptr<std::list<char*>> m_list。
```
std::shared_ptr<std::list<char*>> stuff = std::make_shared<std::list<char*>>();
thing object(stuff); //reference count incremented, even if stuff is destroyed object will still hold a valid reference
```

C ++对象保留？

3 个答案: