How to know if a pointer is valid?

hatemtalbi

Hey, does someone know how to check if a pointer is valid (was allocated by the application and can be used without problem) or no?

David Crow

Have you looked into IsBadCodePtr(), IsBadReadPtr(), IsBadWritePtr(), or IsBadStringPtr()?

"The largest fire starts but with the smallest spark." - David Crow

"Judge not by the eye but by the heart." - Native American Proverb

Viorel

In Windows you can try IsBadReadPtr, IsBadWritePtr and IsBadStringPtr. In MFC you can try AfxIsValidAddress and AfxIsValidString. In case of run-time library, you can try _CrtIsValidPointer, _CrtIsValidHeapPointer and _CrtIsMemoryBlock.

Sarath C

Best programs always handle the pointers validity by checking NULL or not. for this you should cautious about allocation and de-allocation SaRath.
"Do Next Thing..." My Blog | Understanding State Pattern in C++

hatemtalbi

AfxIsValidAddress worked fine for me. Thanks a lots :)

Roland Pibinger

hatemtalbi wrote:

does someone know how to check if a pointer is valid (was allocated by the application and can be used without problem) or no?

When you ask that question something is wrong in your code. You should never have to check if a pointer is 'valid'.

Stephen Hewitt

You are asking for trouble if you rely on these APIs to tell if memory is safe to use. For example with heaps when you free a block it doesn't mean the memory is deallocated straight away; it can be marked as free and recycled. This is how heaps work. In short if IsBadReadPtr returns TRUE you know for sure that the memory isn't safe to read; but if it returns FALSE it does ***NOT*** mean that the memory is safe to use - it could be on the heap's free list for example. These API are only meant for debugging purposes and not for memory management in the manner your post alludes to. Steve

Stephen Hewitt

You are asking for trouble if you rely on these APIs to tell if memory is safe to use. For example with heaps when you free a block it doesn't mean the memory is deallocated straight away; it can be marked as free and recycled. This is how heaps work. For example: if IsBadReadPtr returns TRUE you know for sure that the memory isn't safe to read; but if it returns FALSE it does ***NOT*** mean that the memory is safe to read - it could be on the heap's free list for example. Most people don't believe when I tell them this. The following code shows this effect in action: int *pInt = new int; delete pInt; ASSERT( AfxIsValidAddress(pInt, sizeof(int)) ); If this practice was safe the ASSERT should fire: it doesn't. The memory is being cached in the heap but it is definitely ***NOT*** safe to use it. DO NOT USE THIS TECHNIQUE! Steve

Stephen Hewitt

I agree 100%. You get a five for making so much sense. Steve

David Crow

Stephen Hewitt wrote:

If this practice was safe the ASSERT should fire: it doesn't.

Actually, it should only fire if the address pointed to by pInt was not contained entirely within the program’s memory space.

"The largest fire starts but with the smallest spark." - David Crow

"Judge not by the eye but by the heart." - Native American Proverb

David Crow

Stephen Hewitt wrote:

These API are only meant for debugging purposes and not for memory management in the manner your post alludes to.

Hence my question. :)

"The largest fire starts but with the smallest spark." - David Crow

"Judge not by the eye but by the heart." - Native American Proverb

Stephen Hewitt

DavidCrow wrote:

Actually, it should only fire if the address pointed to by pInt was not contained entirely within the program’s memory space.

Yes, that's what the API does. This doesn't contradict my statement. The OP wanted to know how to tell if memory "was allocated by the application and can be used without problem". AfxIsValidAddress was put forward as a solution and the OP accepted it claiming that it worked. I pointed out that if this API could be used to perform this function then the ASSERT in the code below should fire as AfxIsValidAddress should return FALSE given that it is surely not safe to use a pointer after it has been deleted: int *pInt = new int; delete pInt; ASSERT( AfxIsValidAddress(pInt, sizeof(int)) ); This is not the case. If you try this code AfxIsValidAddress returns TRUE and thus the ASSERT will not fire. Why? Because the address pointed to by pInt was entirely contained in the process’s address space. It's cached by the heap (the small block heap in this case) for recycling. So the problem is that just because an address is physically mapped into the process's address space doesn't mean it's safe to use. In general these APIs can only be used to tell if memory can't be safely used but not to tell if it is safe to use. Steve