HN 日本語サマリー

← 一覧へ戻る
プログラミング

std::functionとcopyable_functionの相互変換

Interconverting std::function with copyable_function (quuxplusone.github.io)

6 pointsby jandeboevrie0 コメント

要約

C++26で導入されたstd::copyable_functionは、std::functionの設計上の問題を解決する新しい型です。しかし、std::functionとstd::copyable_functionの間で相互変換を行う際に、実装によっては意図しないヒープ割り当てが発生し、パフォーマンスの低下やメモリリークのような状態を引き起こす可能性があります。この問題は、特に異なるSTL実装間での相互運用時に顕著になるため、注意が必要です。

全文翻訳

std::function と copyable_function の相互変換

C++11 では、型消去された呼び出し可能オブジェクトコンテナとして std::function が導入されました。function はいくつかの点で設計が悪かったのです。ほとんど使われない"go fish" API は全てのユーザーを肥大化させます。制御対象オブジェクトの operator() がミューテートする場合でも operator() const を広告します。前置条件違反であるべきものを例外を投げて処理するため、これもまた全てのユーザーを肥大化させ、operator() が noexcept になり得ないことを意味します。そこで C++26 は、std::copyable_function を追加してこれらの問題を修正しました。(ただし、function のいくつかの最適でない設計上の決定は引き継がれています。copyable_function<bool()> は copyable_function<void()> への暗黙変換可能であり、bool への文脈変換可能であり、nullptr から代入可能です。)

P2548 “copyable_function” (Hava 2023) には、実装者向けの以下のガイダンスが含まれています。

copyable_function のインスタンス化から互換性のある move_only_function のインスタンス化への変換時に、追加のメモリ割り当てを行わないことが推奨されますが、これは品質実装に委ねられています。

逆方向の変換、つまり move_only_function から copyable_function への変換は許可されないことに注意してください。copyable_function はコピー可能な呼び出し可能オブジェクトのみを保持でき、move_only_function はコピー可能ではありません。

しかし、copyable_function は std::function と相互変換可能です — 両方向とも!これらの型消去ラッパーは、コピー可能で呼び出し可能なものであれば何からでも構築でき、それ自体がコピー可能で呼び出し可能です。したがって、以下のようなことができます。

std::function<int()> f = []{ return 5; };
std::copyable_function<int() const> cf = std::move(f);
std::function<int()> g = std::move(cf);

f から cf へのムーブが以下のように実装されることを期待するでしょう。

[画像: std::function から std::copyable_function へのムーブ操作の図]

そして、cf から g へのムーブも同様です。

[画像: std::copyable_function から std::function へのムーブ操作の図]

しかし、copyable_function が function を知らない場合、f を単なるコピー可能で呼び出し可能な型の rvalue と同じように扱うかもしれません。つまり、ヒープに f のコピーを移動させて所有させるかもしれません。

[画像: std::function から std::copyable_function へのムーブ操作の図(ヒープへのコピー)]

そして、g へのムーブも同様です。function は cf をコピー可能で呼び出し可能な型の rvalue と同じように扱い、ヒープに cf のコピーを移動させて所有させるかもしれません。

[画像: std::copyable_function から std::function へのムーブ操作の図(ヒープへのコピー)]

このムーブ操作は依然として比較的パフォーマンスが良いです — 各構築で O(1) の作業しか行いません — しかし、(n) 回のこのような構築のシーケンスの後では、長さ (n) の呼び出し可能オブジェクトの「連結リスト」のようなものが生成されます。g を呼び出すたびに、g の operator() は、その制御下にある copyable_function の operator() を呼び出し、それが制御下にある function の operator() を呼び出し、それが制御下にあるラムダ(これらの図の緑色のオブジェクト)の operator() を呼び出します。


この記事の執筆時点(2026年7月)では、Big Three STLベンダーのうち、libstdc++のみが C++26 の copyable_function を実装しています。そして、執筆時点では、彼らは上記で図示された「悪い」挙動を実装しています。

以下のような、ややこしいシナリオを考えてみましょう。ある種の「ハンドラコールバック」が std::function に格納されているとします。ユーザー入力に基づいて、そのハンドラを変更するかどうかを定期的に検討します。例えば、

using Handler = std::function<bool(char)>;

Handler update(Handler h, bool negate) {
  if (negate) {
    h = [f = std::move(h)](char c) { return !f(c); };
  }
  return h;
}

~~~~ 
Handler h = original_handler;
while (~~~~) {
  ~~~~ 
  h = update(std::move(h), (input == '!'));
}

