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

Question

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

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

#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）到指针类型的类类型。如果操作数具有类类型，则通过调用上述转换函数将操作数转换为指针类型，并在本节的其余部分使用转换后的操作数代替原始操作数。

您可以 (ab) 通过声明转换函数的 const 版本来使用重载解析的缺失。在足以使它不再与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 /* ... */ }

但是，这样做的缺点是您的智能指针现在可以转换为 any 指针类型。虽然实际的转换仍然经过类型检查，但这并不排除预先进行转换，而是在很久以后给出编译时错误。可悲的是，C++03 中的转换函数似乎无法使用 SFINAE :) 另一种方法是从另一个函数返回私有嵌套类型指针

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

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

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

---

I'm wrong.:(

Answer 3

您可以使用Boost 提出的技术，但我担心的是您允许从智能指针隐式转换为原始指针，这通常是不受欢迎的。此外，用户可以通过-> 操作符获得的指针调用delete，所以你真的无法阻止一个坚定的白痴绕过你想出的任何机制。

你真的应该只实现一个get() 方法而不是提供operator T*()，这样至少对delete smartptr 的调用不会编译。非白痴应该能够弄清楚这可能是有原因的。

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

如果你有这样的功能怎么办：

 void LegacyOwnPointer(SomeType* ptr);

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

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

Answer 4

对此并没有考虑太多，但是...您能否为 operator delete 提供一个重载，该重载对于您的模板类的实例是强类型的，这样当包含代码时编译会失败？如果这是在您的头文件中，则应防止调用中的隐式转换以支持调用您的重载。

操作员删除（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); 
    }