unique_ptr handling for double pointer

Question

I'm using a C function that has a signature like:

/**
 * Read values from source file and store in a newly 
 * allocated array
 */
size_t load_array(FILE * source, double ** pdest) {
  size_t values_read;
  double * dest;
  // ...
  // Keep reading in values from source, incrementing values_read
  // resizing dest when needed.
  // ...
  *pdest = dest;
  return values_read;
}

which currently gets called in my C++ code like this:

double * my_array;
size_t array_length = load_array(source, &my_array);
// ... do stuff with my_array ...
free(my_array);

Can I wrap up my_array with std::unique_ptr so that free gets automatically called? I cannot change the C function (which is part of an external library) so I cannot change the data structure used therein.

There is a similar question on SO, but in that question the C function returned a pointer, and a unique_ptr was created around this returned value. Some of the suggested answers would work if a dumb pointer was created first and then wrapped later, e.g.:

double * my_array;
size_t array_length = load_array(source, &my_array);
auto my_array_wrapper = std::unique_ptr<double, decltype(free)*>{ my_array, free };
// ... do stuff with my_array_wrapper ...

// free() called on wrapped pointer when my_array_wrapper goes out of scope

This doesn't seem very clean to me, since I would still have the original pointer lying around in my code. What I would like to do to completely contain the pointer, with something like:

clever_ptr my_clever_array;
size_t array_length = load_array(source, my_clever_array.get_ptr_address());
// ... do stuff with my_clever_array ...

// free() called on wrapped pointer when wrapper goes out of scope

Obviously I could write a small class for this, but I'm interested in whether there are existing utilities that already provide for this.

Hes probably using legacy C code. As it shows above it takes a `double` double pointer. — Russley Shaw, Mar 11 '16 at 06:25
@H.Guijt The C function doesn't use vector methods, so I don't see how that would work. I cannot change the C function. — beldaz, Mar 11 '16 at 06:25
To whoever closed my question as a duplicate, please explain how it's the same. My function doesn't return the pointer. — beldaz, Mar 11 '16 at 07:42
@beldaz The closer asserted that `std::unique_ptr a_free { my_array, std::free };` after the `load_array`call will work in your case. — Captain Giraffe, Mar 11 '16 at 07:50
@CaptainGiraffe Thanks, I'll try that out. Still think the question is different, even if the answer happens to work for my case also. — beldaz, Mar 11 '16 at 07:54

beldaz · Accepted Answer · 2016-03-14T23:35:57.940

Turns out this can't be done the std::unique_ptr. The only methods for getting at a pointer from this class are:

pointer get() const noexcept; which, being const, won't allow the value of the managed pointer to change (the returned pointer is not const, but it is a copy of the managed one, so changing it's value will not change the value inside the unique_ptr)
pointer release() noexcept; which releases ownership of the managed pointer and so will not call free on it when it goes out of scope.

Hence the only route is to wrap up the pointer after it has been updated. To avoid leaving the pointer lying around it could be placed in a block to limit its scope:

std::unique_ptr<double, decltype(free)*> my_array_wrapper{nullptr, free};
{
  double * my_array;
  size_t array_length = load_array(source, &my_array);
  my_array_wrapper = std::unique_ptr<double, decltype(free)*>{ my_array, free };
}
// ... do stuff with my_array_wrapper ...
// free() called on wrapped pointer when wrapper goes out of scope

This could probably be extended with a wrapper for the load_array function:

size_t load_array_wrapped(FILE * source, std::unique_ptr<double, decltype(free)*> & array_wrapper) {
  double * my_array;
  size_t array_length = load_array(source, &my_array);
  my_array_wrapper = std::unique_ptr<double, decltype(free)*>{ my_array, free };
  return array_length;
}

and then call with:

std::unique_ptr<double, decltype(free)*> my_array_wrapper{nullptr, free};
size_t array_length = load_array_wrapped(source, my_array_wrapper);

Rather than using a block, you could wrap it up in a function , perhaps which returns the `unique_ptr` and the size, and takes `source` as argument — M.M, Mar 13 '16 at 23:15
Even with this solution, you have to carry the length around separately to the pointer, which is not ideal; one approach to consider would be making a custom class which holds the pointer and the length (and is non-copyable and calls `free` in its destructor, and you could provide container adapters) — M.M, Mar 13 '16 at 23:19
@M.M Thanks. I've taken your suggestion a bit further and wrapped things up with a new function that modifies the `unique_ptr` and returns the length. — beldaz, Mar 13 '16 at 23:27

unique_ptr handling for double pointer

1 Answers1