理论上，我应该能够使用自定义指针类型和删除器，以便unique_ptr管理不是指针的对象。我尝试了以下代码：
#ifndef UNIQUE_FD_H
#define UNIQUE_FD_H
#include <memory>
#include <unistd.h>
struct unique_fd_deleter {
typedef int pointer; // Internal type is a pointer
void operator()( int fd )
{
close(fd);
}
};
typedef std::unique_ptr<int, unique_fd_deleter> unique_fd;
#endif // UNIQUE_FD_H
这不起作用（带有-std=c++11参数的gcc 4.7）。它回应以下错误：
In file included from /usr/include/c++/4.7/memory:86:0,
from test.cc:6:
/usr/include/c++/4.7/bits/unique_ptr.h: In instantiation of 'std::unique_ptr<_Tp, _Dp>::~unique_ptr() [with _Tp = int; _Dp = unique_fd_deleter]':
test.cc:22:55: required from here
/usr/include/c++/4.7/bits/unique_ptr.h:172:2: error: invalid operands of types 'int' and 'std::nullptr_t' to binary 'operator!='
从深入研究unique_ptr的定义，我可以看到两个妨碍它工作的问题。第一个，似乎明显违反了标准，是unique_ptr的析构函数将“指针”（根据我的定义，int）与nullptr进行比较，以查看是否它已初始化或未初始化。这与通过布尔转换报告它的方式形成对比，布尔转换将其与"pointer()"（未初始化的“指针”）进行比较。这是我看到的错误的原因 - 整数与nullptr无法比较。
第二个问题是我需要某种方式告诉unique_ptr未初始化的值是什么。我希望以下代码段能够正常工作：
unique_fd fd( open(something...) );
if( !fd )
throw errno_exception("Open failed");
要使其工作，unique_ptr需要知道“未初始化的值”为-1，因为零是有效的文件描述符。
这是gcc中的错误，还是我想在这里做一些根本无法做到的事情？
答案 0 :(得分：9)
Deleter::pointer公开的类型必须满足the NullablePointer requirements。其中最重要的是，这个表达必须是合法的：Deleter::pointer p = nullptr;。当然，nullptr几乎是由不能隐式转换为数字这一事实定义的，因此这不起作用。
您必须使用可以使用std::nullptr_t隐式构造的类型。像这样：
struct file_desc
{
file_desc(int fd) : _desc(fd) {}
file_desc(std::nullptr_t) : _desc(-1) {}
operator int() {return _desc;}
bool operator ==(const file_desc &other) const {return _desc == other._desc;}
bool operator !=(const file_desc &other) const {return _desc != other._desc;}
bool operator ==(std::nullptr_t) const {return _desc == -1;}
bool operator !=(std::nullptr_t) const {return _desc != -1;}
int _desc;
};
您可以将其用作Deleter::pointer类型。
答案 1 :(得分：6)
你可以做一些简单的事情吗？
class unique_fd {
public:
unique_fd(int fd) : fd_(fd) {}
unique_fd(unique_fd&& uf) { fd_ = uf.fd_; uf.fd_ = -1; }
~unique_fd() { if (fd_ != -1) close(fd_); }
explicit operator bool() const { return fd_ != -1; }
private:
int fd_;
unique_fd(const unique_fd&) = delete;
unique_fd& operator=(const unique_fd&) = delete;
};
我不明白为什么你必须使用unique_ptr来设计管理指针。
答案 2 :(得分：1)
完整的样本：
#include <memory>
#include <unistd.h>
#include <fcntl.h>
template<class T, T nullvalue, class D, D d> // auto d works in new compilers.
struct generic_delete
{
class pointer
{
T t;
public:
pointer(T t) : t(t) {}
pointer(std::nullptr_t = nullptr) : t(nullvalue) { }
explicit operator bool() { return t != nullvalue; }
friend bool operator ==(pointer lhs, pointer rhs) { return lhs.t == rhs.t; }
friend bool operator !=(pointer lhs, pointer rhs) { return lhs.t != rhs.t; }
operator T() { return t; }
};
void operator()(pointer p)
{
d(p);
}
};
using unique_fd = std::unique_ptr<void, generic_delete<int, -1, decltype(&close), &close>>;
static_assert(sizeof(unique_fd) == sizeof(int), "bloated unique_fd");
int main()
{
unique_fd fd1(open("fd.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR));
write(fd1.get(), "hello\n", 6);
}
答案 3 :(得分：1)
开源Android Framework定义了一个满足您需要的unique_fd类：https://android.googlesource.com/platform/system/core/+/c0e6e40/base/include/android-base/unique_fd.h
答案 4 :(得分：1)
我建议使用shared_ptr而不是unique_ptr来管理int句柄的生存时间，因为共享所有权语义通常更合适，并且删除器的类型是已删除。您需要以下帮手：
namespace handle_detail
{
template <class H, class D>
struct deleter
{
deleter( H h, D d ): h_(h), d_(d) { }
void operator()( H * h ) { (void) d_(h_); }
H h_;
D d_;
};
}
template <class H,class D>
std::shared_ptr<H const>
make_handle( H h, D d )
{
std::shared_ptr<H> p((H *)0,handle_detail::deleter<H,D>(h,d));
return std::shared_ptr<H const>(
p,
&std::get_deleter<handle_detail::deleter<H,D> >(p)->h_ );
}
要与文件描述符一起使用：
int fh = open("readme.txt", O_RDONLY); // Check for errors though.
std::shared_ptr<int const> f = make_handle(fh, &close);
答案 5 :(得分：1)
理论上，我应该能够使用自定义指针类型和删除器，以便让
unique_ptr管理不是指针的对象。
不，您不应该。也就是说，也许可以使它编译和运行，但是您根本不应该使用unique_ptr来管理不是指针的东西。您绝对应该为您的资源编写适当的RAII类-例如OS文件描述符-或使用某个库中现有的此类。只有当您想要一个指向此类资源的 pointer 时，unique_ptr才有意义。但是，您不需要自定义删除器。
答案 6 :(得分：0)
此解决方案基于Nicol Bolas回答：
struct FdDeleter
{
typedef int pointer;
void operator()(int fd)
{
::close(fd);
}
};
typedef std::unique_ptr<int, FdDeleter> UniqueFd;
它很简短，但您必须避免将UniqueFd实例与nullptr进行比较并将其用作布尔表达式：
UniqueFd fd(-1, FdDeleter()); //correct
//UniqueFd fd(nullptr, FdDeleter()); //compiler error
if (fd.get() != -1) //correct
{
std::cout << "Ok: it is not printed" << std::endl;
}
if (fd) //incorrect, avoid
{
std::cout << "Problem: it is printed" << std::endl;
}
if (fd != nullptr) //incorrect, avoid
{
std::cout << "Problem: it is printed" << std::endl;
}
return 1;
答案 7 :(得分：0)
让Nicol Bolas课程更加通用：
template<class T=void*,T null_val=nullptr>
class Handle
{
public:
Handle(T handle):m_handle(handle){}
Handle(std::nullptr_t):m_handle(null_val){}
operator T(){return m_handle;}
bool operator==(const Handle& other) const
{return other.m_handle==m_handle;}
private:
T m_handle;
};
typedef Handle<int,-1> FileDescriptor;
typedef Handle<GLuint,0> GlResource; // according to http://stackoverflow.com/questions/7322147/what-is-the-range-of-opengl-texture-id
// ...
我不确定是否应该使用默认模板参数值。
答案 8 :(得分：0)
在cppreference.com找到了答案。 查看示例代码：
void close_file(std::FILE* fp) { std::fclose(fp); }
...
{
std::unique_ptr<std::FILE, decltype(&close_file)> fp(std::fopen("demo.txt",
"r"),
&close_file);
if(fp) // fopen could have failed; in which case fp holds a null pointer
std::cout << (char)std::fgetc(fp.get()) << '\n';
}// fclose() called here, but only if FILE* is not a null pointer
// (that is, if fopen succeeded)
在vs2019中进行了尝试，它可以工作！ 还尝试了使用member和lambda：
FileTest.h：
class A
{
std::unique_ptr<std::FILE, std::function<void(std::FILE*)>> fp;
}
FileTest.cpp
void A::OpenFile(const char* fname)
{
fp = std::unique_ptr < std::FILE, std::function<void(std::FILE*)>>(
std::fopen(fname, "wb"),
[](std::FILE * fp) { std::fclose(fp); });
}