C++における関数の受け渡しについて

Question

背景

C++において関数（関数オブジェクト）を渡して動作をカスタマイズするという設計はよくあると思います。
実際、標準ライブラリ<algorithm>の関数群はそうなっています。
例えば、次のようにソートの第3引数に関数オブジェクトを渡すことはよくあるかと思います。

#include <vector>
#include <algorithm>
#include <functional>

int
main() {
  std::vector v{ 1, 2, 3, 5, 9, 4 };
  std::sort(begin(v), end(v), std::greater<int>{});
  // v = [ 9, 5, 4, 3, 2, 1 ]
}

問題提起

greater<int>{}のようにいちいちテンプレートの<>を書くのがかっこ悪いです。
なんなら{}も邪魔くさいです。
greaterと書けると嬉しいです。

質問

何らかのfooという作用があるとします。
fooはジェネリックなものとします。
fooを関数としても関数オブジェクトとしても使いやすくするためにはどういう設計をすれば良いのでしょうか？
なにか良い方法が無いものでしょうか？
やはりプリプロセッサマクロなのでしょうか？？？

yohhoyさんの回答を受けて（追記）

次のように関数オブジェクトを定義し、その中でオーバーロードを行う。
その上で、あらかじめinline変数として関数オブジェクトのインスタンスを作っておく。

オーバーロードが自然にできるし、関数としても関数オブジェクトとしても使い勝手がいい。

これは、range-v3というC++20に提案されているライブラリの実験的実装でも使われている方法であった。
例えばこのソースにみることができる。
もしかしたらこれが現状（C++17）におけるベストプラクティスなのかもしれないですね。

struct foo_t {
  // generic version
  template <class T>
  T operator()(T a) { return a + a; }
  // specialized version
  int operator()(int a) { return a * 10; }
};

inline constexpr auto foo = foo_t{};

試したこと

関数テンプレート

この方法は関数テンプレートを渡す際にどの実態化なのかを示すためテンプレートパラメータが必須になります。

template < class T >
T foo(T a) { return a + a; }

std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo<int> ); // bad

関数オブジェクト

transparentな関数オブジェクトを使う方法。
コンストラクトしないと使えないが、テンプレートじゃないだけ多少マシ。

struct foo {
  template < class T >
  T operator()(T a) { return a + a; }
};
std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo{} );

ただ、普通の関数としてはダメ。

foo{}(42); // bad
// ^

ラムダ式のラッパー

よくある方法として、transparentなラムダ式で関数テンプレートの呼び出しをラップするというものです。
欠点は、記述量が多すぎることです。
これを書くのはとてもとても面倒なことです。
あと、std::forward<decltype(a)>(a)がわからないとよく言われるので地味に困ります。

// シンプル
std::transform( begin(v), end(v), std::back_inserter(result), [](auto a){ return foo(a); } );

// 完全転送
std::transform( begin(v), end(v), std::back_inserter(result),
                [](auto&& a){ return foo(std::forward<decltype(a)>(a)); } );

Globalラムダ式

関数オブジェクトのインスタンスを予め作っておくというアイデアですが、クラスを書くのも面倒なのでラムダ式を書きます。
関数テンプレートを書く代わりにラムダ式を書くことにします。

inline auto foo = [](auto a){ return a + a; };

std::transform( begin(v), end(v), std::back_inserter(result), foo ); // nice!

副次効果として、C++17からラムダ式のoperator()がconstexpr指定されるのでこれいいなぁと思ったのですが、
ラムダ式にしてしまうとオーバーロードしたくなっても簡単にはできないのです。

inline auto foo = [](auto a){ return a + a; };
inline auto foo = [](int a){ return a + 1; }; // redefinition!

Answer 1

Globalラムダ式
ラムダ式にしてしまうとオーバーロードしたくなっても簡単にはできないのです。

"簡単"かと言われるとかなり微妙ですが、C++17の範囲内 かつ Globalラムダ式 でもオーバーロード相当の振る舞いを記述可能です。

template<class... Ts> struct overloaded : Ts...
  { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

inline constexpr auto foo = overloaded{
  // generic version
  [](auto a){ return a + a; },
  // specialized version
  [](int a){ return a * 10; },
};


// 関数として利用
int r1 = foo(42);
double r2 = foo(3.14);

// 関数オブジェクトとして利用
std::transform(begin(v), end(v), std::back_inserter(result), foo);

Demo: https://wandbox.org/permlink/xIEdBjy2Jbkyuwpf

（あまりに技巧的な記述では可読性・保守性を損ねますから、チームメンバのスキル次第なところはあるでしょうね）

---

ただ、普通の関数としてはダメ。

結合優先度の都合で、明示的な括弧が必要ですね（foo{}(42) → (foo{})(42)）。マクロを使え下記のような記述もできます。絶対におススメしませんけど。

struct foo {
  // generic version
  template <class T>
  T operator()(T a) { return a + a; }
  // specialized version
  int operator()(int a) { return a * 10; }
};

#define foo (foo{})

Demo: https://wandbox.org/permlink/Fq280pkwKeAPJV4c

Comments

[mitama_rs]

ありがとうございます。
たしかに、overload setとしてラムダ式をあらかじめ定義しておくという方法がありましたね。

自分のライブラリとして完結できるときに利用できそうです。
やり過ぎ感が否めないですが。

[yohhoy]

後から気づいたのですが、「#define foo (foo{})」ではなく「inline constexpr auto foo = foo_t{};」と書けば、プリプロセッサにたよらずとも前者overloaded相当を実現できますね。

追記：上記コードを実際書いてみると、operator()()メンバ関数側にconst修飾が必要でした。どちらが望ましいかは好みでしょうね...

[mitama_rs]

もしかしたらラムダ式よりいいかもしれないという気がしてきました。

Answer 2

greater<int>{}のようにいちいちテンプレートの<>を書くのがかっこ悪いです。

なんなら{}も邪魔くさいです。
greaterと書けると嬉しいです。

typedef してそれぞれ別名つければいいんじゃないかと。

Comments

[kendji]

あなた仕事が早そうね。