冗長なソート処理を1つのメソッドにまとめたいです。

Question

複数ある冗長なソート処理を、各パラメータの条件式を引数にした
メソッドにまとめたいです。

下記は攻撃力や防御力といったパラーメータが高い順に、
5〜1のランク付をするプログラムです。
現状、ランクを定数で5としていますが、変更が考えられます。

どのように解決したら良いでしょうか。
宜しくお願いします。

    std::vector<const DataIn*> ref;
    std::unordered_map<uint64_t, int> m_mapAttackRank; // キー:id, 値:ランク
    std::unordered_map<uint64_t, int> m_mapDefenceRank; // キー:id, 値:ランク
    
    /*!
     *中略
     */

    // attack順にソート
    std::sort(ref.begin(), ref.end(),
              [] (const DataIn* l, const DataIn* r)
              {
                  return l->attack > r->attack;
              });
    for (int i = 0 , rank = 5  ; 0 < rank ; i++ , rank--)
    {
        // 数値が高い順に5~1のランクをつける。
        m_mapAttackRank[ref.at(i)->id] = rank;
    }
    
    // defence順にソート
    std::sort(ref.begin(), ref.end(),
              [] (const DataIn* l, const DataIn* r)
              {
                  return l->defence > r->defence;
              });
    for (int i = 0 , rank = 5  ; 0 < rank ; i++ , rank--)
    {
        // 数値が高い順に5〜1のランクをつける。
        m_mapDefenceRank[ref.at(i)->id] = rank;
    }

    /*!
     *以下、attackやdefenceと同様に、
     *magicやvitalityなどのパラメータもソート。
     */

Answer 1

こんにちは。

質問の意図を捉えそこねていたらすいません。

std::sort(ref.begin(), ref.end(),
          [] (const DataIn* l, const DataIn* r)
          {
              return l->attack > r->attack;
          });
for (int i = 0 , rank = 5  ; 0 < rank ; i++ , rank--)
{
    // 数値が高い順に5~1のランクをつける。
    m_mapAttackRank[ref.at(i)->id] = rank;
}

上記の処理をまとめるのでしたら、次のようにすればできます。

template<typename tComp>
rank(std::vector<const DataIn*>& iData,
     std::unordered_map<uint64_t, int>& oRank,
     tComp iComp)
{
    std::sort(iData.begin(), iData.end(), iComp);
    for (int i = 0 , rank = 5  ; 0 < rank ; i++ , rank--)
    {
        // 数値が高い順に5~1のランクをつける。
        oRank[iData.at(i)->id] = rank;
    }
}

下記のようにして呼び出します。

rank(ref, m_mapAttackRank,
     [] (const DataIn* l, const DataIn* r)
     {
         return l->attack > r->attack;
     });

---

【別解】
catsforepawさんも同じ意味で理解されていようなので、間違ってないようでちょっと安心。
で、メンバ変数へのポインタを使ってより使いやすく書けました。

template<typename tData, typename tValueType, typename tMapKey>
void rank(std::vector<const tData*>& iData,
     std::unordered_map<tMapKey, int>& oRank,
     tValueType tData::*iValue)
{
    std::sort(iData.begin(), iData.end(),
              [&iValue] (const tData* l, const tData* r)
              {
                  return (l->*iValue) > (r->*iValue);
              });
    for (int i = 0 , rank = 5  ; 0 < rank ; i++ , rank--)
    {
        // 数値が高い順に5~1のランクをつける。
        oRank[iData.at(i)->id] = rank;
    }
}

以下のようにして呼び出します。

rank(ref, m_mapAttackRank, &DataIn::attack);
rank(ref, m_mapDefenceRank, &DataIn::defence);

rank()関数の定義側は複雑ですが、使い方は随分すっきりできましたし、DataIn型にも依存してません。
m_mapAttackRank等のoperator[]に使える型のidメンバを持っていればOKです。この型も型推論に任せることができたので、uint64_tでなくても使えます。（unordered_map<>の指定で決まります。)

Comments

[kotsukotsu]

ありがとうございます、Chironianさんのご回答を参考にさせていただきました。

Answer 2

ぱっと思いつくのだとこんな感じです。

enum StatusType
{
	Attack,
	Defence,
	Magic,
	Vitality,
};

template <StatusType Type>
struct RankTarget{};

template <>
struct RankTarget<Attack>
{
	static int Value(const DataIn *data){return data->attack;}
};

template <>
struct RankTarget<Defence>
{
	static int Value(const DataIn *data){return data->defence;}
};
	// 他のステータスも同様に

template <StatusType Type>
struct Ranking : RankTarget<Type>
{
	static void Sort(std::vector<const DataIn*> &ref, std::unordered_map<uint64_t, int> & rankmap)
	{
		std::sort(ref.begin(), ref.end(),
			[](const DataIn* l, const DataIn* r)
			{
				return Value(l) > Value(r);
			});
		for(int i = 0, rank = 5; 0 < rank; i++, rank--)
		{
			// 数値が高い順に5~1のランクをつける。
			rankmap[ref.at(i)->id] = rank;
		}
	}
};


// 呼び出し側

Ranking<Attack>::Sort(ref, m_mapAttackRank);
Ranking<Defence>::Sort(ref, m_mapDefenceRank);
	// 他のステータスも同様に

ソート処理は共通化して、引数で渡せないDataInオブジェクトのメンバ変数はテンプレートで切り替えるようにしています。
ランキングを固定値ではなくて変数にする場合は、引数として渡すなどが考えられます。

Comments

[kotsukotsu]

度々ご回答いただき、ありがとうございます。