new/delete 演算子のオーバーロード

#はじめに

[C++オーバーロード大全](http://qiita.com/rinse_/items/9d87d5cb0dc1e89d005e)では、たくさんのストックを頂きありがとうございました。
この記事は、上の記事で解説することを避けたCreate/Destroy ObjectおよびCreate/Destroy Objects、すなわちnew/delete演算子とnew[]/delete[]演算子について解説したいと思います。

なお、規格の参照には、C++11にはn3337を、C++14にはn3936を使用しました。正規の規格書ではないのでご了承ください。

# Create/Destroy Object

```cpp
// usual new/delete
void* operator new(std::size_t) ; // ...(A)
void operator delete(void*) noexcept ; // ...(B)
void operator delete(void*, std::size_t) noexcept ; // ...(C)

// placement new/delete
void* operator new(std::size_t, Args...) ; // ...(D)
void operator delete(void*, Args...) noexcept ; // ...(E)
```

オブジェクト構築/破壊演算子。規格ではallocation or deallocation functionと呼ばれているので、確保/解放関数としてもいいですね。まあ、そんな名前では通常呼ばれず、ふつうは単にnew/deleteと呼ばれます。この演算子は他の演算子と違い、引数や戻り値に厳密な制限があります。また、この演算子は注意深くオーバーロードする必要があります。usual(non-placement) new/delete、placement new/delete、クラススコープに定義される場合、グローバルスコープに定義される場合というように場合分けして説明していきたいと思います。

## クラススコープに定義される場合

### usual new/delete

usual new/delete演算子とは、(placement new/deleteと比較して)通常のnew/delete演算子のことです。つまり、以下のような文脈で呼ばれるnew/delete演算子のことを言います。

```cpp
sth* p = new sth(); // usual new
delete p; // usual delete
```

usual new演算子はシグニチャが`void* operator new(std::size_t)`でなければなりません。[^1]
usual delete演算子はシグニチャが`void operator delete(void*)`あるいは`void operator delete(void*, std::size_t)`でなければなりません。[^2]

[^1]: The return type shall be void*. The first parameter shall have type std::size_t (18.2). The first parameter shall not have an associated default argument (8.3.6). [n3337/n3639, 3.7.4.1]
[^2]: Each deallocation function shall return void and its first parameter shall be void*. [n3337/n3639, 3.7.4.2]

```cpp
// usual new/delete
void* operator new(std::size_t) ; // ...(A)
void operator delete(void*) noexcept ; // ...(B)
void operator delete(void*, std::size_t) noexcept ; // ...(C)
```

クラススコープにnew/delete演算子を用意した場合、そのクラスをnew/deleteする場合には常に用意したものが使われるようになります。例えば、以下のようなクラスを用意した場合、`new sth()`とした場合(1)が、`delete ps`とした場合は(2)が呼ばれます。これは大切なことなのですが、両者は必ず対応させてオーバーロードするようにしてください。つまり、`new`の動作のみをオーバーロードしたいと思っても、`delete`もオーバーロードすることが強く推奨されます。

```cpp
struct sth
{
  void* operator new(std::size_t) ; // usual new...(1)
  void operator delete(void*) noexcept ; // usual new...(2)
};
...

sth* p = new sth(); // (1)が呼ばれる
delete p; // (2)が呼ばれる
```

ちなみに、deleteのシグニチャに(C)のものを使うと、そちらがusual deleteという扱いになります。この場合、第二引数には第一引数に示されるオブジェクトのサイズが渡されます。

```cpp
struct sth
{
  void* operator new(std::size_t) ; // usual new...(1)
  void operator delete(void*, std::size_t) noexcept ; // usual new...(2)
};
...

sth* p = new sth(); // (1)が呼ばれる
delete p; // (2)が呼ばれる
```

両方用意すると、(B)のシグニチャが優先されます。その場合、**(C)のシグニチャのdeleteはplacement deleteという扱いになります**。

```cpp
struct sth
{
  void* operator new(std::size_t) ; // usual new...(1)
  void operator delete(void*) noexcept ; // usual delete...(2)
  void operator delete(void*, std::size_t) noexcept ; // placement delete...(3)
};
...

sth* p = new sth(); // (1)が呼ばれる
delete p; // (2)が呼ばれる
```


### placement new/delete

placement new/deleteとは、usual new/deleteよりも引数を多く持つnew/deleteのことです。すなわち、以下のような文脈で呼ばれるnew/deleteのことを指します。第二引数に`std::nothrow_t`を取るplacement new/deleteを想像してください。

```cpp
sth* p = new(std::nothrow) sth(); // placement new

p->~sth(); // call dtor
sth::operator delete(p, std::nothrow); // call the deallocation function
```

言いたいことは分かります。delete式はplacement形式のものが用意されていないので、デストラクタとdeallocation functionをそれぞれ手動で呼ぶ必要があります。
placement new演算子はシグニチャが`void* operator new(std::size_t, Args...)`でなければなりません。Argsは任意の数の任意の型となります。
placement delete演算子はシグニチャが`void operator delete(void*, Args...)`でなければなりません。同様に、Argsは任意の数の任意の型となります。

```cpp
// placement new/delete
void* operator new(std::size_t, Args...) ; // ...(D)
void* operator delete(std::size_t, Args...) noexcept ; // ...(E)
```

呼び出し方が変わるだけで大してusual new/deleteと変わるところはありません。usual new/delete同様に、必ず対応したplacement new/deleteを定義する必要があります。ここで、対応したnew/deleteというのは、`Args...`部分が同じnew/deleteという意味です。
例えば、以下のようなplacement new/deleteを考えます。

```cpp
struct sth
{
  void* operator new(std::size_t n, void* p) { return p; }
  void operator delete(void*, void*) noexcept {}
};
```

恐らくこのsthは、何度も生成･破棄が繰り返されるなどの理由があるのでしょう。以下のように使用することが想定されます。

```cpp
sth* p = static_cast<sth>(std::malloc(sizeof(sth)));
p = operator new(p) sth();

p->~sth();
sth::operator delete(p, p);
std::free(p);
```

`operator delete`を直接呼び出すときは、引数に`operator new`と同じものを入れることが推奨されます。ちなみに、コンストラクタで例外が投げられた場合、補足される前にまず`operator delete`が呼び出されますが、placement newの文脈でコンストラクタが例外を投げた場合、対応する`operator delete`が呼び出されることになります。この意味でも、usual, placementに限らずnew/deleteはセットで用意することが強く推奨されます。

http://ideone.com/TuhbXS


### operator delete(void*, std::size_t) の両義性

`operator delete(void*, std::size_t)`はusual deleteとして紹介しましたが、placement deleteとなりうることにも触れました。ここで、以下のような場合を考えます。

```cpp
struct sth
{
  void* operator new(std::size_t, std::size_t) ; // placement new
  void operator delete(void*, std::size_t) noexcept ; // usual delete
};
```

このクラス`sth`は`void operator delete(void*)`を持たないため、`void operator delete(void*, std::size_t)`はusual deleteとして定義されます。しかしシグニチャとしては、placement newである`void* operator new(std::size_t, std::size_t)`と対応するものを持っています。つまり、placement newの中でコンストラクタが例外を投げた場合にも呼び出されることになります。ゆえに、このようなプログラムはill-formedであるとされ、その動作は保証されません。
`void* operator new(std::size_t, std::size_t)`というシグニチャを持つplacement newを定義したい場合には、`void operator delete(void*)`と`void operator delete(std::size_t)`という2つのdelete演算子を書かなければならないということになります。

```cpp
struct sth
{
  void* operator new(std::size_t) ; // usual new
  void* operator new(std::size_t, std::size_t) ; // placement new
  void operator delete(void*) noexcept ; // usual delete
  void operator delete(void*, std::size_t) noexcept ; // placement delete
};
```

## グローバルスコープに定義される場合

### usual new/delete

```cpp
void* operator new(std::size_t) ;
void operator delete(void*) noexcept ; // C++11
void operator delete(void*, std::size_t) noexcept ; // C++14
```

new/delete演算子はグローバルスコープに置くこともできます。new/delete演算子は名前空間にくるむことができないので、常にグローバルスコープに定義されるnew/delete演算子は一つとなります。[^3]static修飾子やinline修飾子を付与した場合の動作は未定義です。ユーザ定義のnew/delete演算子がない場合には標準ライブラリが用意してくれます。ユーザがこれを定義した場合でもnew/delete演算子はC++ライブラリによって暗黙的に各翻訳単位に宣言がされます[^4]ので、全ての翻訳単位から前方宣言なしに利用することができます。
以下の例は、C++14のコードとして解釈してください。実は、グローバルスコープに定義されるnew/delete演算子のオーバーロードはC++11とC++14で挙動が変わるのです。C++11とC++14の差異についてはまた後述します。

[^3]: A C++ program shall provide at most one definition of a replaceable allocation or deallocation function. Any such function definition replaces the default version provided in the library (17.6.4.6). [n3337/n3936, 3.7.2]
[^4]: The following allocation and deallocation functions (18.6) are implicitly declared in global scope in each translation unit of a program. [n3337/n3946, 3.7.4]

```sub.cpp
#include <cstdint>
#include <cstdlib>
#include <new>

void* operator new(std::size_t n)
{
  std::puts("usual new (sub.cpp)");
  void* p = std::malloc(n);
  return p ? p : throw std::bad_alloc();
}
void operator delete(void* p, std::size_t)
{
  std::puts("usual delete (sub.cpp)");
  std::free(p);
}
```

```main.cpp
int main()
{
  int* p = new int(); // outputs "usual new (sub.cpp)"
  delete p; // outputs "usual delete (sub.cpp)"
}
```

ちなみに、クラススコープのものとグローバルスコープのものと、どちらもnew/deleteがオーバーロードされている場合、クラススコープのものが優先されます。その場合は、`::new`と明示すればグローバルスコープのものを使うこともできます。ただし、`::new`で構築したオブジェクトは`::delete`で、`new`で構築したオブジェクトは`delete`で破棄しなくてはなりません。スマートポインタなどを使うときにこれはしばしば見つけにくいバグを生みます。

http://ideone.com/wJWl5e

### placement new/delete

```cpp
void* operator new(std::size_t, Args...) ; // ...(1)
void operator delete(void*, Args...) noexcept ; // ...(2)
```

ただし、C++14では(2)における`void operator delete(void*, std::size_t)`を除きます。
また注意点はすべてusual new/deleteと変わりません。

### C++11とC++14の差異

グローバルスコープにnew/delete演算子のオーバーロードを定義することについて、C++11とC++14とで大きな差異があるというお話はずっとしていましたが、ここでその差異について書いておこうと思います。

#### 標準ライブラリが用意するnew/deleteのシグニチャの違い
C++11の時点では、グローバルスコープに定義される`operator delete(void*, std::size_t)`は全てplacement deleteでした。しかしC++14では`void operator delete(void*, std::size_t)`と従来の`operator delete(void*, std::size_t)`の両方がusual deleteとして認められるようになりました（両方定義された場合、その両方がusual deleteとして認められます。[^5]）。これに伴い、標準ライブラリは従来のusual deleteと新しいusual deleteの両方を提供してくれるようになりました。
また、解放関数が例外によって終了した場合、その動作が未定義であるというのはC++11から変わらないのですが[^6]、これに合わせてC++14では標準ライブラリの提供する`operator delete`にnoexcept指定がされています。ゆえに、私たちがこれを定義する場合には、C++11かC++14かを問わずnoexceptを指定すべきです。

[^5]: The global operator delete with exactly one parameter is a usual(nonplacement) deallocation function. The global operator delete with exactly two parameters, the second of which has type std::size_t, is a usual deallocation function.
[^6]: 3 If a deallocation function terminates by throwing an exception, the behavior is undefined. [n3337/n3639, 3.7.4.2]

c++11で標準ライブラリが提供する関数は以下の通りです。[^7]

[^7]: [n3337, 3.7.4]


```cpp11.cpp
void* operator new(std::size_t) ;
void* operator new[](std::size_t) ; 
void operator delete(void*) ; 
void operator delete[](void*) ; 
```

c++14で標準ライブラリが提供する関数は以下の通りです。[^8]

[^8]: [n3639, 3.7.4]

```cpp14.cpp
void* operator new(std::size_t) ; 
void* operator new[](std::size_t) ; 
void operator delete(void*) noexcept ; 
void operator delete[](void*) noexcept ; 
void operator delete(void*, std::size_t) noexcept ; 
void operator delete[](void*, std::size_t) noexcept ;
```

よって、c++14以降のグローバルスコープに定義されるnew/deleteでは、クラススコープのものとは異なり以下のような対応付けになります。

```cpp
void* operator new(std::size_t) ; // usual
void* operator new(std::size_t, std::size_t) ; // placement

void operator delete(void*) ; // usual
void operator delete(void*, std::size_t) ; // usual 
```

#### 推奨されるシグニチャの違い
前述の通り、c++11では`void operator delete(void*)`しかusual deleteとして認められていませんでした。しかしc++14以降では、`void operator delete(void*, std::size_t)`が推奨されるみたいです。私の手元のコンパイラ(gcc5.2)では、C++14のオプション付きで`void operator delete(void*)`しか定義しなかった場合以下の警告が出てしまいました。

>main.cpp:8:6: warning: the program should also define `void operator delete(void*, long unsigned int)` [-Wsized-deallocation]
\void operator delete(void* ptr) noexcept

また、`void operator delete(void*)`と`void operator delete(void*, std::size_t)`の両方が定義された場合、後者が優先されるようです。
[ideone C++11版](http://ideone.com/F7QBbv)
[ideone C++14版](http://ideone.com/8PSK5a)

対応関係はどうしたと言われそうですが、規格にそうあるのだからしょうがありません。現状だと、グローバル空間に`operator new(std::size_t, std::size_t)`は定義しない方がよさそうですね。

# Create/Destroy objects

```cpp
// usual new/delete
void* operator new[](std::size_t) ;
void operator delete[](void*) noexcept ;
void operator delete[](void*, std::size_t) noexcept ;

// placement new/delete
void* operator new[](std::size_t, Args...) ;
void operator delete[](void*, Args...) noexcept ;
```

この演算子の存在を忘れていた方、ご安心ください。new[]/delete[]に関しては記事の名目上作っただけであり、注意点も全てnew/deleteと同じです。new/deleteをオーバーロードする際は、new[]/delete[]もオーバーロードするようにしてください。

# 終わりに
当初考えていたよりも複雑な記事になってしまいました。今更ではありますが、特にグローバルなnew/deleteに関してはオーバーロードをなるべく控え、allocatorクラスを作成することを強く推奨いたします。

さて、長くなりましたが、以上でnew/delete演算子、new[]/delete[]演算子のオーバーロードについての解説を終わりたいと思います。ここまで読んでくださった方がいらっしゃったらお礼を申し上げたいと思います。
また今回この記事を書くにあたり、私自身規格を参照しながら詳細な仕様を調べました。その為、規格の解釈が間違っている可能性があることをご了承お願いいたします。同時に、誤りなど気付いた点がございましたらコメントにお願いします。
それでは、長々と失礼いたしました。改めて、読んでいただきありがとうございました。