理论上，我应该能够使用自定义指针类型和deleter，以便让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中的一个错误，还是我试图在这里做一些根本无法完成的事情？
Deleter::pointer公开的类型必须满足NullablePointer的要求。其中最主要的，这个表述必须是合法的：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类型。
你能做一些简单的事情吗？
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，它是为管理指针而设计的。
在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中尝试过它，它有效！还尝试了成员和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); });
}
完整样本：
#ifdef _MSC_VER
#define _CRT_NONSTDC_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include <io.h>
#else
#include <unistd.h>
#endif
#include <memory>
#include <fcntl.h>
template<auto nullvalue, auto delete_>
class unique
{
using T = decltype(nullvalue);
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()(T p)
{
delete_(p);
}
};
public:
using type = std::unique_ptr<struct not_used, generic_delete>;
};
int main()
{
using unique_fd = unique<-1, close>::type;
static_assert(sizeof(unique_fd) == sizeof(int), "bloated unique_fd");
unique_fd fd1(open("fd.txt", O_WRONLY | O_CREAT | O_TRUNC));
write(fd1.get(), "hellon", 6);
}
开源Android Framework定义了一个可能满足您需求的unique_fd类：https://android.googlesource.com/platform/system/core/+/c0e6e40/base/include/android-base/unique_fd.h
让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
// ...
我不确定我是否应该有默认的模板参数值。
此解决方案基于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;
我建议使用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);
不要将(智能(指针强制为非指针对象
理论上，我应该能够使用自定义指针类型和deleter，以便让
unique_ptr管理一个不是指针的对象。
不，你不应该。也就是说，也许在编译和运行方面，但您不应该使用unique_ptr来管理非指针的东西。您绝对应该为您的资源编写一个合适的RAII类，例如操作系统文件描述符，或者使用某个库中现有的此类类。只有当您想要指向此类资源的指针时，unique_ptr才有意义；但是，您不需要自定义deleter。