pair型のような自作struct型でfirst要素の昇順とsecond要素の昇順を使い分けたい

Question

質問

（タイトルのとおりです）

pair型のようなstruct型（例えば今回だとint L, int R）を自作した時に
bool operator<()でソートする方法を定義しておく
①　first要素を優先する昇順ソートを実装
②　second要素を優先する昇順ソートを実装

①first昇順と②second昇順を必要時に使い分けたいのですが

Ｑ１：①と②をstruct内でbool operatorで実装して使い分けることは可能でしょうか？
（Ｑ２：もしその他の方法でもっと良い方法が何かあれば教えて頂きたいです）

質問した経緯や背景

目的は普段使うテンプレとして所持しておきたい
大抵はpair型でなんとかなることが多かったのですが
first,second,昇順,降順,添字を1文字にして簡潔にしたい
ことなどをまとめてテンプレにしておけたらいざ使う時に便利そうだなと思いました

※コードは随分前にネットで調べていいとこ取りしたような記憶があるのですがうろ覚えで
いざ使いたいと思ったらよく分からないので質問させていただきました

試したこと

①と②を単独で実装して片方づつコメントアウトすることで
片方だけの実装は出来ましたが
両立させて使い分ける方法が分かりませんでした

参考にしたコード

C++17

#include <bits/stdc++.h>

using namespace std;

// RHS とは?
// right-hand-side

struct P {
  P(int _L, int _R) : L(_L), R(_R) {}

  // // first優先ソート
  // bool operator<(const P& rhs) const {
  //   // L の値を優先してソートする
  //   return L != rhs.L ? L < rhs.L : R < rhs.R;
  // }

  // secod優先ソート
  bool operator<(const P& rhs) const {
    // R の値を優先してソートする
    return R != rhs.R ? R < rhs.R : L < rhs.L;
  }

  int L;
  int R;
};

void solve() {
  vector<P> p;

  // input
  p.emplace_back(P(8, 2));
  p.emplace_back(P(9, 1));
  p.emplace_back(P(7, 3));
  p.emplace_back(P(5, 5));
  p.emplace_back(P(6, 4));

  sort(p.begin(), p.end(), [](P a, P b) { return a.R < b.R; });
  for (auto e : p) cout << e.L << " " << e.R << "\n";
}

int main() { (solve()); }

// output
/***
9 1
8 2
7 3
6 4
5 5
***/

Answer 1

こんなんでいいのかしら

#include <utility>
#include <algorithm>
#include <vector>
#include <iostream>

struct P {
  P(int _L, int _R) : L(_L), R(_R) {}

  static bool first_order(const P& lhs, const P& rhs) {
    return lhs.L != rhs.L ? lhs.L < rhs.L : lhs.R < rhs.R;
  }

  static bool second_order(const P& lhs, const P& rhs) {
    return lhs.R != rhs.R ? lhs.R < rhs.R : lhs.L < rhs.L;
  }

  int L;
  int R;
};

void solve() {
  using namespace std;
  vector<P> p;

  // input
  p.emplace_back(P(8, 2));
  p.emplace_back(P(9, 1));
  p.emplace_back(P(7, 3));
  p.emplace_back(P(5, 5));
  p.emplace_back(P(6, 4));

  sort(p.begin(), p.end(), P::first_order);
  for (auto e : p) cout << e.L << " " << e.R << "\n";
  cout << endl;
  sort(p.begin(), p.end(), P::second_order);
  for (auto e : p) cout << e.L << " " << e.R << "\n";
}

int main() { (solve()); }

Comments

[moko3]

回答ありがとうございます。
operator<()が１つしか使えないからどうしたら良いかと思っていました。
compare関数をstruct内部に複数個用意するイメージと解釈しました。
（違ってたらすみません）

[episteme]

> compare関数をstruct内部に複数個用意するイメージと解釈しました。
その通り。(structの外で定義しても問題はないけど)

[moko3]

コメントありがとうございます。
おかげさまで4種類(first,second,昇順,降順)の各ソートが出来るpair型ぽいstructのテンプレが作れました。

Answer 2

質問が C++17 を前提としているので少しトピックから外れた回答となりますが C++20 からプロジェクション (投射) という概念が導入されました。 また、ソート関数でプロジェクションが利用できるようになりました。

要するに「変換」に類する処理を統一的なインターフェイスで扱えるようにするというのがプロジェクションの考え方で、関数ポインタ、関数オブジェクト、メンバポインタがプロジェクションとして使えます。

昇順・降順をどうするかとどの要素を比較するかを分けて指示することが出来るので様々な状況に対応しやすいのが利点でしょう。

#include <algorithm>
#include <iostream>
#include <ranges>
#include <tuple>
#include <vector>

struct either {
    either(int left, int right) : left(left), right(right) {}
    std::tuple<int, int> to_tuple() {
        return std::make_tuple(this->left, this->right);
    }
    std::tuple<int, int> to_tuple_reverse_order() {
        return std::make_tuple(this->right, this->left);
    }
    int left;
    int right;
};

std::ostream& operator<<(std::ostream& os, either& obj) {
    os << '(' << obj.left << ',' << obj.right << ')';
    return os;
}

int main() {
    std::vector<either> p = {{8, 2},
                             {9, 1},
                             {7, 3},
                             {5, 5},
                             {6, 4}};

    // 右側要素だけを見て (左側要素を無視して) 昇順に並べる
    // メンバポインタをプロジェクションとして渡している
    std::ranges::sort(p, std::ranges::less(), &either::right);
    for (auto e : p) std::cout << e << '\n';
    std::cout << std::endl;

    // 右側要素を優先して降順に並べる
    // メンバ関数ポインタをプロジェクションとして渡している
    std::ranges::sort(p, std::ranges::greater(), &either::to_tuple_reverse_order);
    for (auto e : p) std::cout << e << '\n';
}

ちなみにプロジェクションの概念は C++20 からのものですが関数ポインタ、関数オブジェクト、メンバポインタを統一的に扱う std::invoke は C++17 から有ります。

---

それと質問内で提示されているコードで気になった点として識別子の名前があります。 アンダースコアで始まってそれに大文字が続く名前は予約されています。 そのような名前を使った結果は未定義ですので避けるべきです。

---

比較演算子 (operator< など) や四則演算の演算子は非メンバ関数として定義するのが通例です。 標準ライブラリでもそうなっています。 メンバ関数として定義しても仕様に反するわけではありませんが左辺では暗黙の型変換が働かない (右辺では働く) という不格好なことになってしまうからです。

Comments

[moko3]

回答ありがとうございます。
C++20は近い将来使うことになると思いますので参考になります。
あと全体的にモダンなコードの書き方？も意識されてるように伺えるところも参考になります。
（開発環境でC++17とC++20を混在させると混乱しそうなので今はC++17のみにして学習しています）

[moko3]

＞＞アンダースコアで始まってそれに大文字が続く名前は予約されています。
ご指摘ありがとうございます。
何かのコードを参考にした時から（多分そのコードでは_x,_yなどを使っていたはずです）
見様見真似で意味も理解せずに_X,_Yのように勝手に自分の書きやすい書き方をしていました。
今後は使わないように気をつけます。

[moko3]

＞＞比較演算子 (operator< など) や四則演算の演算子は非メンバ関数として定義するのが通例です。
ご指摘ありがとうございます。
これもよく理解せずにネットで調べたコードをそのまま自分なりにアレンジして使ってましたが勉強になります。