c++ - 如果我为一个类写new和delete运算符，我是否必须写所有它们的重载？

Question

C++引用页列出了global new operators的8种特定于类的重载。其中有四个是为2017版的C++添加的。

类特定的分配函数

void* T::operator new  ( std::size_t count );   
void* T::operator new[]( std::size_t count );
void* T::operator new  ( std::size_t count, std::align_val_t al ); // (since C++17)
void* T::operator new[]( std::size_t count, std::align_val_t al ); // (since C++17)

特定于类别的展示位置分配功能

void* T::operator new  ( std::size_t count, user-defined-args... );
void* T::operator new[]( std::size_t count, user-defined-args... );
void* T::operator new  ( std::size_t count,
    std::align_val_t al, user-defined-args... ); // (since C++17)
void* T::operator new[]( std::size_t count,
     std::align_val_t al, user-defined-args... ); // (since C++17)

该网站还列出了global delete operators的10个特定于类的版本，其中4个是在2017年引入的。

特定于类的常规释放函数

void T::operator delete  ( void* ptr );
void T::operator delete[]( void* ptr );
void T::operator delete  ( void* ptr, std::align_val_t al ); // (since C++17)
void T::operator delete[]( void* ptr, std::align_val_t al ); // (since C++17)
void T::operator delete  ( void* ptr, std::size_t sz );
void T::operator delete[]( void* ptr, std::size_t sz );
void T::operator delete  ( void* ptr, std::size_t sz, std::align_val_t al ); // (since C++17)
void T::operator delete[]( void* ptr, std::size_t sz, std::align_val_t al ); // (since C++17)

特定于类的布局释放功能

void T::operator delete  ( void* ptr, args... );
void T::operator delete[]( void* ptr, args... );

如果我使用new和delete运算符编写C++类，是否需要重载所有的？我忽略可替换的全局运算符，因为我只编写类特定的运算符。

This other question provides info on writing ISO compliant new and delete operators，但是没有说我是否应该全部重载，或者只是重载一些。

this question about class specific new and delete operators的答案没有说明是全部替换还是部分替换。

如果您可以提供C++标准的引文或C++内存专家的意见，那将有所帮助。

Answer 1

不，您不需要为您的类编写new和delete运算符的所有变体。

有多个原因会偏爱某些新版本而不是其他版本。我将分别描述每个原因。

几乎总是喜欢具有size参数的删除运算符，而不是那些没有参数的删除运算符。

当我为可为其他类提供内存处理的基类编写删除运算符时，我会使用这些版本的删除运算符

void T::operator delete  ( void* ptr, std::size_t sz );
void T::operator delete[]( void* ptr, std::size_t sz );
void T::operator delete  ( void* ptr, std::size_t sz, std::align_val_t al ); // (since C++17)
void T::operator delete[]( void* ptr, std::size_t sz, std::align_val_t al ); // (since C++17)

并故意省略或=delete这些版本。

void T::operator delete  ( void* ptr );
void T::operator delete[]( void* ptr );
void T::operator delete  ( void* ptr, std::align_val_t al ); // (since C++17)
void T::operator delete[]( void* ptr, std::align_val_t al ); // (since C++17)

原因是std::size_t sz参数告诉我对象的大小或数组的大小。在编写基类时，我不知道派生类的对象的大小，因此使用size参数会有所帮助。我的一些内存处理程序按大小隔离对象(当所有块大小相同时，更易于池化内存)。我可以使用size参数来快速选择要搜索的内存池，而不是全部搜索。这将O(n)算法转换为O(1) Action 。

