operator==,!=,<,<-,>,>=,<=> (std::tuple)

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

ユーティリティライブラリ

言語サポート 型のサポート (基本型、RTTI) ライブラリ機能検査マクロ (C++20) プログラムユーティリティ 可変引数関数 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) コルーチンサポート (C++20) 契約サポート (C++26) 三方比較 three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

汎用ユーティリティ 関数オブジェクト ビット操作 (C++20) bitset hash (C++11) 関係演算子 (C++20で非推奨) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= 整数比較関数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) スワップと型操作 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 共通語彙型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::tuple

メンバ関数

tuple::tuple

tuple::operator=

tuple::swap

非メンバ関数

make_tuple

tie

forward_as_tuple

tuple_cat

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20まで)(C++20まで)(C++20まで)(C++20まで)(C++20まで)(C++20)

swap(std::tuple)

get(std::tuple)

ヘルパーコンセプト

tuple-like (C++23)

ヘルパークラス

tuple_size<std::tuple>

tuple_element<std::tuple>

uses_allocator<std::tuple>

basic_common_reference<std::tuple> (C++23)

common_type<std::tuple> (C++23)

formatter<std::tuple> (C++23)

ignore

推論ガイド(C++17)

 

ヘッダ <tuple> で定義
template< class... TTypes, class... UTypes > bool operator==( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(1)	(C++11以降) (C++14以降constexpr)
template< class... TTypes, class... UTypes > bool operator!=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(2)	(C++11以降) (C++14以降constexpr) (C++20まで)
template< class... TTypes, class... UTypes > bool operator<( const std::tuple<TTypes...>& lhs,                 const std::tuple<UTypes...>& rhs );	(3)	(C++11以降) (C++14以降constexpr) (C++20まで)
template< class... TTypes, class... UTypes > bool operator<=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(4)	(C++11以降) (C++14以降constexpr) (C++20まで)
template< class... TTypes, class... UTypes > bool operator>( const std::tuple<TTypes...>& lhs,                 const std::tuple<UTypes...>& rhs );	(5)	(C++11以降) (C++14以降constexpr) (C++20まで)
template< class... TTypes, class... UTypes > bool operator>=( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(6)	(C++11以降) (C++14以降constexpr) (C++20まで)
template< class... TTypes, class... UTypes > constexpr std::common_comparison_category_t<     synth-three-way-result<TTypes, Elems>...>     operator<=>( const std::tuple<TTypes...>& lhs,                  const std::tuple<UTypes...>& rhs );	(7)	(C++20以降)
template< class... TTypes, tuple-like UTuple > constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );	(8)	(C++23から)
template< class... TTypes, tuple-like UTuple > constexpr std::common_comparison_category_t<     synth-three-way-result<TTypes, /* Elems */>...>     operator<=>( const tuple<TTypes...>& lhs, const UTuple& rhs );	(9)	(C++23から)

1,2) タプル lhs の各要素と、タプル rhs の対応する要素を operator== で比較します。

1) 対応する要素のすべてのペアが等しい場合、true を返します。

2) !(lhs == rhs) を返します。

sizeof...(TTypes) が sizeof...(UTypes) と等しくない場合、または [​0​, sizeof...(Types)) 内の任意の i について std::get<i>(lhs) == std::get<i>(rhs) が有効な式でない場合、プログラムは不正な形式です。 [​0​, sizeof...(Types)) 内の任意の i について、std::get<i>(lhs) == std::get<i>(rhs) の型と値カテゴリが BooleanTestable の要件を満たさない場合、動作は未定義です。	(C++26まで)
このオーバーロードは、sizeof...(TTypes) が sizeof...(UTypes) と等しく、std::get<i>(lhs) == std::get<i>(rhs) が有効な式であり、[​0​, sizeof...(Types)) 内のすべての i について decltype(std::get<i>(lhs) == std::get<i>(rhs)) が boolean-testable をモデル化する場合にのみ、オーバーロード解決に参加します。	(C++26以降)

3-6) lhs と rhs を operator< で辞書式に比較します。つまり、最初の要素を比較し、等価であれば2番目の要素を比較し、等価であれば3番目の要素を比較し、というように続きます。

