删除空指针是否安全？

Question

假设我有以下代码：

void* my_alloc (size_t size)
{
   return new char [size];
}

void my_free (void* ptr)
{
   delete [] ptr;
}

这样安全吗？还是必须在删除之前将ptr 转换为char*？

Answer 1

这取决于“安全”。它通常会起作用，因为信息与分配本身的指针一起存储，因此释放器可以将其返回到正确的位置。从这个意义上说，只要您的分配器使用内部边界标签，它就是“安全的”。 （很多人都这样做。）

但是，正如其他答案中提到的，删除 void 指针不会调用析构函数，这可能是一个问题。从这个意义上说，它并不“安全”。

没有充分的理由按照你正在做的事情做你正在做的事情。如果要编写自己的释放函数，可以使用函数模板生成具有正确类型的函数。这样做的一个很好的理由是生成池分配器，这对于特定类型可能非常有效。

正如其他答案中提到的，这是 C++ 中的undefined behavior。一般来说，最好避免未定义的行为，尽管主题本身很复杂并且充满了相互矛盾的意见。

Answer 2

很多人已经评论说不，删除 void 指针是不安全的。我同意这一点，但我还想补充一点，如果您使用 void 指针来分配连续数组或类似的东西，您可以使用 new 执行此操作，以便您可以使用 @987654323 @ 安全（加上，咳咳，一些额外的工作）。这是通过为内存区域（称为“arena”）分配一个 void 指针，然后将指向该 arena 的指针提供给 new 来完成的。请参阅C++ FAQ 中的此部分。这是在 C++ 中实现内存池的常用方法。

Answer 3

对于 char 的特殊情况。

char 是一种没有特殊析构函数的内在类型。所以泄漏的论点是没有实际意义的。

sizeof(char) 通常是 1，因此也没有对齐参数。在 sizeof(char) 不是 1 的稀有平台的情况下，它们分配的内存足够对齐到它们的 char。所以对齐论点也是一个没有实际意义的论点。

malloc/free 在这种情况下会更快。但是你放弃了 std::bad_alloc 并且必须检查 malloc 的结果。调用全局 new 和 delete 操作符可能会更好，因为它绕过了中间人。

Answer 4

如果您只需要一个缓冲区，请使用 malloc/free。 如果您必须使用 new/delete，请考虑一个简单的包装类：

template<int size_ > struct size_buffer { 
  char data_[ size_]; 
  operator void*() { return (void*)&data_; }
};

typedef sized_buffer<100> OpaqueBuffer; // logical description of your sized buffer

OpaqueBuffer* ptr = new OpaqueBuffer();

delete ptr;

Answer 5

我在我的框架中使用了 void*，（又名未知类型），同时用于代码反射和其他模棱两可的壮举，到目前为止，我没有遇到来自任何编译器的问题（内存泄漏、访问冲突等） .仅因操作不规范而发出警告。

删除一个未知数 (void*) 非常有意义。只需确保指针遵循这些准则，否则它可能会失去意义：

1) 未知指针不能指向具有普通解构函数的类型，因此当转换为未知指针时，它永远不会被删除。仅在将未知指针转换回 ORIGINAL 类型后删除它。

2) 实例是否被引用为堆栈绑定或堆绑定内存中的未知指针？如果未知指针引用堆栈上的一个实例，那么它永远不应该被删除！

3) 你 100% 肯定未知指针是一个有效的内存区域吗？不，那么它永远不应该被删除！

总而言之，使用未知 (void*) 指针类型可以完成的直接工作非常少。然而，间接地，void* 是 C++ 开发人员在需要数据模糊性时依赖的重要资产。

Answer 6

这个问题毫无意义。您的困惑可能部分是由于人们经常使用 delete 时使用的草率语言：

您使用delete 销毁动态分配的对象。这样做，您将形成一个 delete 表达式，并带有一个 指向该对象的指针。您永远不会“删除指针”。您真正要做的是“删除由其地址标识的对象”。

现在我们明白为什么这个问题没有意义了：空指针不是“对象的地址”。它只是一个地址，没有任何语义。它可能来自一个实际对象的地址，但是该信息丢失了，因为它被编码在原始指针的类型中。恢复对象指针的唯一方法是将 void 指针转换回对象指针（这需要作者知道指针的含义）。 void 本身是不完整的类型，因此永远不是对象的类型，并且永远不能使用 void 指针来标识对象。 （对象由它们的类型和它们的地址共同识别。）

Answer 7

几乎没有理由这样做。

首先，如果您不知道数据的类型，而您只知道它是void*，那么您真的应该将该数据视为无类型unsigned char*）的strong>blob，并使用malloc/free处理。这有时对于波形数据之类的东西是必需的，您需要将 void* 指针传递给 C api。没关系。

如果你确实知道数据的类型（即它有一个ctor/dtor），但由于某种原因你最终得到了一个void*指针（无论你有什么原因）那么您真的应该将其转换回您知道的类型，并在其上调用delete。

Answer 8

如果您真的必须这样做，为什么不去掉中间人（new 和 delete 运算符）并直接调用全局 operator new 和 operator delete？ （当然，如果您尝试检测 new 和 delete 运算符，您实际上应该重新实现 operator new 和 operator delete。）

void* my_alloc (size_t size)
{
   return ::operator new(size);
}

void my_free (void* ptr)
{
   ::operator delete(ptr);
}

请注意，与malloc() 不同，operator new 在失败时抛出std::bad_alloc（如果已注册，则调用new_handler）。

Answer 9

C++ 标准未定义通过 void 指针删除 - 请参阅第 5.3.5/3 节：

在第一种选择中（删除 对象），如果是静态类型 操作数与其动态不同 类型，静态类型应为基类 操作数的动态类型的类 并且静态类型应具有 虚拟析构函数或行为是 不明确的。在第二种选择中 （删除数组）如果是动态类型 要删除的对象不同于 它的静态类型，行为是 未定义。

及其脚注：

这意味着一个对象不能 使用 void* 类型的指针删除 因为没有类型的对象 无效

.

Answer 10

如果你想使用 void*，为什么不只使用 malloc/free？ new/delete 不仅仅是内存管理。基本上， new/delete 调用构造函数/析构函数，还有更多的事情发生。如果您只是使用内置类型（如 char*）并通过 void* 删除它们，它会起作用，但仍然不推荐。如果您想使用 void*，底线是使用 malloc/free。否则，为方便起见，您可以使用模板函数。

template<typename T>
T* my_alloc (size_t size)
{
   return new T [size];
}

template<typename T>
void my_free (T* ptr)
{
   delete [] ptr;
}

int main(void)
{
    char* pChar = my_alloc<char>(10);
    my_free(pChar);
}

Answer 11

这不是一个好主意，也不是你在 C++ 中会做的事情。你会无缘无故地丢失你的类型信息。

当您为非原始类型调用析构函数时，不会对您正在删除的数组中的对象调用析构函数。

您应该改写新/删除。

删除 void* 可能会偶然正确释放您的内存，但这是错误的，因为结果未定义。

如果出于某种我不知道的原因，您需要将指针存储在 void* 中然后释放它，您应该使用 malloc 和 free。

Answer 12

因为 char 没有特殊的析构逻辑。这行不通。

class foo
{
   ~foo() { printf("huzza"); }
}

main()
{
   foo * myFoo = new foo();
   delete ((void*)foo);
}

d'ctor 不会被召唤。

Answer 13

删除 void 指针是危险的，因为不会在它实际指向的值上调用析构函数。这可能会导致应用程序中的内存/资源泄漏。