我是否在这个通用 unique_ptr<>() 删除器中正确使用了指针 class ？
Am I using the pointer class properly in this generic unique_ptr<>() deleter?
我创建了一个通用删除器模板，可用于创建 unique_ptr<>() 子类型，允许 Deleter 而不仅仅是 delete ptr.
它与默认优化标志（即 -O0）配合使用效果很好，但是，当我使用 -O3 T & operator * () 函数时，不知何故，returns 0 而不是 f_pointer 内容。
我想确保我们同意编译器中有问题并且我的模板是正确的。以下是一段完整的代码，应该在 Ubuntu 16.04 和 Ubuntu 18.04 以及可能支持 C++14 的其他版本下编译（请参阅下面的测试 g++ 版本）。
// RAII Generic Deleter -- allow for any type of RAII deleter
//
// To break compile with:
// g++ --std=c++14 -O3 -DNDEBUG ~/tmp/b.cpp -o b
#include <memory>
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
template<class T, T null_value, class D, D deleter>
class raii_generic_deleter
{
public:
class pointer
{
private:
T f_pointer = null_value;
public:
pointer(T p)
: f_pointer(p)
{
}
pointer(std::nullptr_t = nullptr)
: f_pointer(null_value)
{
}
explicit operator bool () const
{
return f_pointer != null_value;
}
bool operator == (pointer const rhs) const
{
return f_pointer == rhs.f_pointer;
}
bool operator != (pointer const rhs) const
{
return f_pointer != rhs.f_pointer;
}
T & operator * ()
{
return f_pointer;
}
};
void operator () (pointer p)
{
deleter(*p);
}
};
typedef std::unique_ptr<int,
raii_generic_deleter<int, -1, decltype(&::close), &::close>>
raii_fd_t;
int main(int argc, char * argv [])
{
int fd = -1;
{
raii_fd_t safe_fd;
std::cout << "default initialization: safe_fd = " << *safe_fd
<< std::endl;
fd = open("/tmp/abc.tmp", O_RDWR | O_CREAT, 0700);
std::cout << "fd = " << fd << std::endl;
safe_fd.reset(fd);
std::cout << "safe_fd after the reset(" << fd
<< ") = " << *safe_fd << std::endl;
}
if(fd != -1)
{
// assuming the safe_fd worked as expected, this call returns an error
//
int r = close(fd);
int e(errno);
std::cout << "second close returned " << r
<< " (errno = " << e << ")" << std::endl;
}
return 0;
}
（原文见 libsnapwebsites 中的 raii_generic_deleter.h）
我在使用 -O0 时得到的输出（无优化）：
default initialization: safe_fd = -1
fd = 3
safe_fd after the reset(3) = 3
second close returned -1 (errno = 9)
在这种情况下，*safe_fd 会按预期调用 returns -1 和 3。这会调用模板 T & pointer::operator * () 函数。
任何级别的优化（-O1、-O2、-O3）输出如下所示：
default initialization: safe_fd = 0
fd = 3
safe_fd after the reset(3) = 0
second close returned -1 (errno = 9)
正如我们所见，安全文件描述符 returns 0 而不是初始化后的 -1 然后又是 0 而它应该是 3.但是，由于第二次关闭按预期失败，因此析构函数正确关闭了文件。换句话说，不知何故，文件描述（3）是已知的，并被删除者正确使用。
当我以这种方式更新指针运算符时：
T & operator * ()
{
std::cout << "f_pointer within operator * = " << f_pointer
<< std::endl;
return f_pointer;
}
那么任何优化级别的输出都是正确的：
f_pointer within operator * = -1
default initialization: safe_fd = -1
fd = 3
f_pointer within operator * = 3
safe_fd after the reset(3) = 3
f_pointer within operator * = 3
second close returned -1 (errno = 9)
这可能是因为该特定功能未完全优化。
编译器：
我在 Ubuntu 16.04
上使用 stock g++ 进行了测试
g++ (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609
还有 Ubuntu 18.04
g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0
我也继续将此报告为 bug on the GNU website。
问题似乎是由于 unique_ptr::operator* 的 libstdc++ 实现所致。这是一种非常简化、精简的方式：
struct pointer
{
pointer(int val = -42) : z(val) { }
int z = -42;
int& operator*() { return z; }
};
struct my_unique_ptr
{
pointer rep;
pointer get() { return rep; }
#ifdef PROBLEM
int& operator*() { return *get(); } // libstdc++ implementation
#else
int& operator*() { return *rep; } // libc++ implementation
#endif
};
int main()
{
my_unique_ptr q;
std::cout << *q << "\n";
}
现在非常清楚 libstdc++ 不可能与您的 pointer 实现一起工作，因为它 returns 是对 operator* 中本地临时对象的引用。任何存储自己的指针对象的 pointer 都会遇到同样的问题。
标准方面，这似乎不是 libstdc++ 中的错误。该标准指定 unique_ptr::operator*() returns *get()，而 libstdc++ 忠实地做到了这一点。
如果有的话，这是标准中的缺陷。
立即解决的办法是停止在 pointer class 中定义 operator*。 unique_ptr 不需要它（NullablePointer 不需要提供它）。
因为 pointer 实际上只不过是 T 的包装器，它为给定常量提供值初始化，因此为它定义一个 operator T() 更有意义, 并使用 get() 到 "dereference" 对应的 unique_ptr.
我正在添加我自己的答案，以向对此类 RAII 删除器感兴趣的其他人展示代码中的更改（非常实用，因为您不需要在每次实例化时都指定删除器！）。
如@n.m所述。在接受的答案中， int 不是指针，因此不能作为指针访问。所以 T & operator * () 对于这种类型是不合逻辑的（因为 operator [] () 和 operator -> () 也没有意义）。
代码的问题是因为 get() 在 unique_ptr<>() 实现中被 operator * () 使用。它看起来像这样：
/// Return the stored pointer.
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
正如我们所见，get() return 是一个 pointer 副本。这样的对象是暂时的！这意味着您不能 return 从它引用并希望它保持有效。 operator * () 这样做，但是：
/// Dereference the stored pointer.
typename add_lvalue_reference<element_type>::type
operator*() const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return *get();
}
如我们所见，此函数 return 是 get() 编辑的参考 return 的内容，但随后又说它需要一个参考。这就是为什么我的 operator * () 实现必须 return 非常量引用。
通过删除该约束并使用 operator T () const 而不是 operator * () 来检索 unique_ptr<>() 的值，我得到了正确的值。
// RAII Generic Deleter -- allow for any type of RAII deleter
//
// To break compile with:
// g++ --std=c++14 -O3 -DNDEBUG ~/tmp/b.cpp -o b
#include <memory>
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
template<class T, T null_value, class D, D deleter>
class raii_generic_deleter
{
public:
class pointer
{
private:
T f_pointer = null_value;
public:
pointer(T p)
: f_pointer(p)
{
}
pointer(std::nullptr_t = nullptr)
: f_pointer(null_value)
{
}
explicit operator bool () const
{
return f_pointer != null_value;
}
bool operator == (pointer const rhs) const
{
return f_pointer == rhs.f_pointer;
}
bool operator != (pointer const rhs) const
{
return f_pointer != rhs.f_pointer;
}
operator T () const
{
return f_pointer;
}
};
void operator () (pointer p)
{
deleter(static_cast<T>(p));
}
};
typedef std::unique_ptr<int,
raii_generic_deleter<int, -1, decltype(&::close), &::close>>
raii_fd_t;
int main(int argc, char * argv [])
{
int fd = -1;
{
raii_fd_t safe_fd;
std::cout << "default initialization: safe_fd = " << safe_fd.get()
<< std::endl;
fd = open("/tmp/abc.tmp", O_RDWR | O_CREAT, 0700);
std::cout << "fd = " << fd << std::endl;
safe_fd.reset(fd);
std::cout << "safe_fd after the reset(" << fd
<< ") = " << safe_fd.get() << std::endl;
}
if(fd != -1)
{
// assuming the safe_fd worked as expected, this call returns an error
//
int r = close(fd);
int e(errno);
std::cout << "second close returned " << r
<< " (errno = " << e << ")" << std::endl;
}
return 0;
}
所以两个主要变化 (1) T & operator * () 变成了 operator T () const 和 (2) 在 main() 中，把 *safe_fd 变成了 safe_fd.get()。
注意：我还将删除函数的 f_pointer 转换为 T 以防删除函数不是一对一匹配并且自动转换会失败。 （即在我的例子中 close(int) 有一个确切的 T 作为输入，所以它会工作得很好。有时删除器可能不是那么完美。）
我创建了一个通用删除器模板，可用于创建 unique_ptr<>() 子类型，允许 Deleter 而不仅仅是 delete ptr.
它与默认优化标志（即 -O0）配合使用效果很好，但是，当我使用 -O3 T & operator * () 函数时，不知何故，returns 0 而不是 f_pointer 内容。
我想确保我们同意编译器中有问题并且我的模板是正确的。以下是一段完整的代码，应该在 Ubuntu 16.04 和 Ubuntu 18.04 以及可能支持 C++14 的其他版本下编译（请参阅下面的测试 g++ 版本）。
// RAII Generic Deleter -- allow for any type of RAII deleter
//
// To break compile with:
// g++ --std=c++14 -O3 -DNDEBUG ~/tmp/b.cpp -o b
#include <memory>
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
template<class T, T null_value, class D, D deleter>
class raii_generic_deleter
{
public:
class pointer
{
private:
T f_pointer = null_value;
public:
pointer(T p)
: f_pointer(p)
{
}
pointer(std::nullptr_t = nullptr)
: f_pointer(null_value)
{
}
explicit operator bool () const
{
return f_pointer != null_value;
}
bool operator == (pointer const rhs) const
{
return f_pointer == rhs.f_pointer;
}
bool operator != (pointer const rhs) const
{
return f_pointer != rhs.f_pointer;
}
T & operator * ()
{
return f_pointer;
}
};
void operator () (pointer p)
{
deleter(*p);
}
};
typedef std::unique_ptr<int,
raii_generic_deleter<int, -1, decltype(&::close), &::close>>
raii_fd_t;
int main(int argc, char * argv [])
{
int fd = -1;
{
raii_fd_t safe_fd;
std::cout << "default initialization: safe_fd = " << *safe_fd
<< std::endl;
fd = open("/tmp/abc.tmp", O_RDWR | O_CREAT, 0700);
std::cout << "fd = " << fd << std::endl;
safe_fd.reset(fd);
std::cout << "safe_fd after the reset(" << fd
<< ") = " << *safe_fd << std::endl;
}
if(fd != -1)
{
// assuming the safe_fd worked as expected, this call returns an error
//
int r = close(fd);
int e(errno);
std::cout << "second close returned " << r
<< " (errno = " << e << ")" << std::endl;
}
return 0;
}
（原文见 libsnapwebsites 中的 raii_generic_deleter.h）
我在使用 -O0 时得到的输出（无优化）：
default initialization: safe_fd = -1
fd = 3
safe_fd after the reset(3) = 3
second close returned -1 (errno = 9)
在这种情况下，*safe_fd 会按预期调用 returns -1 和 3。这会调用模板 T & pointer::operator * () 函数。
任何级别的优化（-O1、-O2、-O3）输出如下所示：
default initialization: safe_fd = 0
fd = 3
safe_fd after the reset(3) = 0
second close returned -1 (errno = 9)
正如我们所见，安全文件描述符 returns 0 而不是初始化后的 -1 然后又是 0 而它应该是 3.但是，由于第二次关闭按预期失败，因此析构函数正确关闭了文件。换句话说，不知何故，文件描述（3）是已知的，并被删除者正确使用。
当我以这种方式更新指针运算符时：
T & operator * ()
{
std::cout << "f_pointer within operator * = " << f_pointer
<< std::endl;
return f_pointer;
}
那么任何优化级别的输出都是正确的：
f_pointer within operator * = -1
default initialization: safe_fd = -1
fd = 3
f_pointer within operator * = 3
safe_fd after the reset(3) = 3
f_pointer within operator * = 3
second close returned -1 (errno = 9)
这可能是因为该特定功能未完全优化。
编译器：
我在 Ubuntu 16.04
上使用 stock g++ 进行了测试g++ (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609
还有 Ubuntu 18.04
g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0
我也继续将此报告为 bug on the GNU website。
问题似乎是由于 unique_ptr::operator* 的 libstdc++ 实现所致。这是一种非常简化、精简的方式：
struct pointer
{
pointer(int val = -42) : z(val) { }
int z = -42;
int& operator*() { return z; }
};
struct my_unique_ptr
{
pointer rep;
pointer get() { return rep; }
#ifdef PROBLEM
int& operator*() { return *get(); } // libstdc++ implementation
#else
int& operator*() { return *rep; } // libc++ implementation
#endif
};
int main()
{
my_unique_ptr q;
std::cout << *q << "\n";
}
现在非常清楚 libstdc++ 不可能与您的 pointer 实现一起工作，因为它 returns 是对 operator* 中本地临时对象的引用。任何存储自己的指针对象的 pointer 都会遇到同样的问题。
标准方面，这似乎不是 libstdc++ 中的错误。该标准指定 unique_ptr::operator*() returns *get()，而 libstdc++ 忠实地做到了这一点。
如果有的话，这是标准中的缺陷。
立即解决的办法是停止在 pointer class 中定义 operator*。 unique_ptr 不需要它（NullablePointer 不需要提供它）。
因为 pointer 实际上只不过是 T 的包装器，它为给定常量提供值初始化，因此为它定义一个 operator T() 更有意义, 并使用 get() 到 "dereference" 对应的 unique_ptr.
我正在添加我自己的答案，以向对此类 RAII 删除器感兴趣的其他人展示代码中的更改（非常实用，因为您不需要在每次实例化时都指定删除器！）。
如@n.m所述。在接受的答案中， int 不是指针，因此不能作为指针访问。所以 T & operator * () 对于这种类型是不合逻辑的（因为 operator [] () 和 operator -> () 也没有意义）。
代码的问题是因为 get() 在 unique_ptr<>() 实现中被 operator * () 使用。它看起来像这样：
/// Return the stored pointer.
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
正如我们所见，get() return 是一个 pointer 副本。这样的对象是暂时的！这意味着您不能 return 从它引用并希望它保持有效。 operator * () 这样做，但是：
/// Dereference the stored pointer.
typename add_lvalue_reference<element_type>::type
operator*() const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return *get();
}
如我们所见，此函数 return 是 get() 编辑的参考 return 的内容，但随后又说它需要一个参考。这就是为什么我的 operator * () 实现必须 return 非常量引用。
通过删除该约束并使用 operator T () const 而不是 operator * () 来检索 unique_ptr<>() 的值，我得到了正确的值。
// RAII Generic Deleter -- allow for any type of RAII deleter
//
// To break compile with:
// g++ --std=c++14 -O3 -DNDEBUG ~/tmp/b.cpp -o b
#include <memory>
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
template<class T, T null_value, class D, D deleter>
class raii_generic_deleter
{
public:
class pointer
{
private:
T f_pointer = null_value;
public:
pointer(T p)
: f_pointer(p)
{
}
pointer(std::nullptr_t = nullptr)
: f_pointer(null_value)
{
}
explicit operator bool () const
{
return f_pointer != null_value;
}
bool operator == (pointer const rhs) const
{
return f_pointer == rhs.f_pointer;
}
bool operator != (pointer const rhs) const
{
return f_pointer != rhs.f_pointer;
}
operator T () const
{
return f_pointer;
}
};
void operator () (pointer p)
{
deleter(static_cast<T>(p));
}
};
typedef std::unique_ptr<int,
raii_generic_deleter<int, -1, decltype(&::close), &::close>>
raii_fd_t;
int main(int argc, char * argv [])
{
int fd = -1;
{
raii_fd_t safe_fd;
std::cout << "default initialization: safe_fd = " << safe_fd.get()
<< std::endl;
fd = open("/tmp/abc.tmp", O_RDWR | O_CREAT, 0700);
std::cout << "fd = " << fd << std::endl;
safe_fd.reset(fd);
std::cout << "safe_fd after the reset(" << fd
<< ") = " << safe_fd.get() << std::endl;
}
if(fd != -1)
{
// assuming the safe_fd worked as expected, this call returns an error
//
int r = close(fd);
int e(errno);
std::cout << "second close returned " << r
<< " (errno = " << e << ")" << std::endl;
}
return 0;
}
所以两个主要变化 (1) T & operator * () 变成了 operator T () const 和 (2) 在 main() 中，把 *safe_fd 变成了 safe_fd.get()。
注意：我还将删除函数的 f_pointer 转换为 T 以防删除函数不是一对一匹配并且自动转换会失败。 （即在我的例子中 close(int) 有一个确切的 T 作为输入，所以它会工作得很好。有时删除器可能不是那么完美。）