pulling out unique_ptr from unique_ptr<T,Deleter> - c++

Question

Can someone please advise on how to return the unique pointer from a templatised unique pointer pool with a custom deletor.
In the code snippet below i am using ObjectPool.h as my template class to get a stack of unique pointers .
I am using ObjectPool to create a sharedpool object in DBConnection.h and later in DBConnection.cpp i am simply returning the object to DBExec .
I get compile errors in DBConnection.cpp related to conversion of pointer with deleter to normal unique pointer.
> Class that will manage connection objects.
**DBConnectionPool.h**
#ifndef DBCONNECTIONPOOL_H
#define DBCONNECTIONPOOL_H
#include "DBExec.h"
#include "ObjectPool.h"
class DBConnectionPool {
static SharedPool<DBExec> pool;
static DBConnectionPool* instance;
DBConnectionPool& operator=(const DBConnectionPool&);
DBConnectionPool(const DBConnectionPool&);;
DBConnectionPool(){};
public:
...
**static std::unique_ptr<DBExec> getQueryObject();**
};
#endif /* DBCONNECTIONPOOL_H */
**DBConnection.cpp**
>implementation of getQueryObject
**std::unique_ptr<DBExec> DBConnectionPool::getQueryObject() {
return std::move(pool.acquire());
}**
/* Class that manages the unique pointer */
**ObjectPool.h**
#ifndef OBJECTPOOL_H
#define OBJECTPOOL_H
#include <memory>
#include <stack>
#include <mutex>
#include <assert.h>
template <class T>
class SharedPool {
/* Class that manages the unique pointer */
public:
using ptr_type = std::unique_ptr<T, std::function<void(T*)> >;
SharedPool() {
}
virtual ~SharedPool() {
}
void add(std::unique_ptr<T> t) {
std::lock_guard<std::mutex> lck (mt);
pool_.push(std::move(t));
}
ptr_type acquire() {
std::lock_guard<std::mutex> lck (mt);
assert(!pool_.empty());
ptr_type tmp(pool_.top().release(),
[this](T * ptr) {
this->add(std::unique_ptr<T>(ptr));
});
pool_.pop();
return std::move(tmp);
}
bool empty() const {
std::lock_guard<std::mutex> lck (mt);
return pool_.empty();
}
size_t size() const {
std::lock_guard<std::mutex> lck (mt);
return pool_.size();
}
std::stack<std::unique_ptr<T>>& getPoolStack () {
return pool_;
}
private:
> thread safe
std::mutex mt;
std::stack<std::unique_ptr<T> > pool_;
};
#endif /* OBJECTPOOL_H */

Answer 1

std::unique_ptr<T,D> and std::unique_ptr<T> are unrelated types (unless D=std::default_delete<T>). So you need to specify the type of the deleter in all your typedefs.
The next problem is you can't actually type out the type of your deleter, since it's a lambda type. So you may have to switch from a lambda to a named callable type.
template <class T>
class SharedPool {
public:
class Deleter {
public:
void operator()(T* ptr) const {
pool->add(std::unique_ptr<T,Deleter>(ptr));
}
private:
explicit Deleter(SharedPool* pool) : pool(pool) {}
SharedPool* pool;
friend class SharedPool<T>;
};
using ptr_type = std::unique_ptr<T, Deleter>;
You might also consider using std::shared_ptr since it type-erases its deleter type, but you don't seem to need the sharedness.

Answer 2

If I understand you correctly, you want to get a regular unique_ptr from one that has a custom deleter. This is not possible because returning a unique_ptr from another unique_ptr would violate the uniqueness of that pointer. Your only option would be to convert it to something, where the deleter is hidden from the type (i.e., type erasure).

Answer 3

It sounds like what you want is type erasure, or at least partial type erasure. A simple solution would be to just use std::shared_ptr:
std::shared_ptr<T>(new T, custom_deleter);
This would provide some overhead over std::unique_ptr, though some overhead is unavoidable.