std::auto_ptr 的最佳实践

Question

我刚刚习惯使用 std::auto_ptr 的智能指针。

假设我想调用一个同时具有 auto_ptr 和普通指针的函数。

auto_ptr<uint32> data_smart(new uint32[123])]);
uint32 data_fix[123];
uint32* data_dumb = new uint32[123];

processData(data_smart);
processData(data_fix);
processData(data_dumb);

在不超载的情况下，最佳实践是什么？有带有 uint32* 参数的 processData 函数吗？在这种情况下，我可以使用 .get() 将智能指针强制转换为 uint32* 吗？或者说我应该采取什么方法呢？ 提前致谢！

Answer 1

1.

auto_ptr<uint32> data_smart(new uint32[123])]);

不要那样做。 auto_ptr 仅适用于标量（它调用 delete 而不是 delete[]）。

2.
auto_ptr 拥有它指向的对象，因此除非您想将所有权传递给该函数（在您的代码中不需要），否则该函数应该接受普通指针。因此，您应该将调用更改为：

processData(data_smart.get());

以便明确表示 data_smart 继续拥有该对象。

Answer 2

编辑：诺亚·罗伯茨对你的问题的评论是这里更大的问题，但这回答了所提出的问题，即使示例代码是错误的......

---

...没有重载...

如果您想在不重载的情况下执行此操作，则适用于所有这些的唯一选择是使该方法采用哑指针参数。

对于这种情况，我可以将智能指针强制转换为 uint32* 吗？

不可以。使用 std::auto_ptr::get()。

Answer 3

首先，您不使用指向数组的指针来初始化 auto_ptr。它不受支持，最终会导致内存泄漏。 std::auto_ptr 仅处理单个对象。

如果您仍然想使用 std::auto_ptr，但仅适用于单个对象，则需要记住 std::auto_ptr 在复制构造函数中转移所有权。这意味着如果您按值传递 data_smart，则在调用 processData 后，本地 auto_ptr (data_smart) 将不会保留任何内存。

最后，您可能想使用 boost::scoped_array 或 boost::shared_array。

Answer 4

最佳实践是不要使用 auto_ptr。它将在 C++0x 中弃用，并由 std::unique_ptr 取代（参考：C++0x 标准草案，附录 D，第 10 段）。与此同时，替代方案包括 std::tr1::shared_ptr 和 boost::scoped_ptr。

但您的示例是一个数组，而这些指针类型不适用于数组。您可以使用 boost::shared_array 来实现这一点。

然而标准本身没有数组智能指针。这可能是因为他们认为您应该使用 std::vector （或者当您在编译时知道大小时使用 std::array 来表示固定大小的数组）。鉴于此，您可以执行以下操作：

std::vector<uint32> dataVector;
data.reserve(123);

// or, if the size is always 123:
std::tr1::array<uint32, 123> dataArray;

现在，您可以调用接受常规普通 uint32* 的函数，因为 vector 和 std:: tr1::arrays 有方法让您以 C 风格数组的指针的形式访问数据：

processData(&dataVector[0]);
processData(dataArray.data());

如果您打算这样做，我会强烈建议添加边界检查。将第二个参数传递给 processData 以及数组的大小：

processData(&dataVector[0], dataVector.size());

如果您可以完全放弃 C 风格的指针/数组，更好的方法可能是通过引用传递：

void processData(std::vector<uint32>& data) {
    // process the data
}

// call it like this:
processData(dataVector);

但这仅适用于 向量，而不是std::tr1::array或任何其他容器。因此，更进一步，您可以使用接受迭代器的模板：

template <class AnIterator>
void processData(AnIterator begin, AnIterator end) {
    for (AnIterator it = begin; it != end; ++it) {
        // process each item
    }
}

// call it like this
processData(dataVector.begin(), dataVector,end());

// or like this
processData(dataArray.begin(), dataArray.end());

// or even like this (assume c_data is a C-style array):
processData(c_data, c_data + number_of_items_in_c_data);

最后一个模板可以工作，因为指向 C 样式数组的指针可以用作迭代器。

Answer 5

在您的情况下，使用向量是最安全的选择：

std::vector<uint32> data(123);

processData 的签名理想情况下应该是：

void processData(const std::vector<uint32> & data);

但是，这个签名更常用：

void processData(uint32 * bytes, int length);

在这两种情况下，您都可以使用向量：

// 1
processData(data);

// 2
processData(data.data(), data.size());

Answer 6

尽管为什么您应该使用 auto 和哑（正如您所说的）指针将相同的数据指向相同的名称函数而不重载，但 auto_ptr 不能在数组上使用，因为它调用了错误类型的删除。

看看这个：http://learningcppisfun。 blogspot.com/2007/05/custom-deleters-with-smart-pointers.html

另外看看这个关于数组智能指针的问题：数组的 auto_ptr

Answer 7

让我觉得有趣的是，data_smart 变量是这三个变量中最愚蠢的一个。也就是说，当该作用域结束时，auto_ptr 析构函数将对其指针调用 delete 而不是 delete[] ，这会导致 UB （这比可能的内存更糟糕）从 data_dumb 泄漏）。

所以，重点是不要对数组使用 auto_ptr，而使用向量。

进入真正的问题。首先，如果可能的话，使用引用参数而不是指针参数。如果这不可能，请使用裸指针，并且 auto_ptr::get() 可以访问底层指针。

Answer 8

忽略已经被锤击的不要在数组上使用 auto_ptr 。

在不超载的情况下，最佳实践是什么？

看来你的方法不会取得所有权，所以剩下的问题是它会改变吗？

processData 函数带有 uint32* 参数吗？

processData( uint32* ) 这是一种选择，但可能不是最好的。
processData( uint32[123] ) 如果您不进行编辑（123 开始推送一些复制）。
processData( uint32 &[123] ) by ref 并根据需要应用 const。

在这种情况下，我可以使用 .get() 将智能指针强制转换为 uint32* 吗？

您可以使用 get() 获取智能指针的指针内容，它已经“类型化”了，因此无需对其进行强制转换。

旁白：
如此原始级别的数据和操作应该在一个类中，您甚至可能不需要将成员变量传递到成员函数中。