h が update にムーブされ、再びムーブアウトされることに注目してください(暗黙のムーブのおかげで)。これは std::function のムーブコンストラクタを使用しており、ほとんどのムーブコンストラクタと同様に、高速でメモリを割り当てません。

しかし、同僚がこのコードの一部を C++26 に更新し、std::function の代わりに std::copyable_function を使用することを合理的に選択できるようになったと仮定します。¹ 同僚がコードベース全体を copyable_function を一貫して使用するように更新した場合、問題はありません。しかし、彼が自分の部分だけを更新し、新しい copyable_function ベースのコードが他の全員の古い function ベースのコードと相互運用する必要がある場合はどうでしょうか?その場合、以下のようになります。

using OldHandler = std::function<bool(char)>;
using NewHandler = std::copyable_function<bool(char)>;

OldHandler update(OldHandler h, bool negate);
  // pre-C++26 コールバックのために変更なし

~~~~ 
NewHandler h = original_handler;
while (~~~~) {
  ~~~~ 
  h = update(std::move(h), (input == '!'));
}

これは「連結リスト」のシナリオを引き起こし、h の呼び出し演算子は、negate が false の場合でも、update を往復するたびに遅くなっていきます!

この小さなベンチマークを作成しました(Godbolt)。

#include <chrono>
#include <cstdio>
#include <functional>

size_t now() {
  static const auto epoch = std::chrono::high_resolution_clock::now();
  auto tp = std::chrono::high_resolution_clock::now();
  return std::chrono::duration_cast<std::chrono::microseconds>(tp - epoch).count();
}

void print_elapsed_time(int i, size_t call_started) {
  printf("Invocation on the %dth iteration took %zu us\n", i, now() - call_started);
}

using OldHandler = std::function<void(int, size_t)>;
using NewHandler = std::copyable_function<void(int, size_t) const>;

OldHandler update(OldHandler h, bool negate) {
  if (negate) { /* do something here, but for this example we don't care what */ }
  return h;
}

int main() {
  NewHandler handler = print_elapsed_time;
  for (int i = 0; i < 160'000; ++i) {
    handler = update(std::move(handler), false);
    if (i % 10'000 == 0) {
      handler(i, now());
    }
  }
}

このプログラムを libstdc++(GCC 16 時点)で実行すると、以下のような出力が得られます。

Invocation on the 0th iteration took 0 us
Invocation on the 10000th iteration took 180 us
Invocation on the 20000th iteration took 296 us
Invocation on the 30000th iteration took 365 us
[...]
Invocation on the 130000th iteration took 1057 us
Invocation on the 140000th iteration took 1108 us
Invocation on the 150000th iteration took 1202 us

handler(i, now()) を呼び出すたびに、handler にぶら下がっている「呼び出し可能オブジェクトの連結リスト」は以前より10,000要素長くなり、ポインタをたどるのに約100マイクロ秒長くなります。もちろん、必要以上に数キロバイトのメモリを保持し続けます。これは「論理的なメモリリーク」です。そのメモリは技術的にはまだアクセス可能で、h のデストラクタによって解放されますが、h が生きている限り、プログラムの「論理的」状態に変化がないにもかかわらず、RAM使用量は時間とともに増加し続けます。


2026年7月現在、Microsoft STL は move_only_function と function をこのような「論理的なメモリリーク」なしで相互運用させています。そして、彼らが copyable_function を実装すれば、それも同様に回避されると確信しています。libstdc++ の実装は将来改善されるかもしれません。一方、libc++ はまだ move_only_function も copyable_function も実装していないため、この問題について考える時間はまだ十分にあります。


ちなみに、型消去型を自分で書く際に、より単純なバージョンのこの落とし穴に注意してください。int を保持する Printable をコピーするときに、int を保持する Printable ではなく、Printable を保持する Printable を取得しないようにしてください。Printable&、const Printable&、Printable&&、および const Printable&& から構築する場合でも、それが依然として有効であることを確認するために単体テストを書いてください。この問題を解決することは、STL のように複数の型消去型がうまく連携する必要がある場合、より困難になります。可能であれば、そのような状況に陥らないようにしてください。しかし、そうしなければならない場合は、この落とし穴に注意してください。


脚注: C++26 で function を copyable_function に放棄すべきでしょうか?はい、と言う人もいるでしょう。個人的には、両方とも放棄して、自分で型消去呼び出し可能オブジェクトを書くべきだと答えます。100行もかかりません!

完全に新規の C++26 コードであれば、function より copyable_function を推奨します(ベンダーが実装したら)。しかし、既存のコードベースで両方の型を混在させることは推奨しません。どちらか一方を選んでそれに固執し、コードベース全体を一度に更新できる時点を目指して作業するでしょう。