Karşılaştırma operatörlerini "tuple" ve "tie" aracılığıyla uygulamak, iyi bir fikir mi?

^{(Not: tupleve tieBoost veya C ++ 11'den alınabilir.)}
Yalnızca iki öğeli küçük yapılar yazarken std::pair, operator<katı-zayıf sıralama gibi tüm önemli şeyler bu veri türü için zaten yapıldığından, bazen a seçme eğilimindeyim. .
Olumsuz yönleri, oldukça işe yaramaz değişken isimleridir. Kendimi o yarattı bile typedef, ben 2 gün sonra hatırlamayacaksınız firstve hangi secondonlar aynı türden ikisi de, özellikle eğer tam olarak. İkiden fazla üye için bu durum daha da kötüleşiyor, çünkü yuvalama pairoldukça berbat.
Bunun için diğer seçenek birtupleya Boost ya da C ++ 11'den, ancak bu gerçekten daha hoş ve net görünmüyor. Bu yüzden, gerekli karşılaştırma operatörleri de dahil olmak üzere yapıları kendim yazmaya geri dönüyorum.
Özellikle, operator<oldukça külfetli olabileceğinden, sadece aşağıdakiler için tanımlanan işlemlere güvenerek tüm bu karmaşadan kurtulmayı düşündüm tuple:

Örneğin, operator<katı-zayıf-sıralama örneği :

bool operator<(MyStruct const& lhs, MyStruct const& rhs){
  return std::tie(lhs.one_member, lhs.another, lhs.yet_more) <
         std::tie(rhs.one_member, rhs.another, rhs.yet_more);
}

( tieBir hale getirir tupleve T&geçirilen ifade referanslar).

Düzenleme : @DeadMG'den özel olarak miras alma önerisi tuplekötü değil, ancak bazı dezavantajları var:

• Operatörler bağımsızsa (muhtemelen arkadaş), herkese açık olarak miras almam gerekir
• Döküm ile, işlevlerim / işleçlerim ( operator=özellikle) kolayca atlanabilir
• İle tieonlar sipariş için önemli değil eğer çözümü, ben bazı üyelerini bırakabilir

Bu uygulamada dikkate almam gereken herhangi bir sakınca var mı?

Bu kesinlikle doğru bir işleci yazmayı kendi başınıza döndürmekten daha kolay hale getirecektir. Profil oluşturma, karşılaştırma işleminin uygulamanızın zaman alıcı bir parçası olduğunu gösteriyorsa, yalnızca farklı bir yaklaşımı düşünün derim. Aksi takdirde, bunu sürdürmenin kolaylığı, olası performans endişelerinden daha ağır basmalıdır.

Aynı problemle karşılaştım ve çözümüm c ++ 11 değişken şablonlarını kullanıyor. İşte kod geliyor:

.H bölümü:

/***
 * Generic lexicographical less than comparator written with variadic templates
 * Usage:
 *   pass a list of arguments with the same type pair-wise, for intance
 *   lexiLessthan(3, 4, true, false, "hello", "world");
 */
bool lexiLessthan();

template<typename T, typename... Args>
bool lexiLessthan(const T &first, const T &second, Args... rest)
{
  if (first != second)
  {
    return first < second;
  }
  else
  {
    return lexiLessthan(rest...);
  }
}

Ve bağımsız değişkenler olmadan temel durum için .cpp:

bool lexiLessthan()
{
  return false;
}

Şimdi örneğiniz şöyle olur:

return lexiLessthan(
    lhs.one_member, rhs.one_member, 
    lhs.another, rhs.another, 
    lhs.yet_more, rhs.yet_more
);

Benim fikrime göre, hala std::tupleçözümlerle aynı konuyu ele almıyorsunuz - yani, hem kaç tane hem de her bir üye değişkenin adını bilmelisiniz, bunu işlevde iki kez kopyalıyorsunuz. Kalıtımı tercih edebilirsiniz private.

struct somestruct : private std::tuple<...> {
    T& GetSomeVariable() { ... }
    // etc
};

Bu yaklaşım bir olan küçük biraz daha başlamak için bir karmaşa, ama sadece biri yerine aşırı istediğiniz her operatör için her yerde, tek bir yerde değişkenleri ve isimlerini muhafaza ediyoruz.

Birden fazla operatör aşırı yüklemesi veya tuple'dan daha fazla yöntem kullanmayı planlıyorsanız, tuple'ı sınıfın bir üyesi yapmanızı veya tuple'dan türetmenizi öneririm. Aksi takdirde, yaptığınız şey çok daha fazla iştir. İkisi arasında karar verirken, cevaplanması gereken önemli bir soru şudur: Sınıfınızın bir demet olmasını ister misiniz ? Değilse, bir tuple içermesini ve delegasyon kullanarak arabirimi sınırlandırmanızı tavsiye ederim.

Tuple üyelerini "yeniden adlandırmak" için erişimciler oluşturabilirsiniz.