It depends on what you mean: if you want to empty the memory used, but still have access to that memory, then you use memset(pointer, 0, mem_size);, to re-initialize the said memory to zeroes.
If you no longer need that memory, then you simply call free(pointer);, which'll free the memory, so it can be used elsewhere.

Using realloc(pointer, 0) may work like free on your system, but this is not standard behaviour. realloc(ptr, 0) is not specified by the C99 or C11 standards to be the equivalent of free(ptr).

realloc(pointer, 0) is not equivalent to free(pointer).

The standard (C99, §7.22.3.5):

The realloc functionSynopsis1#include <stdlib.h>void *realloc(void *ptr, size_t size);Description2 The realloc function deallocates the old object pointed to by ptr and returns apointer to a new object that has the size specified by size. The contents of the newobject shall be the same as that of the old object prior to deallocation, up to the lesser ofthe new and old sizes. Any bytes in the new object beyond the size of the old object haveindeterminate values.3 If ptr is a null pointer, the realloc function behaves like the malloc function for thespecified size. Otherwise, if ptr does not match a pointer earlier returned by a memorymanagement function, or if the space has been deallocated by a call to the free orrealloc function, the behavior is undefined. If memory for the new object cannot beallocated, the old object is not deallocated and its value is unchanged.Returns4The realloc function returns a pointer to the new object (which may have the samevalue as a pointer to the old object), or a null pointer if the new object could not beallocated.

As you can see, it doesn't specify a special case for realloc calls where the size is 0. Instead, it only states that a NULL pointer is returned on failure to allocate memory, and a pointer in all other cases. A pointer that points to 0 bytes would, then, be a viable option.

To quote a related question:

More intuitively, realloc is "conceptually equivalent" to to malloc+memcpy+free on the other pointer, and malloc-ing a 0-byte chunk of memory returns either NULL either a unique pointer, not to be used for storing anything (you asked for 0 bytes), but still to be freeed. So, no, don't use realloc like that, it may work on some implementations (namely, Linux) but it's certainly not guaranteed.

As another answer on that linked question states, the behaviour of realloc(ptr, 0) is explicitly defined as implementation defined according to the current C11 standard:

If the size of the space requested is zero, the behavior is implementation-defined: either a null pointer is returned, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object

realloc() is used to increase or decrease the memory and not to free the memory.

Check this, and use free() to release the memory (link).

I don't think you mean "empty"; that would mean "set it to some particular value that I consider to be empty" (often all bits zero). You mean free, or de-allocate.

The manual page says:

If ptr is NULL, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call is equivalent to free(ptr).

Traditionally you could use realloc(ptr, 0); as a synonym for free(ptr);, just as you can use realloc(NULL, size); as a synonym for malloc(size);. I wouldn't recommend it though, it's a bit confusing and not the way people expect it to be used.

However, nowadays in modern C the definition has changed: now realloc(ptr, 0); will free the old memory, but it's not well-defined what will be done next: it's implementation-defined.

So: don't do this: use free() to de-allocate memory, and let realloc() be used only for changing the size to something non-zero.