Take the 2-minute tour ×

I have a doubt regarding how can we check whether a pointer passed to a function is allocated with memory or not in C ?

I have wriiten my own function in C which accepts a character pointer - buf [pointer to a buffer] and size - buf_siz [buffer size]. Actually before calling this function user has to create a buffer and allocate it memory of buf_siz.

Since there is a chance that user might forget to do memory allocation and simply pass the pointer to my function I want to check this. So is there any way I can check in my function to see if the pointer passed is really allocated with buf_siz amount of memory .. ??

EDIT1: It seems there is no standard library to check it .. but is there any dirty hack to check it .. ??

EDIT2: I do know that my function will be used by a good C programmer ... But I want to know whether can we check or not .. if we can I would like to hear to it ..

Conclusion: So it is impossible to check if a particular pointer is allocated with memory or not within a function

share|improve this question
I don't really think so, but I don't feel confident enough to post as an answer. –  Ibrahim Oct 16 '09 at 5:48
There's no way to check, unless you use a memory manager or roll your own. –  Michael Foukarakis Oct 16 '09 at 5:55
If its a character pointer, we can do strlen() or sizeof() and check how much memory is allocated(ofcourse if the string is NULL terminated). For other types, i am not sure if there is some way.!! –  mk.. Feb 18 at 5:33
+1 Nice summary!! –  Dariush Apr 1 at 21:35

14 Answers 14

up vote 12 down vote accepted

You cannot check, except some implementation specific hacks.

Pointers have no information with them other than where they point. The best you can do is say "I know how this particular compiler version allocates memory, so I'll dereference memory, move the pointer back 4 bytes, check the size, makes sure it matches..." and so on. You cannot do it in a standard fashion, since memory allocation is implementation defined. Not to mention they might have not dynamically allocated it at all.

You just have to assume your client knows how to program in C. The only un-solution I can think of would be to allocate the memory yourself and return it, but that's hardly a small change. (It's a larger design change.)

share|improve this answer
A pointer could be not null but still not have buf_siz bytes allocated. I don't think there's really any way to check what the asker wants. –  Ibrahim Oct 16 '09 at 5:49
Oops, I sped-read the question. –  GManNickG Oct 16 '09 at 5:50
Ok, how about this? Since this is C, the client probably used malloc which does return a NULL pointer if it were unable to allocate memory. So ... in malloc we trust? –  Jacob Oct 16 '09 at 5:56
It's up to the client to make sure malloc worked before calling the function, if that's what you're saying. –  GManNickG Oct 16 '09 at 5:57
Yea. The end conclusion is your function should do one thing and one thing only. Imagine the overhead if every function made sure the memory it was accessing from parameters was valid. Just have your function do what it's suppose to do. –  GManNickG Oct 16 '09 at 6:04

You can't check with anything available in standard C. Even if your specific compiler were to provide a function to do so, it would still be a bad idea. Here's an example of why:

int YourFunc(char * buf, int buf_size);

char str[COUNT];
result = YourFunc(str, COUNT);
share|improve this answer
@Mark - In the code you are assigning str as an array of size COUNT .. hence in 'YourFunc' I can still perform operations like strcpy within the size of buf_size. But if str is just a char pointer then trying to perform any strcpy operation of size buf_size will result in a 'Segmentation Fault' –  codingfreak Oct 16 '09 at 5:58
That's VERY VERY wrong, codingfreak. The segmentation fault happens if 'str' is a char pointer pointing at memory you're not allowed to access. It doesn't happen because 'str' is a char pointer, it happens because you ask the program to do something it's not allowed to do. –  gnud Oct 16 '09 at 16:12
@gnud - I am sorry I guess I replied in a wrong view point. –  codingfreak Apr 14 '12 at 2:14

No, you can't. You'll notice that no functions in the standard library or anywhere else do this. That's because there's no standard way to tell. The calling code just has to accept responsibility for correctly managing the memory.

share|improve this answer
@Chuck if there is no standard library function to check it is there any other way out .. ? –  codingfreak Oct 16 '09 at 5:59

No, in general there is no way to do this.

Furthermore, if your interface is just "pass a pointer to a buffer where I will put stuff", then the caller may choose not to allocate memory at all, and instead use a fixed size buffer that's statically allocated or an automatic variable or something. Or perhaps it's a pointer into a portion of a larger object on the heap.

