decltypeのSFINAEについて

Question

template < class T>
auto f(T&& range) -> decltype(begin(range), end(range), true)
{
	for (const auto& r : range) { cout << r << endl; }

	return true;
}

int main() {
	vector<string> vec{ "test", "items", "range" };

	f(vec);

}

以上のコードの挙動を説明すると、
decltypeでまずbegin、endが評価されたあとtrueが評価され戻り値はbool、begin、endが失敗した場合実体化されない、で正しいでしょうか。
参考: https://qiita.com/_EnumHack/items/92e6e135174f1f781dbb

Answer 1

こんにちは。

その通りです。

SFINAEって何か特殊な雰囲気が漂いますが、要するにオーバーロードと考え方は同じです。
void foo(int x); と void foo(char const* x); がある時、foo("abc");で呼び出すと前者は本来エラーです。ですが、他にマッチするオーバーロードがあればエラーにせず単に採用しないだけです。SFINAEとよく似た動作ですね。

試しに後者を定義しなければアンマッチ・エラーになります。SFINAEを使う場合も同様でマッチするテンプレートがなければアンマッチ・エラーとなります。

#include <string>
#include <vector>
#include <iostream>
using namespace std;

template < class T>
auto f(T&& range) -> decltype(begin(range), end(range), true)
{
    for (const auto& r : range) { cout << r << endl; }

    return true;
}
void foo(int) {}
//void foo(char const*) {}

int main() {
    vector<string> vec{ "test", "items", "range" };

    f(vec);

    f(123);
    foo("abc");
}

wandbox

Comments

[__ook]

回答ありがとうございます。
ジェネリックな関数テンプレートと非テンプレートのオーバーロードを共存させてはいけないそうですが、なぜでしょうか…
参考：https://github.com/LoliGothick/cppbook/blob/master/chapter5.re

[Chironian]

そのリンク先は長すぎて全部読む気にはなれないのですが、「ジェネリックな関数テンプレートと非テンプレートのオーバーロードを共存」の意味は理解できませんでした。
なお、関数テンプレートと同じ名前の通常関数を共存させることは、普通に推奨されている使い方です。
https://teratail.com/questions/97314

[__ook]

良いのですね…かなり理解できました。
むしろ明示的特殊化し特定の型に絞るのであれば単にオーバーロードすべきなのですね…ありがとうございました。

[__ook]

すみません、だめです、理解した気でいたのですが、
template <typename T> void foo(T);
template <typename T> void foo(T*); // overload of foo(T)
template <> void foo<int>(int*); // specialisation of foo(T*)

foo(new int); // calls foo<int>(int*);

でなぜintの特殊化が呼ばれるのかがわかりません。
オーバーロードの解決を優先するのであれば
template <typename T> void foo(T*);
が呼ばれるのでは…？
なぜ特殊化で解決されるのでしょうか。

[Chironian]

template <typename T> void foo(T*); は、通常関数によるオーバーロードではないです。
よりマッチする範囲が狭い方が優先して呼ばれることが多いので、明示的特殊化の方が呼ばれます。
この辺りは、いなむ先生の https://qiita.com/_EnumHack/items/cd904d383588ddb2189f に詳しい解説があります。

通常関数によるオーバーロードする場合は、void foo(int*);を定義して下さい。（テンプレートではないもの）

[__ook]

なるほど…読みます…ありがとうございました。

[__ook]

> よりマッチする範囲が狭い方が優先して呼ばれることが多い
そうなると常にtemplate <> void foo<int>(int*); // specialisation of foo(T*)
が呼ばれるような気がしますが…
bとcを入れ替えるとbが呼ばれるのですね…？
>おおまかに次のようになる
1. f(int),f(int const),f(int&)等、intがcvr修飾されたもの
2. f<int>(int)などの特殊化されたテンプレート
3. f(T),などtemplate
4. f(double),f(long)など型変換可能な引数を持つもの
5. f(...)可変長引数
らしいのでやはりtemplate <> void foo<int>(int*); // specialisation of foo(T*)が呼ばれるような…
難しいです、何度も質問してすみません。

[Chironian]

> foo(new int); // calls foo<int>(int*);
これは、template <> void foo<int>(int*)が呼ばれているという意味ではないのですか？
何が疑問なのか、良く分からないです。

> bとcを入れ替えるとbが呼ばれるのですね…？
bとcは何を指しています？

[__ook]

すみません、bとcはいただいた記事のyohhoyさんの提示コードを指していました…

template <typename T> void foo(T);
template <typename T> void foo(T*);
template <> void foo<int>(int*);
だとint*の特殊化が呼ばれ
template <typename T> void foo(T);
template <> void foo<int>(int*);
template <typename T> void foo(T*);
と順序を逆にすると
template <typename T> void foo(T*);
が呼ばれる、というところが理解できていません。
> よりマッチする範囲が狭い方が優先して呼ばれることが多い
であれば常にint*が呼ばれるのではないか、と思いました。
あくまで多い、ということでしょうか。

[Chironian]

プライマリー・テンプレートのオーバーロードを解決した後で、明示的特殊化にマッチするかどうか判定されます。
(a)(b)(c)と記述すると、(c)は(b)の明示的特殊化となり、f(int*)は(b)のプライマリー・テンプレートにマッチした後、より範囲の狭い明示的特殊化の(c)が選択されます。
(a)(c)(b)と記述すると、(c)は(a)の明示的特殊化となり、f(int*)は(b)のプライマリー・テンプレートにマッチしますが、(b)に明示的特殊化がないので(b)が選択されます。
このように明示的特殊化は予測しづらい振る舞いをするので、通常関数のオーバーロードを使ったほうが好ましいです。

ところで、「明示的特殊化」と「完全特殊化」は同じ意味で使われています。

[__ook]

なるほど…理解できました、ありがとうございます。
質問にお付き合いくださったおかげでとても理解が進みました。ありがとうございました。