3) 空のタプルの場合、false を返します。空でないタプルの場合、効果は次と等価です。
if (std::get<0>(lhs) < std::get<0>(rhs)) return true;

if (std::get<0>(rhs) < std::get<0>(lhs)) return false;
if (std::get<1>(lhs) < std::get<1>(rhs)) return true;
if (std::get<1>(rhs) < std::get<1>(lhs)) return false;
...

return std::get<N - 1>(lhs) < std::get<N - 1>(rhs);

4) !(rhs < lhs) を返します。

5) rhs < lhs を返します。

6) !(lhs < rhs) を返します。

sizeof...(TTypes) が sizeof...(UTypes) と等しくない場合、または同等ステートメントに示されている比較式のいずれかが有効な式でない場合、プログラムは不正な形式です。

同等ステートメントに示されている比較式のいずれかの型と値カテゴリが BooleanTestable の要件を満たさない場合、動作は未定義です。

7) lhs と rhs を synth-three-way で辞書式に比較します。つまり、最初の要素を比較し、等価であれば2番目の要素を比較し、等価であれば3番目の要素を比較し、というように続きます。

• 空のタプルの場合、std::strong_ordering::equal を返します。
• 空でないタプルの場合、効果は次と等価です。

if (auto c = synth-three-way(std::get<0>(lhs), std::get<0>(rhs)); c != 0) return c;
if (auto c = synth-three-way(std::get<1>(lhs), std::get<1>(rhs)); c != 0) return c;
...
return synth-three-way(std::get<N - 1>(lhs), std::get<N - 1>(rhs));

8) (1) と同じですが、rhs が tuple-like オブジェクトであり、rhs の要素数は std::tuple_size_v<UTuple> によって決定される点が異なります。このオーバーロードは 引数依存の名前探索 (argument-dependent lookup) を介してのみ見つかります。

9) (7) と同じですが、rhs が tuple-like オブジェクトである点が異なります。/* Elems */ は、[​0​, std::tuple_size_v<UTuple>) 内の各 i に対する型パック std::tuple_element_t<i, UTuple> を昇順に示します。このオーバーロードは 引数依存の名前探索 (argument-dependent lookup) を介してのみ見つかります。

すべての比較演算子は短絡評価されます。比較の結果を決定するために必要な範囲を超えてタプル要素にアクセスすることはありません。

<, <=, >, >=, != 演算子は、それぞれ operator<=> と operator== から合成されます。

(C++20以降)

パラメーター

lhs, rhs

-

比較するタプル

戻り値

1,8) [​0​, sizeof...(Types)) 内のすべての i について std::get<i>(lhs) == std::get<i>(rhs) であれば true、そうでなければ false。2つの空のタプルの場合は true を返します。

2) !(lhs == rhs)

3) lhs の最初の非等価要素が rhs の要素より小さい場合 true、rhs の最初の非等価要素が lhs の要素より小さい場合、または非等価要素がない場合 false。2つの空のタプルの場合、false を返します。

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

7,9) 最初の非等価要素のペアがあればその関係、そうでなければ std::strong_ordering::equal。2つの空のタプルの場合、std::strong_ordering::equal を返します。

備考

関係演算子は、各要素の operator< を用いて定義されます。	(C++20まで)
関係演算子はsynth-three-wayを介して定義されます。synth-three-wayは、可能であればoperator<=>を使用し、そうでなければoperator<を使用します。 特に、要素の型が operator<=> を提供しない場合でも、3方向比較可能な型に暗黙的に変換できる場合は、operator< の代わりにその変換が使用されます。	(C++20以降)

機能テストマクロ	値	規格	機能
__cpp_lib_constrained_equality	202403L	(C++26)	std::tuple の制約付き operator==

例

タプルには operator< が定義されているため、タプルのコンテナはソートできます。

このコードを実行

#include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
 
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
 
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

出力

{ 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

欠陥報告

以下の動作変更を伴う欠陥報告が、以前に公開されたC++標準に遡って適用されました。

DR	適用対象	公開された動作	正しい動作
LWG 2114 (P2167R3)	C++11	ブール演算の型事前条件が不足していました	追加された

関連項目

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)

pair内の値を辞書式比較する (関数テンプレート)