blocks|key|1326242|text|这取决于“安全”。它通常会工作，因为关于分配本身的信息与指针一起存储，因此释放分配器可以将其返回到正确的位置。从这个意义上说，只要你的分配器使用内部边界标记，它就是“安全的”。(许多人都这样做。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1326243|然而，正如在其他答案中提到的，删除空指针将不会调用析构函数，这可能是一个问题。从这个意义上说，它不是“安全的”。|1326244|没有很好的理由去做你正在做的事情。如果您想编写自己的释放函数，可以使用函数模板来生成具有正确类型的函数。这样做的一个很好的理由是生成池分配器，这对于特定类型非常有效。|1326245|正如在其他答案中提到的，这是C%2B%2B中的undefined+behavior。一般来说，避免未定义的行为是很好的，尽管主题本身很复杂，充满了相互矛盾的观点。|offset|length|1326246|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/language/ub^0|0|0|0|J|I|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

It depends on "safe." It will usually work because information is stored along with the pointer about the allocation itself, so the deallocator can return it to the right place. In this sense it is "safe" as long as your allocator uses internal boundary tags. (Many do.) 

However, as mentioned in other answers, deleting a void pointer will not call destructors, which can be a problem. In that sense, it is not "safe."

There is no good reason to do what you are doing the way you are doing it. If you want to write your own deallocation functions, you can use function templates to generate functions with the correct type. A good reason to do that is to generate pool allocators, which can be extremely efficient for specific types.

As mentioned in other answers, this is <a href="https://en.cppreference.com/w/cpp/language/ub" rel="noreferrer">undefined behavior</a> in C++. In general it is good to avoid undefined behavior, although the topic itself is complex and filled with conflicting opinions.

blocks|key|1326062|text|删除空指针是危险的，因为析构函数不会在它实际指向的值上被调用。这可能会导致应用程序中的内存/资源泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1326063|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Deleting a void pointer is dangerous because destructors will not be called on the value it actually points to. This can result in memory / resource leaks in your application.

blocks|key|1326406|text|如果您真的必须这样做，为什么不跳过中间人(+new和delete操作符)，直接调用全局operator+new和operator+delete呢？(当然，如果您试图检测new和delete运算符，则实际上应该重新实现operator+new和operator+delete。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1326407|void*+my_alloc+(size_t+size)
{
+++return+::operator+new(size);
}

void+my_free+(void*+ptr)
{
+++::operator+delete(ptr);
}|code-block|syntax|javascript|1326408|请注意，与malloc()不同的是，operator+new会在失败时抛出std::bad_alloc+(如果注册了new_handler，则会调用它)。|1326409|entityMap^0|M|3|Q|6|17|C|1K|F|2C|3|2G|6|30|C|3D|F|0|0|5|8|I|C|11|E|1M|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|N|$]]

If you really must do this, why not cut out the middle man (the <code>new</code> and <code>delete</code> operators) and call the global <code>operator new</code> and <code>operator delete</code> directly? (Of course, if you're trying to instrument the <code>new</code> and <code>delete</code> operators, you actually ought to reimplement <code>operator new</code> and <code>operator delete</code>.)

<pre><code>void* my_alloc (size_t size)
{
 return ::operator new(size);
}

void my_free (void* ptr)
{
 ::operator delete(ptr);
}
</code></pre>

Note that unlike <code>malloc()</code>, <code>operator new</code> throws <code>std::bad_alloc</code> on failure (or calls the <code>new_handler</code> if one is registered).

blocks|key|1541252|text|很多人已经评论说，不，删除空指针是不安全的。我同意这一点，但我也想补充说，如果你为了分配连续数组或类似的东西而使用空指针，那么你可以用new来做这件事，这样你就能够安全地使用delete+(嗯，有点额外的工作)。这是通过分配一个指向内存区域的空指针(称为“arena”)，然后将指向arena的指针提供给new来实现的。请参阅C%2B%2B+FAQ中的此部分。这是在C%2B%2B中实现内存池的常用方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1541253|entityMap|0|LINK|mutability|MUTABLE|url|https://isocpp.org/wiki/faq/dtors#memory-pools^0|1V|3|2F|6|4J|7|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

A lot of people have already commented saying that no, it's not safe to delete a void pointer. I agree with that, but I also wanted to add that if you're working with void pointers in order to allocate contiguous arrays or something similar, that you can do this with <code>new</code> so that you'll be able to use <code>delete</code> safely (with, ahem, a little of extra work). This is done by allocating a void pointer to the memory region (called an 'arena') and then supplying the pointer to the arena to new. See this section in the <a href="https://isocpp.org/wiki/faq/dtors#memory-pools" rel="nofollow noreferrer">C++ FAQ</a>. This is a common approach to implementing memory pools in C++.

blocks|key|1541178|text|因为char没有特殊的析构函数逻辑。这行不通的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1541179|class+foo
{
+++~foo()+{+printf("huzza");+}
}

main()
{
+++foo+*+myFoo+=+new+foo();
+++delete+((void*)foo);
}|code-block|syntax|javascript|1541180|D‘’ctor不会被调用。|1541181|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Because char has no special destructor logic. THIS won't work.

<pre><code>class foo
{
 ~foo() { printf("huzza"); }
}

main()
{
 foo * myFoo = new foo();
 delete ((void*)foo);
}
</code></pre>

The d'ctor won't get called.

blocks|key|1541407|text|如果你想使用void*，为什么不直接使用malloc/free呢？new/delete不仅仅是内存管理。基本上，new/delete调用了一个构造函数/析构函数，而且还有更多的事情在进行。如果您只使用内置类型(如char*)并通过void*删除它们，那么它可以工作，但仍然不推荐这样做。如果你想使用void*，底线是使用malloc/free。另外，为了方便起见，您可以使用模板函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1541408|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);
}|code-block|syntax|javascript|1541409|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to use void*, why don't you use just malloc/free? new/delete is more than just memory managing. Basically, new/delete calls a constructor/destructor and there are more things going on. If you just use built-in types (like char*) and delete them through void*, it would work but still it's not recommended. The bottom line is use malloc/free if you want to use void*. Otherwise, you can use template functions for your convenience.

