関数を引数とした関数テンプレートが理解できない

Question

発生している問題

次のコードで，test1の場合はエラーは出ないのですが，test2にすると，エラーが出ます。いずれの組合せでも動作すると理解していたのですが，ちょっと理解できなくりました。どなたか教えてください。

該当のソースコード

namespace test1{

int funcA(int t, std::function<int(int)>f){
    return f(t);
}
int funcB(int t, int(*f)(int)){
    return f(t);
}
int funcC(int t, int f(int) ){
    return f(t);
}
}

namespace test2{

template<typename T>
T funcA(T t, std::function<T(T)>f){
    return f(t);
}
template<typename T>
T funcB(T t, T(*f)(T)){
    return f(t);
}
template<typename T>
T funcC(T t, T f ){
    return f(t);
}
}

int a(int x){return x;};
auto b=[](int x){return x;};


int main() {
    using namespace std;
    
    using namespace  test1;
    
    cout << funcA(10,a)<<'\n';// test2にするとエラー
    cout << funcB(10,a)<<'\n';
    cout << funcC(10,a)<<'\n';// test2にするとエラー
    
    cout << funcA(10,b)<<'\n';// test2にするとエラー
    cout << funcB(10,b)<<'\n';// test2にするとエラー
    cout << funcC(10,b)<<'\n';// test2にするとエラー
    
    
    return 0;
}

試したこと

さらにtest3で試すと funcA とa b, funcBとbの組合せでエラーになって,
test2と状況が異なります。

namespace test3{
template<typename T,typename C>
T funcA(T t, std::function<C(C)>f){
    return f(t);
}
template<typename T,typename C>
T funcB(T t, C(*f)(C)){
    return f(t);
}
template<typename T,typename C>
T funcC(T t, C f ){
    return f(t);
}
}

補足情報（FW/ツールのバージョンなど）

Answer 1

int a(int x){return x;};
auto b=[](int x){return x;};

まず前提を整理しておきます：

• aは通常の**関数(function)**です。
• bはラムダ式(lambda expression)から生成される**クロージャオブジェクト(closure object)**です。

---

名前空間test1の関数引数では型情報が確定していますから、a,bいずれでも適切な型変換が暗黙に行われます。

• test1::funcAの第2引数はstd::function<int(int)>型を要求します。
• test1::funcBの第2引数は関数ポインタint(*)(int)型を要求します。
• test1::funcCの第2引数は関数int(int)型を要求するように見えますが、C++のルールにより「関数ポインタint(*)(int)型」に読み替えられます。

つまりtest1::funcBとtest1::funcCは同一シグネチャを持つ関数です。

static_assert(
  std::is_same<decltype(test1::funcB),
               decltype(test1::funcC)>::value);

• 関数aはstd::function<int(int)>型へと変換可能です。
• 関数aは関数ポインタint(*)(int)型へと変換可能です。
• クロージャオブジェクトbはstd::function<int(int)>型へと変換可能です。
• ラムダ式[](int x){return x;}は何もキャプチャしないため、クロージャオブジェクトbは関数ポインタint(*)(int)型へと変換可能です。

---

名前空間test2の関数テンプレート引数では型情報が確定していません。つまり実引数a,bからテンプレートパラメータ型推定できるかが論点となります。
残念ながら、プログラミング言語C++の型推論はあなたが期待するほど柔軟ではないというのが大雑把な回答です。

また、test2::funcCの第2引数はTではなくT f(T)を意図していたのではないでしょうか？

template<typename T>
T funcC(T t, T f){  // ←ココ
    return f(t);
}

下記コード記述を行えば名前空間test2でも全てコンパイル通すこともできます。
https://wandbox.org/permlink/3CqrQylmIetOvP79

cout << funcA(10, {a}) << '\n'; // {}によりstd::functionの推論ガイドを利用
cout << funcB(10, a) << '\n';   // (無加工)
cout << funcC(10, a) << '\n';   // (無加工)

cout << funcA(10, {b}) << '\n'; // {}によりstd::functionの推論ガイドを利用
cout << funcB(10, +b) << '\n';  // +により関数ポインタ型へ強制変換
cout << funcC(10, +b) << '\n';  // +により関数ポインタ型へ強制変換

（参考記事：ラムダ式と単項+演算子 - 地面を見下ろす少年の足蹴にされる私）

Comments

[jbe00214]

早速ありがとうございます。{}と＋での強制変換ですね。やってみました。{}は初期化ということですが，＋をつけるとなぜ強制変換されるのでしょうか。なお，test2::funcCの第2引数はT f　で試したものです。ビャーネストラウストラップ著プログラミング言語C++第４版(§3.4.3)の以下の例示コードを参考にしました。
template<typename C, typename P>
int count(const C& c, P pred){
.....
if( pred(x) )
....
}
というコードが出て来ます。名前空間test2の T f を, test1では int f のように関数を表現できなかったので，int f(int)としました。なのでtest2は　T f での検討でよいのです。

[yohhoy]

> ＋をつけるとなぜ強制変換されるのでしょうか
回答末尾にある参考記事を参照ください。

> なのでtest2は　T f での検討でよいのです。
そのような意図であれば、test3で試したように2種類のテンプレートパラメータを利用すべきです。1つのテンプレートパラメータは1種類の型に推論されるため、test2::funcCではあなたの意図を表現できていません。

template<typename T> T funcC(T t, T f)
と
template<typename T, typename C> T funcC(T t, C f)
は全く意味合いが異なります。

[jbe00214]

了解です。Tはintに推論するけど，Cは int ではなく，int (*)(int)に推論するわけですね。謎が解けました。

Answer 2

端的に言えば、 C++ の型推論ルールでは推論できないからです。

テンプレートの実引数推定においては原則として暗黙の型変換は考慮されません。 この場合には a の型 int (*)(int) は std::function<T(T)> にマッチしないのでここから T を推論することはできません。

また、推論はそれぞれの仮引数ごとに行われた上で最終的に突き合わせされる (推論が一致しなければマッチしなかったことになる) ので仮引数 t において T が int であることが推論できても std::function<T(T)> の T が推論できなければ全体としてはマッチするものがなかったことになります。

Comments

[jbe00214]

ありがとうございます。まだあやふやなのですが，名前空間test2::funcCをラムダ式bからの型推論ができなかったのに，test3::funcCでは推論できるようになるのはなぜなのか，お分かりになりますか。

[jbe00214]

謎が解けました。test3では,Tはint に推論し，Cはint(*)(int)に推論されるからですね。ありがとうございました。