how to set pointer to a memory to NULL using memset?

Question

Hi,

I have a structure

typedef struct my_s {

   int x;
   ...
} my_T;

my_t * p_my_t;

I want to set the address of p_my_t to NULL, tried:

memset (&p_my_t, 0, sizeof(my_t*))

This does not look right,

what is the correct way of doing this? appreciate it...

---

Amendment to question - asking a radically more complex question:

Thanks, here is what I am trying to do:

• Two processes, A and B
• malloc p_my_t in A, B has N threads and can access it
• Start deleting in A but I can not simply free it since threads in B may still using it.
• So I call a function, pass address of p_my_t to B to set its address to NULL in B so no other threads in B can use anymore
• After call back from B, I then free memory in A

NB: there is no standard way to manage memory allocations via shared memory between processes. You will have to do some rather careful thinking about what is going on.

Answer 1

Don't use memset to initialize a null pointer as this will set the memory to all bits zero which is not guaranteed to be the representation of a null pointer, just do this:

p_my_t = NULL;

or the equivalent:

p_my_t = 0;

Answer 2

What exactly are you trying to do? p_my_t is already a pointer, but you haven't allocated memory for it. If you want to set the pointer to NULL, simply do

p_my_t = NULL;

Trying to dereference this pointer will result in a segmentation fault (or access violation on Windows).

Once the pointer actually pointers to something (e.g. via malloc() or by assigning to it the address of a struct my_T), then you can properly memset() it:

memset(p_my_t, 0, sizeof(struct my_T));

This will zero out the entire structure, setting all fields to zero.

Answer 3

Thanks, here is what I an trying to do

• two processes, A and B
• malloc p_my_t in A, B has N threads and can access it
• start deleting in A but I can not simply free it since threads in B may still using.
• so I call a function, pass address of p_my_t to B to set its address to NULL in B so no others threads in B can use anymore
• After call back from B, I then free memory in A

Answer 4

Per your reply (elsewhere in this post) stating:

Thanks, here is what I an trying to do

• two processes, A and B
• malloc p_my_t in A, B has N threads and can access it
• start deleting in A but I can not simply free it since threads in B may still using.
• so I call a function, pass address of p_my_t to B to set its address to NULL in B so no others threads in B can use anymore
• After call back from B, I then free memory in A

What you need is some form of synchronization between all your threads and processes. I'm not sure of how you are sharing this object between processes, but I suspect you are using shared memory.

Normally I would recommend using a shared pointer class (such as Boost's shared_ptr class), but I'm not sure of how well that would work in this scenario. You may want to consider tweaking your class so that it tracks its own references and can be used with the Boost intrusive_ptr class.

That way, process A can simply forget about the object, and when process B is finished, the instance of my_T will know that there are no more references left and clean itself up.

The synchronization would come into play here when my_T is adding or removing references internally (so you don't run into nasty race conditions where it thinks it should clean itself up but is really still in use).

One other approach that has a bit more of a "kluge" feel to it is to give each instance of my_T an "is-valid" flag so that all processes/threads using it will know whether or not to continue doing so.

For more details on Boost's various pointer classes, check out their documentation.

Answer 5

The recommended code for setting a pointer to null is assigning 0 (zero). Bjarne Stroustrup does it :) Anyway it is just as expressive as NULL and does not depend on a macro definition.

Note that NULL is not a keyword, it is not reserved and while it would be confusing to redefine, nothing says that you should not (more than style). A coworker often jokes about defining NULL to something different than 0 in some header just to see how other people's code behave.

In the upcoming standard there will be a more expressive nullptr keyword to identify a null pointer.

Answer 6

I think maybe you want

extern void set_t_pointer_to_null(my_T *pp);

and call

set_t_pointer_to_null(&p_my_t);

where

void set_t_pointer_to_null(my_T *pp) { *pp = NULL; }

I'm not sure it's worth defining a function to do this, but I think this answers the question you're trying to ask.

Answer 7

From reading your multi-thread comments I should say there is no safe sequence of code to accomplish your task. You will have to step back and reexamine your algorithm.

Answer 8

If I get it right, memset won't solve your problem. If A and B are separate processes, then p_my_t in process A will be different form p_my_t in process B. You just can't pass a pointer between different processes. I sugest you use some kind of IPC mechanism in order to sinchronyze your two processes (message queues, for example), and just using p_my_t = NULL instead of memset.

Answer 9

Per your update, it seems to me that what you are really trying to do is guard access to a resource, which means you should use a read/write lock that is shared between the processes to guard the ptr to that resource, and test the ptr before using.

• Allocate the structure in shared memory.
• Allocate the ptr to the structure in shared memory.
• Guard access to the ptr to the structure with a Read/Write lock.
• Process A should acquire a WRITE lock to the ptr when initializing or invalidating the ptr and structure.
• Process B should acquire a READ lock to the ptr, and test that the ptr is valid before using the structure