C++ “智能指针”自动转换为裸指针但无法显式删除的模板

Question

我正在一个非常大的遗留 C++ 代码库中工作，该代码库将保持匿名。作为遗留代码库，它在各处传递原始指针。但我们正在逐渐尝试使其现代化，因此也有一些智能指针模板。这些智能指针（与 Boost 的scoped_ptr 不同）具有到原始指针的隐式转换，因此您可以将其中之一传递到采用原始指针的例程中，而无需编写 .get()。这样做的一个很大的缺点是，您也可能不小心在删除语句中使用了一个，然后就会出现双重释放错误，这可能是一个真正难以追踪的痛苦。

有没有办法修改模板，使其仍然具有到原始指针的隐式转换，但如果在删除语句中使用会导致编译错误？像这样：

#include <my_scoped_ptr>

struct A {};
extern void f(A*);

struct B
{
    scoped_ptr<A> a;

    B();
    ~B();
};

B::B()
    : a(new A)
{
    f(a); // this should compile
}

B::~B()
{
    delete a; // this should NOT compile
}

Answer 1

标准说

操作数应具有指针类型，或具有到指针类型的单个转换函数（12.3.2）的类类型。如果操作数是类类型，则通过调用上述转换函数将操作数转换为指针类型，并在本节的其余部分中使用转换后的操作数代替原始操作数。

您可以通过声明转换函数的 const 版本来 (ab) 使用缺少重载解析的情况。在符合标准的编译器上，使用 delete 就足以使其不再工作：

struct A {
  operator int*() { return 0; }
  operator int*() const { return 0; }
};

int main() {
  A a;
  int *p = a; // works
  delete a; // doesn't work
}

结果如下 在

[js@HOST2 cpp]$ clang++ main1.cpp
main1.cpp:9:3: error: ambiguous conversion of delete expression of type 'A' to a pointer
  delete a; // doesn't work
  ^      ~
main1.cpp:2:3: note: candidate function            
  operator int*() { return 0; }
  ^
main1.cpp:3:3: note: candidate function             
  operator int*() const { return 0; }
  ^
1 error generated.

---

这方面不太符合标准的编译器（EDG/Comeau、GCC）上，您可以将转换函数设为模板。 delete 不需要特定类型，因此这可以工作：

template<typename T>
operator T*() { return /* ... */ }

但是，这有一个缺点，您的智能指针现在可以转换为任何指针 -类型。尽管实际的转换仍然经过类型检查，但这不会预先排除转换，而是会在稍后给出编译时错误。遗憾的是，SFINAE 似乎无法使用 C++03 中的转换函数:) 另一种方法是从其他函数返回私有嵌套类型指针

struct A {
  operator int*() { return 0; }

private:
  struct nested { };
  operator nested*() { return 0; }
};

现在唯一的问题是转换为 void*，在这种情况下，两个转换函数同样可行。 @Luther 建议的一个解决方法是从另一个转换函数返回一个函数指针类型，它适用于 GCC 和 Comeau，并摆脱了 void* 问题，同时在没有其他问题的情况下通常的转换路径，与模板解决方案不同，

struct A {
  operator int*() { return 0; }

private:
  typedef void fty();
  operator fty*() { return 0; }
};

但请注意，只有不符合标准的编译器才需要这些解决方法。

Answer 2

没有办法可以阻止一个而不阻止另一个。任何可以将其隐式转换为函数调用指针的地方，都可以将其隐式转换为删除表达式。

最好的办法是删除转换功能。您的情况正是用户定义的转换运算符很危险且不应经常使用的原因。

---

我错了。:(

Answer 3

您可以使用 Boost 提出的技术，但我担心的是，您允许从智能指针到原始指针的隐式转换，这通常是不受欢迎的。此外，用户可以在 -> 运算符获得的指针上调用 delete ，因此您实际上无法阻止一个顽固的白痴绕过您所采用的任何机制跟上。

您确实应该只实现 get() 方法，而不是提供 operator T*() ，这样至少对 delete smartptr 的调用不会编译。非白痴应该能够弄清楚这可能是行不通的。

是的，输入 LegacyFunc(smartptr.get()) 比输入 LegacyFunc(smartptr) 需要更多工作，但前者是首选，因为它使其显式化并防止意外转换防止发生，例如delete smartptr。

如果你有这样的函数怎么办：

 void LegacyOwnPointer(SomeType* ptr);

函数将指针存储在某个地方？这会搞砸智能指针，因为现在它不知道其他东西正在拥有原始指针。

不管怎样，你都有一些工作要做。智能指针类似于原始指针，但它们并不相同，因此您不能只是查找并替换 T* 的所有实例并将其替换为 my_scoped_ptr code> 并期望它能像以前一样工作。

Answer 4

没有对此考虑太多，但是...您能否为模板类实例的强类型删除运算符提供重载，以便在包含代码时编译失败？如果这是在您的头文件中，则应防止调用删除时的隐式转换，以支持调用您的重载。

运算符删除（my_scoped_ptr）
{
//...不可编译的代码放在这里
。

如果这被证明是一个愚蠢的想法，我深表歉意

Answer 5

我可以看出你不想在哪里进行大量的 .get() 应用。您是否考虑过用更小的替代品来替代删除？

struct A
{
    friend static void Delete( A* p) { delete p; }

private:
    ~A(){}
};

struct B
{
};

int main() 
   { 

    delete new B();  //ok

    Delete( new A ); //ok

    delete new A; //compiler error

    return (0); 
    }