struct my_deleter {
    typedef pointer int;
    void operator()(pointer x) { my_close(x); }
};

std::unique_ptr<int, my_deleter> p;

A>struct my_deleter {
A>    typedef pointer int;
A>    void operator()(pointer x) { my_close(x); }
A>};

A>std::unique_ptr<int, my_deleter> p;
A>

struct IntFileCloserDeleter
{
    typedef int pointer;
    void operator()(pointer x) { if (x != -1) ::close(x); }
};

int file1 = ::open(filenameOutput, O_WRONLY|O_CREAT|O_TRUNC, 0);
std::unique_ptr<int, IntFileCloserDeleter> filecloser { file1 };

/usr/include/c++/4.8/bits/unique_ptr.h: In instantiation of 'std::unique_ptr<_Tp, _Dp>::~unique_ptr() [with _Tp = int; _Dp = IntFileCloserDeleter]':
/home/antonio/workspace/...............cpp:55:78: required from here
/usr/include/c++/4.8/bits/unique_ptr.h:183:12: error: invalid operands of types 'int' and 'std::nullptr_t' to binary 'operator!='
if (__ptr != nullptr)

      // Destructor.
      ~unique_ptr() noexcept
      {
    auto& __ptr = std::get<0>(_M_t);
    if (__ptr != nullptr)
      get_deleter()(__ptr);
    __ptr = pointer();
      }

template <class Descriptor, class FuncType, FuncType Function>
class DescriptorCloser
{
public:
    inline explicit DescriptorCloser(Descriptor file, Descriptor null = -1) : d_(file), null_(null) {}
    inline ~DescriptorCloser() { if (d_ != null_) Function(d_); }
    inline Descriptor get() const { return d_; }
    inline Descriptor release() { Descriptor d = d_; d_ = null_; return d; }
private:
    Descriptor d_;
    Descriptor null_;
};

typedef DescriptorCloser<int, int(*)(int), ::close> FileCloser;

int myfile = ::open(...);
FileCloser filecloser(myfile);

struct num
{
    int v;
    num(int v = -1) : v(v) {}
    bool operator == (num const& other) const { return v == other.v; }
    bool operator != (num const& other) const { return v != other.v; }

    bool operator == (std::nullptr_t) const { return *this == num(); }
    bool operator != (std::nullptr_t) const { return *this != num(); }
};

num install(int v) { std::cout << "install " << v << std::endl; return v; }
void utilize(num x) { std::cout << "utilize " << x.v << std::endl; }

struct num_deleter
{
    typedef num pointer;
    void operator()(pointer x) const { utilize(x); }
};

int main()
{
    std::cout << "{" << std::endl;
    {
        std::unique_ptr<num, num_deleter> p(install(123)), q(install(0)), r;
        std::cout << p.get().v << " " << q.get().v << " " << r.get().v << std::endl;
    }
    std::cout << "}" << std::endl;
}

template <class Descriptor, Descriptor NullValue, class FuncType, FuncType Function>
class DescriptorCloser : private boost::noncopyable
{
public:
    inline explicit DescriptorCloser(Descriptor file) : d_(file) {}
    inline ~DescriptorCloser() { if (d_ != NullValue) Function(d_); }
    inline Descriptor get() const { return d_; }
    inline Descriptor release() { Descriptor d = d_; d_ = NullValue; return d; }
private:
    Descriptor d_;
};

typedef DescriptorCloser<int, -1, int(*)(int), ::close> FileCloser;

_>int myfile = ::open(...);
_>FileCloser filecloser(myfile);
_>

{
  FILE * fp = fopen("test.out", "wb"); SCOPE_EXIT(fclose(fp));
...
  fread();
}

std::shared_ptr<int> Wrap(int handle)
{
  return std::shared_ptr<int>(new int(handle), [](int* handle)
  {
    if (!handle)
      return;

    CloseMyHandle(*handle);
    delete handle;
  });
}

//usage
int myHandle = OpenMyHandle();//get handle;
std::shared_ptr<int> safeHandle = Wrap(myHandle);
//use safeHandle
UseHandle(*safeHandle);

   const int f = open("xxx.txt", O_RDONLY, 0);
   BOOST_SCOPE_EXIT((f)) {
      close(f);
   } BOOST_SCOPE_EXIT_END
   // . . .

      int handle = open("xxx.txt", O_RDONLY, 0);
      auto FunOnExit = [](int* pHandle){ return close(*pHandle); };
      std::unique_ptr<int, decltype(FunOnExit)> myfile(&handle, FunOnExit);

#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>

...

      int handle = open("xxx.txt", O_RDONLY, 0);
      boost::shared_ptr<void> guard(static_cast<void*>(0), boost::bind(close, handle));