删除空指针安全吗？

Question

假设我有以下代码：

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

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

这安全吗？ 或者在删除之前必须将 ptr 转换为 char* ？

Answer 1

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

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

及其脚注：

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

。

Answer 2

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

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

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

正如其他答案中提到的，这是 C++ 中的 未定义行为。 一般来说，避免未定义的行为是有好处的，尽管主题本身很复杂并且充满了相互冲突的观点。

Answer 3

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

当您为非基本类型调用析构函数时，不会对数组中要删除的对象调用析构函数。

您应该重写 new/delete。

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

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

Answer 4

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

Answer 5

如果您确实必须这样做，为什么不去掉中间人（new 和 delete 运算符）并调用全局operator new 和 <直接代码>运算符删除？ （当然，如果您尝试使用 new 和 delete 运算符，您实际上应该重新实现 operator new 和 operator

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 6

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

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

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

Answer 7

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

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

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

医生不会被叫到。

Answer 8

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

Answer 9

如果你想使用 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 10

几乎没有理由这样做。

首先，如果您不知道数据的类型，并且您只知道它是void*，那么您确实应该将该数据视为二进制数据的无类型 blob (unsigned char*)，并使用 malloc/free 来处理它。 有时，对于波形数据等数据是必需的，您需要将 void* 指针传递给 C api。 没关系。

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

Answer 11

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

删除未知的 (void*) 是完全有意义的。 只需确保指针遵循以下准则，否则可能会失去意义：

1) 未知指针不得指向具有简单解构函数的类型，因此当转换为未知指针时，永远不应该删除它。 仅在将未知指针强制转换回原始类型后才将其删除。

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

3) 您是否 100% 肯定未知指针是有效的内存区域？ 不，那么它绝对不应该被删除！

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

Answer 12

如果您只想要一个缓冲区，请使用 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 13

对于 char 的特殊情况。

char 是一种内部类型，没有特殊的析构函数。 因此，关于泄密的争论是没有实际意义的。

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

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