If your interface specifically says "pass a pointer to allocated memory (because I'm going to deallocate it)", then you should expect that the caller will do so. Failure to do so isn't something you can reliably detect.

share|improve this answer

For a platform-specific solution, you may be interested in the Win32 function IsBadReadPtr (and others like it). This function will be able to (almost) predict whether you will get a segmentation fault when reading from a particular chunk of memory.

However, this does not protect you in the general case, because the operating system knows nothing of the C runtime heap manager, and if a caller passes in a buffer that isn't as large as you expect, then the rest of the heap block will continue to be readable from an OS perspective.

share|improve this answer
@Greg - Sorry to say I am not much intrested in WIN32 functions .. if possible a well working dirty hack is also ok since there is NO standard C function –  codingfreak Oct 16 '09 at 7:32
Okay, you didn't specify what platform you are interested in. Specifying the platform and compiler may get you a more specific answer. –  Greg Hewgill Oct 16 '09 at 7:53
@Greg - Yeah I agree with you ... –  codingfreak Oct 16 '09 at 8:25

I always initialize pointers to null value. Therefore when I allocate memory it will change. When I check if memory's been allocated I do pointer != NULL. When I deallocate memory I also set pointer to null. I can't think of any way to tell if there was enough memory allocated.

This doesn't solve your problem, but you got to trust that if someone writes C programs then he is skilled enough to do it right.

share|improve this answer
@Yelonek .. I do agree with you but I really want to know if there is any possibilty to check .... –  codingfreak Oct 16 '09 at 7:34
I do too but (especially in libraries) s*** happens. –  Mr Universe May 30 '13 at 5:38

As everyone else said, there isn't a standard way to do it.

So far, no-one else has mentioned 'Writing Solid Code' by Steve Maguire. Although castigated in some quarters, the book has chapters on the subject of memory management, and discusses how, with care and complete control over all memory allocation in the program, you can do as you ask and determine whether a pointer you are given is a valid pointer to dynamically allocated memory. However, if you plan to use third party libraries, you will find that few of them allow you to change the memory allocation routines to your own, which greatly complicates such analysis.

share|improve this answer
@Jonathan - What you mean by third party libraries -- ?? I am just using standard libraries and ISO C99. But I will just try out the book which you have recommended. –  codingfreak Oct 16 '09 at 7:38
Third party libraries are anything you didn't write, including the standard libraries. Roughly speaking, if it uses malloc() anywhere, you will have a tough time replacing those calls with your own memory allocator, which means it will be hard to track abuses. You may have to go for more sophisticated memory tracking stuff - check out debugging versions of malloc, valgrind, Purify, etc. (It is the bane of my life - we can't use most libraries from outside without hard work because the product I work on has excruciating memory management requirements that libraries neither know nor care about.) –  Jonathan Leffler Oct 16 '09 at 8:42

One hack you can try is checking if your pointer points to stack allocated memory. This will not help you in general as the allocated buffer might be to small or the pointer points to some global memory section (.bss, .const, ...).

To perform this hack, you first store the address of the first variable in main(). Later, you can compare this address with the address of a local variable in your specific routine. All addresses between both addresses are located on the stack.

share|improve this answer
Yeah ... If I write the whole application I can do that .. But inorder to use a function to check things might be complex ..? –  codingfreak Oct 16 '09 at 8:27
This has the potential to cause someone to think that uninitialized pointers are on the heap. Also, if someone happened to store a pointer to somewhere farther down (up?) the stack, which later got popped off to get your function, it would also be considered on the heap. –  Kevin Nov 11 at 16:25

in general lib users are responsible for input check and verification. You may see ASSERT or something in the lib code and they are used only for debug perpose. it is a standard way when writing C/C++. while so many coders like to do such check and verfying in their lib code very carefully. really "BAD" habits. As stated in IOP/IOD, lib interfaces should be the contracts and make clear what will the lib do and what will not, and what a lib user should do and what should be not necessary.

share|improve this answer

An uninitialised pointer is exactly that - uninitialised. It may point to anything or simply be an invalid address (i.e. one not mapped to physical or virtual memory).