<pre><code>template&lt;typename T&gt;
T* my_alloc (size_t size)
{
 return new T [size];
}

template&lt;typename T&gt;
void my_free (T* ptr)
{
 delete [] ptr;
}

int main(void)
{
 char* pChar = my_alloc&lt;char&gt;(10);
 my_free(pChar);
}
</code></pre>

blocks|key|1326357|text|如果你只是想要一个缓冲区，可以使用malloc/free。如果您必须使用new/delete，请考虑一个简单的包装类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1326358|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;|code-block|syntax|javascript|1326359|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you just want a buffer, use malloc/free. 
If you must use new/delete, consider a trivial wrapper class:

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

typedef sized_buffer&lt;100&gt; OpaqueBuffer; // logical description of your sized buffer

OpaqueBuffer* ptr = new OpaqueBuffer();

delete ptr;
</code></pre>

blocks|key|1541535|text|我已经在我的框架中使用了void*+(也就是未知类型)，在代码反射和其他歧义方面，到目前为止，我还没有遇到任何问题(内存泄漏，访问冲突等)。来自任何编译器的。只有由于操作不规范而导致的警告。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1541536|删除一个未知(void*)是非常有意义的。只需确保指针遵循这些指导原则，否则它可能会失去意义：|1541537|1)未知指针不能指向具有微不足道的解构函数的类型，因此当转换为未知指针时，它永远不应被删除。只有在将未知指针强制转换回原始类型后才能将其删除。|1541538|2)实例是否在堆栈绑定内存或堆绑定内存中被引用为未知指针？如果未知指针引用堆栈上的实例，则永远不要删除它！|1541539|3)你是否100%25确定未知指针是一个有效的内存区域？不，那就永远不应该是DELTED！|1541540|总而言之，使用未知(void*)指针类型可以完成的直接工作非常少。然而，当需要数据不明确时，void*间接是C%2B%2B开发人员的一项重要资产。|1541541|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

I have used void*, (aka unknown types) in my framework for while in code reflection and other feats of ambiguity, and so far, I have had no troubles (memory leak, access violations, etc.) from any compilers. Only warnings due to the operation being non-standard. 

It perfectly makes sense to delete an unknown (void*). Just make sure the pointer follows these guidelines, or it may stop making sense:

1) The unknown pointer must not point to a type that has a trivial deconstructor, and so when casted as an unknown pointer it should NEVER BE DELETED. Only delete the unknown pointer AFTER casting it back into the ORIGINAL type.

2) Is the instance being referenced as an unknown pointer in stack bound or heap bound memory? If the unknown pointer references an instance on the stack, then it should NEVER BE DELETED!

3) Are you 100% positive the unknown pointer is a valid memory region? No, then it should NEVER BE DELTED!

In all, there is very little direct work that can be done using an unknown (void*) pointer type. However, indirectly, the void* is a great asset for C++ developers to rely on when data ambiguity is required.

blocks|key|1326483|text|对于char的特殊情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1326484|char是没有特殊析构函数的内部类型。因此，泄密的论点是一个没有意义的论点。|1326485|sizeof(char)通常是1，所以也没有对齐参数。在很少有平台的情况下，sizeof(+char+)不是1，它们为char分配足够对齐的内存。因此，对齐的争论也是没有意义的。|1326486|在这种情况下，malloc/free会更快。但是您放弃了std::bad_alloc，并且必须检查malloc的结果。调用全局的new和delete运算符可能更好，因为它绕过了中间人。|1326487|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

For the particular case of char.

char is an intrinsic type that does not have a special destructor. So the leaks arguments is a moot one.

sizeof(char) is usually one so there is no alignment argument either. In the case of rare platform where the sizeof(char) is not one, they allocate memory aligned enough for their char. So the alignment argument is also a moot one.

malloc/free would be faster on this case. But you forfeit std::bad_alloc and have to check the result of malloc. Calling the global new and delete operators might be better as it bypass the middle man.

Suppose I have the following code:

<pre><code>void* my_alloc (size_t size)
{
 return new char [size];
}

void my_free (void* ptr)
{
 delete [] ptr;
}
</code></pre>

Is this safe? Or must <code>ptr</code> be cast to <code>char*</code> prior to deletion?

Is it safe to delete a void pointer?

内存管理

编译器

假设我有以下代码：void* my_alloc (size_t size){   return new char [size];}void my_free (void* ptr){   delete [] ptr;}这个安全吗？还是必须在删除前将ptr转换为char*？

问删除空指针安全吗？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除空指针安全吗？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除空指针安全吗？
EN