我的某些内存分配器使用“链模型”而不是“块模型”，并且size参数也有助于在其中删除。 (我将内存分配器称为“块模型”，如果它预先分配了一个巨大的块，然后将该块划分为多个单独的块，例如数组。如果每个块都指向上一个和下一个块，则将其称为“链模型”，如果每个块都指向上一个和下一个块因此，当有人从内存块链中删除一个块时，我希望delete运算符(operator)知道要删除的块的大小正确。我可以在断言的删除操作中添加一个断言(大小==下一个块的地址-该块的地址)。

在适当的地方，最好使用带有alignment参数的new和delete运算符。

既然C++ 17为新运算符提供了对齐参数，请在需要时使用它们。如果需要性能，请在4、8或16字节边界上对齐对象!它使程序运行更快。

因此，假设您有一个可识别对齐的内存分配器。它知道某些对象最好存储在4个字节的边界上，因为这些对象很小，如果使用4个字节的边界，则可以将更多对象压缩到内存中。它还知道某些对象最好在8字节边界上对齐，因为这些对象经常使用。

如果内存处理程序提供了正确的新运算符，而派生类提供了正确的对齐值，则您将知道这一点。

2017 C++标准说:

When allocating objects and arrays of objects whose alignment exceeds STDCPP_DEFAULT_NEW_ALIGNMENT, overload resolution is performed twice: first, for alignment-aware function signatures, then for alignment-unaware function signatures. This means that if a class with extended alignment has an alignment-unaware class-specific allocation function, it is the function that will be called, not the global alignment-aware allocation function. This is intentional: the class member is expected to know best how to handle that class.

这意味着编译器将检查带有alignment参数的new和delete运算符，然后检查没有alignment参数的运算符。

如果您具有可识别对齐的内存处理程序，则始终提供这些新的运算符，即使您还希望为客户端代码提供忽略对齐的选项。

void* T::operator new  ( std::size_t count, std::align_val_t al ); // (since C++17)
void* T::operator new[]( std::size_t count, std::align_val_t al ); // (since C++17)
void* T::operator new  ( std::size_t count,
    std::align_val_t al, user-defined-args... ); // (since C++17)
void* T::operator new[]( std::size_t count,
     std::align_val_t al, user-defined-args... ); // (since C++17)

如果提供了上述新的运算符，并且忽略或重载了这些重载，则可以强制代码提供对齐参数。

void* T::operator new  ( std::size_t count );
void* T::operator new[]( std::size_t count );

void* T::operator new  ( std::size_t count, user-defined-args... );
void* T::operator new[]( std::size_t count, user-defined-args... );

使用类特定于位置的新运算符提供提示。

假设您编写了一个分配多个数据成员的类，并且希望所有这些数据成员都位于同一内存页上。如果数据分布在多个内存页面上，则CPU必须将不同的内存页面加载到L1或L2高速缓存中，以便您可以访问对象的成员数据。如果您的内存处理程序可以将对象的所有数据成员放在同一页上，则您的程序将运行得更快，因为CPU不需要将多个页面加载到缓存中。

这些是类(class)特定位置的新运算符。

void* T::operator new  ( std::size_t count, user-defined-args... );
void* T::operator new[]( std::size_t count, user-defined-args... );
void* T::operator new  ( std::size_t count,
    std::align_val_t al, user-defined-args... ); // (since C++17)
void* T::operator new[]( std::size_t count,
     std::align_val_t al, user-defined-args... ); // (since C++17)

通过提供提示参数将它们重载为如下所示。

void* T::operator new  ( std::size_t count, void* hint );
void* T::operator new[]( std::size_t count, void* hint );
void* T::operator new  ( std::size_t count, std::align_val_t al, void* hint ); // (since C++17)
void* T::operator new[]( std::size_t count, std::align_val_t al, void* hint ); // (since C++17)

hint参数告诉内存处理程序尝试将对象放置在该提示地址不在同一提示地址的位置，而是将放置在同一页上。

现在，您可以编写一个看起来像这样的类，它是从您的内存处理类派生的。

class Foo : public MemoryHandler
{
public:
    Foo();
    ...
private:
    Blah * b_;
    Wham * f_;
};

Foo::Foo() : b_( nullptr ), f_( nullptr )
{
    // This should put data members on the same memory page as this Foo object.
    b_ = new ( this ) Blah;
    f_ = new ( this ) Wham;
}