smart_ptr | Boost.org smart_ptr module | SDK library

A factory would normally never control the lifetime of an object. It should hand out an appropriate pointer, preferably a std::unique_ptr and the caller determines it's lifetime.

There are multiple issues with your code:

• You don't check that the inputs are exactly as expected (real, double, non-sparse, etc.)
• You are attaching memory allocated without MATLAB API functions to an mxArray
• You are freeing the memory behind the pointers right after you attach them to the mxArray
• You don't create the plhs[ ] mxArray variables before using them

Normally, when working with mex routines one would do the following in order:

• Check that inputs are exactly as expected
• Create the output plhs[ ] mxArray variables
• Get the pointers to the data areas of the plhs[ ] mxArray variables
• Pass these pointers to the calculation routines

In your case, maybe there is a reason you want to use the gsl_matrix_alloc( ) routine for your memory allocation instead of the MATLAB API memory allocation functions. Fine, but if you do this then you will have to copy the result into the plhs[ ] mxArray data area. You can't attach the pointer directly because that will screw up the MATLAB Memory Manager and lead to a crash downstream. But in all cases you need to create the plhs[ ] mxArray variables first. E.g., if we just go with your current memory allocation scheme you would need to copy the data:

EDIT for gsl data copy

As it turned out I had a file called Assert.h in my include-path (a custom file of mine). On case-insensitive filesystems as used by Windows and MacOS, this would shadow the original assert.h header that actually defines the assert macro.

The solution therefore was simply to rename my assert-header file.

(I found the solution thanks to https://github.com/luckybulldozer/VisualSFM_OS_X_Installer/issues/15)

Polymorphic allocators are stateful, which means they cannot be default-constructed - because they wouldn't know about the memory resource they're supposed to work with.

This is not particular to PMR or unique pointers, it will also crop up when e.g. using Boost Interprocess allocators on a vector - you will always have to pass an initializer for the allocator.

Ifff you want a global/singleton memory resource, you can obviously declare a custom deleter that encodes that constant:

There is no difference. The standard in [unique.ptr.single.observers] and [util.smartptr.shared.obs] both define operator* as being *get().

get should be used when you need a raw pointer to the managed object for passing to something that only excepts a raw pointer. Otherwise, * and -> are overloaded for the smart pointers to apply those operations to the managed pointer.

You could be tempeted to use &*smart_ptr to get a raw pointer to the managed object, but & is an operator that can be overloaded and could give you the wrong result. the proper way to get the address (a pointer) would be std::addressof(*smart_ptr), but using smart_ptr.get() is shorter.

As hinted by S.M., if we must use unique_ptr, the trick appears to be to make sure to define a copy constructor, e.g., this example gives the expected results with no error messages,

While I wasn't able to find a solution to this problem, I found a workaround. I switched to using pcl::PCLPointCloud2 intead of pcl::PointCloud and the code works fine.

This is the actual error:

ld: library not found for -lcuda

The compiler cannot find your CUDA C library. You will have to install it first, and / or make sure that it's in a location where the compiler can find it.

See also this question on how to install CUDA on OSX.

If you use conda, you can also do

Starting with the example in the documentation makes for a simpler implementation.