shared_ptr with malloc and free

Question

I have working in large application which contain c and cpp. The all files saved as cpp extension but the code is written in c- style. I mean it is define structure rather than

Answer 1

Can I use shared_ptr with malloc and free. if yes Can anyone point out me sample code base.

Yes. shared_ptr does not allocate memory itself. However, it does delete your object once reference count drops to zero. Since it uses delete by default and you cannot use it with objects allocated by malloc (or any other way), you have to use a custom deleter.

if I create shared_ptr in my application and pass this pointer to another function if they are using malloc or calloc. will it impact any functionality.

It is not clear what are you asking here. If that function does not expect a shared pointer be passed, then extra care have to be taken. But it depends on what that function actually does.

We have call some function which accept double pointer and fill the structure inside their application and use malloc Can we assign those pointer to shared_ptr.

Yes, you can use any pointer with shared_ptr.

Answer 2

To use a std::shared_pointer with malloc() and free() you should specify a custom deleter. This should do it

std::shared_ptr<T> ptr(static_cast<T*>(malloc(sizeof(T))), free);

As long as you do not pass around the result of std::shared_ptr<T>::get(), your pointer is safe.

Edit: Added casting the result of malloc() to T*.

Answer 3

Can I use shared_ptr with malloc and free.

Yes.

Can anyone point out me sample code base.

You need to provide a custom deleter, so that memory is released using free rather than the default delete. This can be a pointer to the free function itself:

shared_ptr<void> memory(malloc(1024), free);

Remember that malloc and free only deal with raw memory, and you're responsible for correctly creating and destroying any non-trivial objects you might want to keep in that memory.

if I create shared_ptr in my application and pass this pointer to another function if they are using malloc or calloc. will it impact any functionality.

I don't quite follow the question. You can use this shared_ptr interchangably with "normal" shared pointers, if that's what you're asking. Type erasure ensures that users of the pointers aren't affected by different types of deleter. As with any shared pointer, you have to be a bit careful if you extract the raw pointer with get(); specifically, don't do anything that might free it, since you've irrevocably assigned ownership to the shared pointer.

We have call some function which accept double pointer and fill the structure inside their application and use malloc Can we assign those pointer to shared_ptr.

I guess you mean something like:

double * make_stuff() {
   double * stuff = static_cast<double*>(malloc(whatever));
   put_stuff_in(stuff);
   return stuff;
}

shared_ptr<double> shared_stuff(make_stuff(), free);

UPDATE: I didn't spot the phrase "double pointer", by which I assume you mean the C-style use of a pointer to emulate a reference to emulate a return value; you can do that too:

void make_stuff(double ** stuff);

double * stuff = 0;
make_stuff(&stuff);
shared_ptr<double> shared_stuff(stuff, free);

How will handle with realloc and calloc

It's fine to initialise the shared pointer with the result of calloc, or anything else that returns memory to be released using free. You can't use realloc, since shared_ptr has taken ownership of the original pointer and won't release it without calling free.