Is it possible to use a C++ smart pointers together with C's malloc?

Question

Some of my code still uses malloc instead of new. The reason is because I am afraid to use new because it throws exception, rather than returning NULL, which I can easily check for. Wrapping every call to new in a try{}catch(){} also doesn't look that good. Whereas when using malloc I can just do if (!new_mem) { /* handle error */ }.

Therefore I have a question. Can I use smart pointers together with malloc?

Something like:

SmartPointer<Type> smarty = malloc(sizeof(Type));

Something like this.

Is this possible?

Thanks, Boda Cydo.

If you want new to now throw an exception and just return NULL you can use: Type* bla = new (std::nothrow) Type();. I think it's better to use std::nothrow than malloc since the later doesn't call the constructor. — Vitor Py, Aug 13 '10 at 14:02
What are you going to do in the error handling code to compensate for not getting memory? Usually the test is if the alloc worked then do work. If it failed exit with an error code (which is a compilcated way passing control back up the stack). — Martin York, Aug 13 '10 at 15:47

James McNellis · Accepted Answer · 2010-08-13T14:10:21.413

If you are using shared_ptr or unique_ptr, you can specify a custom deleter. For example,

struct free_delete
{
    void operator()(void* x) { free(x); }
};

This can be used with shared_ptr like so:

std::shared_ptr<int> sp((int*)malloc(sizeof(int)), free_delete());

If you are using unique_ptr, the deleter is a part of the unique_ptr's type, so the deleter needs to be specified as a template argument:

std::unique_ptr<int, free_delete> up((int*)malloc(sizeof(int)));

However, it is better to use exceptions correctly, rather than avoiding them, when writing C++, especially with respect to allocation failures. In most cases, you cannot successfully recover from an allocation failure in the function trying to do the allocation, so exceptions can help you to handle the error where you are actually capable of handling it.

You can also pass `free` directly: `auto myPointer = std::unique_ptr(..., free)` — chpatrick, Dec 19 '15 at 20:06
@PatrickChilton Note that if you do this, your `unique_ptr` will be twice as large. — James McNellis, Dec 19 '15 at 23:24

score 13 · Answer 2 · answered Aug 13 '10 at 14:01

13

You can use nothrow keyword with the new operator, which will return NULL rather that throw an exception. For details see link below: http://www.cplusplus.com/reference/std/new/nothrow/

answered Aug 13 '10 at 14:01

gtikok

1,119
8
18

2

Is using `nothrow` a common practice? (Because I haven't actually seen personally use of nothrow in real practice myself.) – bodacydo Aug 13 '10 at 14:14
11

It is the most common way to use `new` when you don't want it to throw an exception. But no, it is more common to just use `new` and work *with* exception handling. If allocation fails, you can't usually do much about it anyway, so letting an exception propagate is a pretty clean way to exit gracefully. – jalf Aug 13 '10 at 14:20

score 3 · Answer 3 · answered Aug 13 '10 at 14:10

The best solution is to use new (std::nothrow) Type. This will act just like new Type, but will give null rather than throwing if it fails. This will be much easier than trying to make malloc behave like new.

If you really must use malloc, then remember to construct and destruct the object correctly:

void* memory = malloc(sizeof(Type));
Type* object = new (memory) Type;
object->~Type();
free(object); // or free(memory)

You can use this with a some smart pointers by giving it a custom deleter:

void malloc_deleter(Type* object)
{
    object->~Type();
    free(object);
}

if (void* memory = malloc(sizeof(Type)))
{
    Type* object = new (memory) Type;
    std::shared_ptr<Type> ptr(object, malloc_deleter);
    DoStuff(ptr);
}

But this would be much simpler using non-throwing new:

if (Type* object = new (std::nothrow) Type)
{        
    std::shared_ptr<Type> ptr(object);
    DoStuff(ptr);
}

Using malloc has the additional advantage of letting you use realloc: http://stackoverflow.com/a/33706568/1858225 — Kyle Strand, Nov 14 '15 at 08:56

score 2 · Answer 4 · answered Aug 13 '10 at 14:05

What code goes in /* handle error */? Is there anything you can actually DO with an out-of-memory error? I just let the application terminate with a call stack (core dump) so I have an idea at least one possible place that might be causing problems.

Using malloc to allocate memory for C++ classes and objects is not a good idea because it won't make sure that the constructors are called, possibly leaving you with uninitialized classes that may even crash if they have virtual methods.

Just use new and delete and don't worry about catching the exception, after all running out of memory IS an exceptional case and should not happen in normal runs of the application.

There are some situations in which you _can_ handle the error. For example, memory-greeding numerical computations (ex. simulations) can easily get out of memory on weak machines, but in this case you can stop right away and display an error instead of crashing. — Yury, Sep 21 '12 at 08:12

Fred Larson · Answer 5 · 2010-08-13T14:05:42.750

1

It depends on what the SmartPointer does on destruction. If you can specify free as a deallocator, that could work. For example, boost::shared_ptr allows you to specify a deleter.

I didn't pay enough attention to your reason for wanting this. I agree with the other answers that using the nothrow new is a much better idea.

edited Aug 13 '10 at 14:05

answered Aug 13 '10 at 14:00

Fred Larson

60,987
18
112
174

score 1 · Answer 6 · answered Aug 13 '10 at 14:01

1

It is possible to use malloc with smart pointers (you have to cast return value to target pointer type, though and provide custom deallocator). But better option is to use nothrow version of new operator.

http://www.cplusplus.com/reference/std/new/nothrow/

answered Aug 13 '10 at 14:01

el.pescado - нет войне

18,889
4
46
89

score 1 · Answer 7 · edited May 23 '17 at 12:34

1

You might want to try "placement new". See What uses are there for "placement new"?

edited May 23 '17 at 12:34

Community

1
1

answered Aug 13 '10 at 14:06

Kristopher Johnson

81,409
55
245
302

score 1 · Answer 8 · answered Aug 13 '10 at 14:07

Use nothrow.

Nothrow constant

This constant value is used as an argument for operator new and operator new[] to indicate that these functions shall not throw an exception on failure, but return a null pointer instead.

char* p = new (nothrow) char [1048576];
if (p==NULL) cout << "Failed!\n";
else {
    cout << "Success!\n";
    delete[] p;
}

score 1 · Answer 9 · answered Aug 13 '10 at 14:22

I have a question.

What happens if "Type" is a type whose constructor can throw? In that case, one still needs to handle exceptions in a try/catch block.

So is it a good idea to abandon exception based approach?

I would say that one can use the Abstract Factory/Factory Method design pattern and have all the 'new's in relatively lesser set of files/namespaces/classes, rather than these being scattered all around the place. That may also help in restricting the use of try/catch block to a relatively lesser code.

score 0 · Answer 10 · answered Mar 03 '20 at 11:12

0

for oneliner: unique_ptr<char, void (*)(void*)> buffer( (char*)malloc(size), free );

answered Mar 03 '20 at 11:12

LennonLam

215
1
2
10

Is it possible to use a C++ smart pointers together with C's malloc?

10 Answers10

Linked

Related