我正在尝试定义一个只能在堆上实例化的类

Question

我试图通过将删除运算符重载为友元函数来实现这一点。代码如下：

#include <iostream>


class HeapOnly
{
    int x;
    int y;
    ~HeapOnly()
    {

    }
public:
    void friend operator delete(void* a);
};

void operator delete(void* p)
{
    delete p;
}

int main()
{
    HeapOnly *abc = new HeapOnly();
    delete abc;
}

以上代码在 Visual Studio 中给出错误“Error C2248 'HeapOnly::~HeapOnly': cannot access private member declaration in class 'HeapOnly”

我不明白为什么它会出错，因为删除运算符作为友元函数重载，因此它应该能够访问私有的析构函数。

Answer 1

实际上并没有一个“删除运算符”可以让您重载。有：

• 删除表达式，如delete abc；和
• 释放内存的释放函数，其语法令人困惑的是operator delete。

换句话说，您从未重载不存在的“删除运算符”或将其声明为朋友。唯一重载并声明为友元的是释放函数。

删除表达式分两步完成：

1. 调用析构函数将对象还原为原始内存
2. 调用释放函数来释放内存

因此，私有析构函数仍然被认为是由main 直接调用的，它不是类的朋友。

我们可以做一个小实验来验证：

代码 1：没有 friend 声明：https://godbolt.org/g/WVmzNP

class HeapOnly
{
    int x;
    int y;
    ~HeapOnly() = default;
};

int main()
{
    HeapOnly *abc = new HeapOnly();
    delete abc;
}

代码 2：声明 main 为好友：https://godbolt.org/g/9PVZ4C

class HeapOnly
{
    int x;
    int y;
    ~HeapOnly() = default;

    friend int main();
};

int main()
{
    HeapOnly *abc = new HeapOnly();
    delete abc;
}

Answer 2

关于您的尝试失败的原因，请参阅其他答案。我不知道您是否以及如何实现只能在堆上实例化的类的总体目标，以及这是否可取，但我怀疑两者。

但是，您可以做的是限制取消分配通过std::allocator或std::default_delete，这样简单的自动变量是不可能的：

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>

class HeapOnly
{
    ~HeapOnly();
  public:
    bool operator < (HeapOnly const&) const;
    friend class std::allocator<HeapOnly>;
    friend class std::default_delete<HeapOnly>;
};

int main()
{
    std::vector<HeapOnly> X(10);   // okay
    HeapOnly Y;                    // ERROR: cannot be destructed
    std::sort(X.begin(),X.end());  // ERROR: requires automatic variables
    std::vector<std::unique_ptr<HeapOnly>> Z(10);    // okay
    for(auto&z:Z)
        z.reset(new HeapOnly);
    std::sort(Z.begin(),Z.end(),[](std::unique_ptr<HeapOnly> const&x,
                                   std::unique_ptr<HeapOnly> const&y)
                                { return *x < *y; }); 
}

但是请注意，很多事情都依赖于自动变量，包括std::swap 和std::sort（直接与std::sort 成为朋友并没有帮助，因为它将工作委托给特定于实现的帮助程序）。但是，您可以启用unique_ptr（和shared_ptr），这似乎与仅堆类有关，并对指向的对象进行排序。

进一步注意，尽管上面的代码可能适用于大多数（如果不是全部）STL 实现，但不能保证。例如，std::allocator<>::destroy() 可以将销毁委托给辅助函数，这是一个实现细节，因此不能成为朋友。

但是，您可以对此进行测试并使用 SFINAE 来规避此类情况。