A practical solution is to have a validity signature in the objects pointed to. Create a malloc() wrapper that allocates the requested block size plus the sizeof a signature structure, creates a signature structure at the start of the block but returns the pointer to the location after the signature. You can then create a validation function that takes the pointer, uses a negative offset to get the validity structure and checks it. You will of course need a corresponding free() wrapper to invalidate the block by overwriting the validity signature, and to perform the free from the true start of the allocated block.

As a validity structure, you might use the size of the block and its one's complement. That way you not only have a way of validating the block (XOR the two values and compare to zero), but you also have information about the block size.

share|improve this answer
You might want to check your first sentence: "An initialised pointer is exactly that - uninitialised." –  Chris Lutz Oct 16 '09 at 8:49
Thanks Chris - fixed. –  Clifford Oct 16 '09 at 16:06

There is almost never "never" in computers. Cross platform is way over anticipated. After 25 years I have worked on hundreds of projects all anticipating cross platform and it never materialized.

Obviously, a variable on the stack, would point to an area on the stack, which is almost linear. Cross platform garbage collectors work, by marking the top or (bottom) of the stack, calling a little function to check if the stack grows upwards or downwards and then checking the stack pointer to know how big the stack is. This is your range. I don't know a machine that doesn't implement a stack this way (either growing up or down.)

You simply check if the address of our object or pointer sits between the top and bottom of the stack. This is how you would know if it is a stack variable.

Too simple. Hey, is it correct c++? No. Is correct important? In 25 years I have seen way more estimation of correct. Well, let's put it this way: If you are hacking, you aren't doing real programming, you are probably just regurigating something that's already been done.

How interesting is that?

share|improve this answer
The original question was about C, not C++, didn't mention nor imply on-stack variables and wasn't about interesting/new/unique stuff. –  Alexey Frunze Apr 13 '12 at 11:00

There is a simple way to do this. Whenever you create a pointer, write a wrapper around it. For example, if your programmer uses your library to create a structure.

struct struct_type struct_var;

make sure he allocates memory using your function such as

struct struct_type struct_var = init_struct_type()

if this struct_var contains memory that is dynamically allocated, for ex,

if the definition of struct_type was

typedef struct struct_type {
 char *string;

then in your init_struct_type() function, do this,

 struct struct_type *temp = (struct struct_type*)malloc(sizeof(struct_type));
 temp->string = NULL;
 return temp;

This way,unless he allocates the temp->string to a value, it will remain NULL. You can check in the functions that use this structure, if the string is NULL or not.

One more thing, if the programmer is so bad, that he fails to use your functions, but rather directly accesses unallocated the memory, he doesn't deserve to use your library. Just ensure that your documentation specifies everything.

share|improve this answer

I once used a dirty hack on my 64bit Solaris. In 64bit mode the heap starts at 0x1 0000 0000. By comparing the pointer I could determine if it was a pointer in the data or code segment p < (void*)0x100000000, a pointer in the heap p > (void*)0x100000000 or a pointer in a memory mapped region (intptr_t)p < 0 (mmap returns addresses from the top of the addressable area). This allowed in my program to hold allocated and memory mapped pointers in the same map, and have my map module free the correct pointers.

But this kind of trick is highly unportable and if your code relies on something like that, it is time to rethink the architecture of your code. You're probably doing something wrong.

share|improve this answer

The below code is what I have used once to check if some pointer tries to access illegal memory. The mechanism is to induce a SIGSEGV. The SEGV signal was redirected to a private function earlier, which uses longjmp to get back to the program. It is kind of a hack but it works.

The code can be improved (use 'sigaction' instead of 'signal' etc), but it is just to give an idea. Also it is portable to other Unix versions, for Windows I am not sure. Note that the SIGSEGV signal should not be used somewhere else in your program.

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
#include <signal.h>

jmp_buf jump;

void segv (int sig)
  longjmp (jump, 1); 

int memcheck (void *x) 
  volatile char c;
  int illegal = 0;

  signal (SIGSEGV, segv);

  if (!setjmp (jump))
    c = *(char *) (x);
    illegal = 1;

  signal (SIGSEGV, SIG_DFL);

  return (illegal);

int main (int argc, char *argv[])
  int *i, *j; 

  i = malloc (1);

  if (memcheck (i))
    printf ("i points to illegal memory\n");
  if (memcheck (j))
    printf ("j points to illegal memory\n");

  free (i);

  return (0);
share|improve this answer

Your Answer


