Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::tuple
定義済みヘッダー <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 ) と等しくない場合、または std :: get < i > ( lhs ) == std :: get < i > ( rhs ) が [ ​ 0 ​ , sizeof... ( Types ) ) の範囲内のいずれかの i に対して有効な式でない場合、プログラムは不適格となる。
std :: get < i > ( lhs ) == std :: get < i > ( rhs ) の型と値カテゴリが [ ​ 0 ​ , sizeof... ( Types ) ) の範囲内のいずれかの i に対して BooleanTestable の要件を満たさない場合、動作は未定義となる。
(C++26まで)
このオーバーロードは、 sizeof... ( TTypes ) が sizeof... ( UTypes ) と等しく、 std :: get < i > ( lhs ) == std :: get < i > ( rhs ) が有効な式であり、かつ decltype ( std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ) が [ ​ 0 ​ , sizeof... ( Types ) ) の範囲内のすべての i に対して 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 ) と等しくない場合、またはequivalent-to文で示されている比較式のいずれかが有効な式でない場合、プログラムは不適格となります。
等価性を示すステートメントに含まれる比較式の型と値カテゴリが BooleanTestable 要件を満たさない場合、動作は未定義です。
7) lhs と rhs を synth-three-way によって辞書式順序で比較します。つまり、最初の要素を比較し、それらが等価であれば2番目の要素を比較し、それらも等価であれば3番目の要素を比較する、という処理を繰り返します。

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 > 型のパックを表す。このオーバーロードは 実引数依存探索 によってのみ発見される。

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

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

(C++20以降)

目次

パラメータ

lhs, rhs - 比較対象のタプル

戻り値

1,8) true を返す条件： std :: get < i > ( lhs ) == std :: get < i > ( rhs ) が [ ​ 0 ​ , sizeof... ( Types ) ) の範囲内の全ての i に対して成り立つ場合。それ以外の場合は false を返す。二つの空タプルの場合は true を返す。
2) ! ( lhs == rhs )
3) true が返されるのは、 lhs 内の最初の非等価要素が rhs 内の対応する要素より小さい場合です。 false が返されるのは、 rhs 内の最初の非等価要素が lhs 内の対応する要素より小さい場合、または非等価要素が存在しない場合です。両方のタプルが空の場合、 false を返します。
4) ! ( rhs < lhs )
5) rhs < lhs
6) ! ( lhs < rhs )
7,9) 等価でない最初の要素のペア間の関係（存在する場合）、それ以外の場合は std::strong_ordering::equal 。二つの空のタプルに対しては、 std::strong_ordering::equal を返す。

注記

関係演算子は各要素の operator < を用いて定義される。

(C++20まで)

関係演算子は synth-three-way を用いて定義され、これは可能な場合は operator <=> を、そうでない場合は operator < を使用する。

特に、要素型自体が operator <=> を提供していないが、三方比較可能な型に暗黙変換可能な場合、その変換が operator < の代わりに使用される。

(C++20以降)
機能テスト マクロ 値 標準 機能
__cpp_lib_constrained_equality 202403L (C++26) 制約付き operator == を std::tuple に追加

例

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 論理演算の型事前条件が欠落していた 追加された

関連項目

(C++20で削除) (C++20で削除) (C++20で削除) (C++20で削除) (C++20で削除) (C++20)
pair 内の値を辞書順に比較する
(関数テンプレート)