C++ - Same_as コンセプトが型の等価性を 2 回チェックするのはなぜですか?

https://en.cppreference.com/w/cpp/concepts/same_as で Same_as コンセプトの実装の可能性を調べていると、何か奇妙なことが起こっていることに気づきました。

namespace detail {
    template< class T, class U >
    concept SameHelper = std::is_same_v<T, U>;
}

template< class T, class U >
concept same_as = detail::SameHelper<T, U> && detail::SameHelper<U, T>;

最初の質問は、なぜ SameHelper の概念が必要なのかということです。 2 つ目は、なぜ Same_as は T が U と同じか、U が T と同じかどうかをチェックするのかということです。冗長ではないでしょうか?

SameHelper<T, U> という理由だけで、 true である可能性は、SameHelper を意味するわけではありません。そうかもしれません。

2019 年 10 月 22 日 17:05

2

重要なのは、a が b に等しい場合、b は a に等しいということですよね?

2019 年 10 月 22 日 17:06

1

@user7769147 はい、これがその関係を定義しています。

2019 年 10 月 22 日 17:12

5

うーん、std::is_same のドキュメントには、「可換性が満たされる、つまり任意の 2 つの型 T と U について、is_same の場合およびその場合に限り、is_same::value == true」とさえ書かれています。 ::値 == true。」これは、この二重チェックが必要ないことを意味します

2019 年 10 月 22 日 17:13

2

いいえ、これは間違っています。std::is_same は次のように述べています: 条件が成立する場合に限り、2 つの型は可換です。必ずしもそうとは限りません。しかし、2 つの非可換型の例は見つかりませんでした。

2019 年 10 月 22 日 17:36

興味深い質問です。最近、コンセプトに関する Andrew Sutton の講演を視聴しましたが、Q&A セッションで誰かが次の質問をしました (タイムスタンプは次のリンクにあります)。 CppCon 2018: アンドリュー サットン「60 年の概念: 知っておくべきことはすべて、知らないことは何もない」

質問は要約すると次のようになります。もし私にコンセプトがあるとしたら、A&&と言うのはB＆amp;＆amp; C、別の人は C &&; と言います。 B＆amp;＆amp; A、それらは同等でしょうか？ Andrew は「はい」と答えましたが、コンパイラには、概念をアトミック論理命題 (アンドリューの言葉ではアトミック制約) に分解し、それらが同等かどうかをチェックする内部メソッド (ユーザーには透過的) がいくつかあるという事実を指摘しました。

次に、cppreference が std::same_as について述べていることを見てみましょう。

std::same_as std::same_as を包含します。その逆も同様です。

これは基本的に「if-and-only-if」です。関係：それらはお互いを暗示します。 (論理的等価性)

私の推測では、ここでのアトミック制約は std::is_same_v<T, U> であると考えられます。コンパイラーが std::is_same_v を処理する方法により、コンパイラーは std::is_same_v<T, U& と考えてしまう可能性があります。gt;および std::is_same_v<U, T> 2 つの異なる制約として (これらは異なるエンティティです!)。したがって、そのうちの 1 つだけを使用して std::same_as を実装すると、次のようになります。

template< class T, class U >
concept same_as = detail::SameHelper<T, U>;

次に、std::same_as を実行します。および std::same_as と「爆発」するだろう異なるアトミック制約に依存し、等価ではなくなります。

では、コンパイラはなぜそれを気にするのでしょうか?

次の例を考えてみましょう。

#include <type_traits>
#include <iostream>
#include <concepts>

template< class T, class U >
concept SameHelper = std::is_same_v<T, U>;

template< class T, class U >
concept my_same_as = SameHelper<T, U>;

template< class T, class U> requires my_same_as<U, T>
void foo(T a, U b) {
    std::cout << "Not integral" << std::endl;
}

template< class T, class U> requires (my_same_as<T, U> && std::integral<T>)
void foo(T a, U b) {
    std::cout << "Integral" << std::endl;
}

int main() {
    foo(1, 2);
    return 0;
}

理想的には、my_same_as<T、U> && std::integral; my_same_as を包含します。したがって、コンパイラは 2 番目のテンプレート特殊化を選択する必要があります。ただし、そうではありません: コンパイラはエラー error: オーバーロードされた 'foo(int, int)' の呼び出しがあいまいです。

この背後にある理由は、my_same_as<U, T> がそして私は<T、U>と同じです。お互いを包摂せず、 と同じです&& std::integral;そして私は<U, T>と同じです。 （包摂関係の下で部分的に順序付けられた制約セットに関して）比類のないものになります。

ただし、交換した場合

template< class T, class U >
concept my_same_as = SameHelper<T, U>;

付き

template< class T, class U >
concept my_same_as = SameHelper<T, U> && SameHelper<U, T>;

コードがコンパイルされます。

2019 年 10 月 22 日 19:47 に回答

ph3rin

4,596

1

金バッジ 1 個

19 個

銀バッジ 19 個

42 個

銅バッジ 42 個

7

と同じ と同じです。異なる原子制約を使用することもできますが、結果は同じになります。なぜコンパイラーは、論理的な観点からは同じである 2 つの異なるアトミック制約として Same_as を定義することをそれほど気にするのでしょうか?

2019 年 11 月 4 日 15:03

5

コンパイラは次の点を考慮する必要があります。r 任意の 2 つの式は制約包含に関しては別個のものとして扱われますが、明白な方法でそれらに対する引数を考慮することができます。したがって、両方の方向が必要なだけでなく (制約を比較するときに名前の順序が問題にならないように)、SameHelper も必要です。これにより、is_same_v の 2 つの使用が同じ式から派生します。

2019 年 11 月 4 日 20:07

2

概念の平等に関する従来の通念は間違っているようです。 is_same であるテンプレートとは異なります。 is_same と同一であり、2 つのアトミック const雨は、同じ式から形成されない限り、同一とはみなされません。したがって、両方が必要になります。

2019 年 11 月 5 日 13:08

are_same_as についてはどうですか?テンプレート<タイプ名 T、タイプ名 U0、タイプ名... Un>コンセプト are_same_as = SameAs && (同じ && ...);場合によっては失敗するでしょう。たとえば、are_same_as のようになります。 are_same_as<T, int, U> と同等になります。ただし、<U, T, int> と同じではありません

2019 年 11 月 5 日 16:27

さらに、概念はそれ自体を再帰的に参照できないため、このテンプレートは となります。コンセプト are_same_as = SameAs && (同じ && ...) && (sizeof...(Un) == 0 || are_same_as);許可されません

2019 年 11 月 5 日 16:36

[concept.same] は、LWG 問題 3182 の一部として変更されました (コンセプト Same の名前が is_same a に変更される前)s per P1754R1) [私の強調]:

ディスカッション:

18.4.2 の同じコンセプトの仕様 [concept.same]:

template<class T, class U>
  concept Same = is_same_v<T, U>;

template<class T, class U>
  concept same-impl = // exposition only
    is_same_v<T, U>;

template<class T, class U>
  concept Same = is_same_v<T, U>same-impl<T, U> && same-impl<U, T>;

#include <iostream>

template <typename T> concept C1 = true;    
template <typename T> concept C2 = true; 

template <typename T> requires C1<T> && C2<T> // #1
void f() { std::cout << "C1 && C2"; }

template <typename T> requires C1<T>          // #2
void f() { std::cout << "C1"; }

// old impl.; was named Same back then
template<typename T, typename U>
concept same_as = is_same_v<T, U>;

// A and B are concepts
concept same_as = A ^ B

template< class T, class U >
concept same_as = std::is_same_v<T, U> && std::is_same_v<U, T>