การใช้ตัวดำเนินการเปรียบเทียบผ่าน 'tuple' และ 'tie' เป็นความคิดที่ดีหรือไม่?

^{(หมายเหตุ: tupleและtieสามารถนำมาจาก Boost หรือ C ++ 11)}
เมื่อเขียนโครงสร้างขนาดเล็กที่มีเพียงสององค์ประกอบบางครั้งฉันมักจะเลือก a std::pairเนื่องจากมีการทำสิ่งสำคัญทั้งหมดสำหรับประเภทข้อมูลนั้นแล้วเช่นoperator<การจัดลำดับที่เข้มงวด - อ่อนแอ .
ข้อเสียคือชื่อตัวแปรที่ค่อนข้างไร้ประโยชน์ แม้ว่าฉันจะสร้างสิ่งนั้นขึ้นมาเองtypedefแต่ฉันก็จำไม่ได้ว่า 2 วันต่อมาว่าfirstอะไรsecondคืออะไรโดยเฉพาะอย่างยิ่งถ้าทั้งสองเป็นประเภทเดียวกัน สิ่งนี้จะแย่ลงไปอีกสำหรับสมาชิกมากกว่าสองคนเนื่องจากการทำรังนั้นpairค่อนข้างแย่มาก
อีกทางเลือกหนึ่งคือไฟล์tupleไม่ว่าจะจาก Boost หรือ C ++ 11 แต่ก็ไม่ได้ดูดีและชัดเจนขึ้น ดังนั้นฉันจึงกลับไปเขียนโครงสร้างด้วยตัวเองรวมถึงตัวดำเนินการเปรียบเทียบที่จำเป็น
เนื่องจากโดยเฉพาะอย่างยิ่งoperator<อาจเป็นเรื่องยุ่งยากฉันจึงคิดที่จะหลีกเลี่ยงความยุ่งเหยิงทั้งหมดนี้โดยอาศัยการดำเนินการที่กำหนดไว้สำหรับtuple:

ตัวอย่างoperator<เช่นสำหรับการสั่งซื้อที่เข้มงวด - อ่อนแอ:

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);
}

( tieทำให้tupleของT&การอ้างอิงจากการขัดแย้งผ่าน.)

แก้ไข : ข้อเสนอแนะจาก @DeadMG ถึงการสืบทอดแบบส่วนตัวtupleไม่ใช่เรื่องเลวร้าย แต่ก็มีข้อเสียอยู่บ้าง:

• หากผู้ดำเนินการมีสถานะอิสระ (อาจเป็นเพื่อนกัน) ฉันต้องสืบทอดต่อสาธารณะ
• ด้วยการแคสต์ฟังก์ชัน / ตัวดำเนินการของฉัน ( operator=โดยเฉพาะ) สามารถข้ามได้อย่างง่ายดาย
• ด้วยtieวิธีแก้ปัญหาฉันสามารถละทิ้งสมาชิกบางคนได้หากพวกเขาไม่สำคัญสำหรับการสั่งซื้อ

มีข้อบกพร่องใด ๆ ในการใช้งานนี้ที่ฉันต้องพิจารณาหรือไม่?

นี่จะทำให้ง่ายต่อการเขียนตัวดำเนินการที่ถูกต้องมากกว่าการหมุนด้วยตัวเอง ฉันจะบอกว่าให้พิจารณาแนวทางอื่นหากการสร้างโปรไฟล์แสดงให้เห็นว่าการดำเนินการเปรียบเทียบเป็นส่วนที่ใช้เวลานานในการสมัคร มิฉะนั้นความสะดวกในการบำรุงรักษานี้ควรมีมากกว่าข้อกังวลด้านประสิทธิภาพที่อาจเกิดขึ้น

ฉันเจอปัญหาเดียวกันนี้และวิธีแก้ปัญหาของฉันใช้เทมเพลตตัวแปร c ++ 11 รหัสมาที่นี่:

ส่วน. h:

/***
 * 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...);
  }
}

และ. cpp สำหรับกรณีฐานโดยไม่มีข้อโต้แย้ง:

bool lexiLessthan()
{
  return false;
}

ตอนนี้ตัวอย่างของคุณกลายเป็น:

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

ในความคิดของฉันคุณยังไม่ได้แก้ไขปัญหาเดียวกันกับวิธีแก้ปัญหาstd::tupleนั่นคือคุณต้องรู้ทั้งจำนวนและชื่อของตัวแปรสมาชิกแต่ละตัวคุณกำลังทำซ้ำสองครั้งในฟังก์ชัน คุณสามารถเลือกprivateรับมรดกได้

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

วิธีการนี้เป็นเล็ก ๆ น้อย ๆอีกเล็กน้อยของระเบียบที่จะเริ่มต้นด้วย แต่คุณยังคงรักษาเพียงตัวแปรและชื่อที่อยู่ในสถานที่แห่งหนึ่งแทนการในสถานที่สำหรับผู้ประกอบการที่คุณต้องการเกินทุก

หากคุณวางแผนที่จะใช้ตัวดำเนินการมากกว่าหนึ่งตัวเกินพิกัดหรือวิธีการอื่น ๆ จากทูเปิลฉันขอแนะนำให้ทำให้ tuple เป็นสมาชิกของคลาสหรือได้มาจากทูเปิล มิฉะนั้นสิ่งที่คุณกำลังทำอยู่จะต้องทำงานมากกว่า เมื่อตัดสินใจระหว่างสองคำถามที่สำคัญที่จะตอบคือ: คุณต้องการเรียนของคุณจะเป็น tuple หรือไม่? ถ้าไม่ฉันขอแนะนำให้มีทูเพิลและ จำกัด อินเทอร์เฟซโดยใช้การมอบหมาย

คุณสามารถสร้าง accessors เพื่อ "เปลี่ยนชื่อ" สมาชิกของทูเพิล