ทำไมคอมไพเลอร์ C ++ ไม่ได้กำหนดโอเปอเรเตอร์ == และโอเปอเรเตอร์! =?

ฉันเป็นแฟนตัวยงของการให้คอมไพเลอร์ทำงานให้คุณได้มากที่สุด เมื่อเขียนคลาสง่าย ๆ คอมไพเลอร์สามารถให้สิ่งต่อไปนี้กับ 'ฟรี':

• ตัวสร้างเริ่มต้น (ว่าง)
• ตัวสร้างสำเนา
• ผู้ทำลายล้าง
• ผู้ประกอบการที่ได้รับมอบหมาย ( operator=)

แต่ก็ดูเหมือนจะไม่สามารถทำให้คุณดำเนินการเปรียบเทียบใด ๆ - เช่นหรือoperator== operator!=ตัวอย่างเช่น:

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

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

คอมไพเลอร์จะไม่ทราบว่าคุณต้องการเปรียบเทียบตัวชี้หรือการเปรียบเทียบแบบลึก (ภายใน)

มันปลอดภัยกว่าที่จะไม่ใช้มันและปล่อยให้โปรแกรมเมอร์ทำเอง จากนั้นพวกเขาสามารถตั้งสมมติฐานทั้งหมดที่พวกเขาชอบ

อาร์กิวเมนต์ที่หากคอมไพเลอร์สามารถให้ตัวสร้างการคัดลอกเริ่มต้นมันควรจะสามารถให้เริ่มต้นที่คล้ายกันoperator==()ทำให้รู้สึกจำนวนหนึ่ง ฉันคิดว่าเหตุผลสำหรับการตัดสินใจที่จะไม่ให้ค่าเริ่มต้นที่คอมไพเลอร์สร้างขึ้นสำหรับผู้ประกอบการนี้สามารถคาดเดาได้จากสิ่งที่ Stroustrup กล่าวเกี่ยวกับตัวสร้างสำเนาเริ่มต้นใน "การออกแบบและวิวัฒนาการของ C ++" (มาตรา 11.4.1 - การควบคุมการคัดลอก) :

ฉันถือว่าเป็นการส่วนตัวที่โชคร้ายที่การทำสำเนาถูกกำหนดโดยค่าเริ่มต้นและฉันไม่อนุญาตให้คัดลอกวัตถุในหลาย ๆ คลาสของฉัน อย่างไรก็ตาม C ++ สืบทอดการกำหนดค่าเริ่มต้นและตัวสร้างการคัดลอกจาก C และใช้บ่อย

ดังนั้นแทนที่จะ "ทำไม C ++ ถึงไม่มีค่าเริ่มต้น operator==() " คำถามควรเป็น "ทำไม C ++ มีการกำหนดค่าเริ่มต้นและตัวสร้างการคัดลอก" ด้วยคำตอบที่ว่ารายการเหล่านั้นถูกรวมอย่างไม่เต็มใจโดย Stroustrup สำหรับความเข้ากันได้กับ C (อาจเป็นสาเหตุของหูดส่วนใหญ่ของ C ++ แต่อาจเป็นสาเหตุหลักของความนิยมของ C ++)

เพื่อจุดประสงค์ของฉันเองใน IDE ของฉันส่วนย่อยที่ฉันใช้สำหรับคลาสใหม่มีการประกาศสำหรับผู้ดำเนินการกำหนดค่าส่วนตัวและตัวสร้างการคัดลอกดังนั้นเมื่อฉันสร้างคลาสใหม่ขึ้นมาฉันจะไม่ได้รับค่าเริ่มต้นและการคัดลอก ของการดำเนินการเหล่านั้นจากprivate:ส่วนถ้าฉันต้องการรวบรวมเพื่อให้สามารถสร้างพวกเขาสำหรับฉัน

แม้แต่ใน C ++ 20 คอมไพเลอร์ก็ยังไม่สร้างoperator==ให้คุณโดยปริยาย

struct foo
{
    std::string str;
    int n;
};

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ill-formed

แต่คุณจะได้รับความสามารถในการเริ่มต้นอย่างชัดเจน== ตั้งแต่ C ++ 20 :

struct foo
{
    std::string str;
    int n;

    // either member form
    bool operator==(foo const&) const = default;
    // ... or friend form
    friend bool operator==(foo const&, foo const&) = default;
};

ผิดนัด==ไม่สมาชิกที่ชาญฉลาด==(ในลักษณะเดียวกับที่ตัวสร้างสำเนาเริ่มต้นไม่สมาชิกฉลาดก่อสร้างคัดลอก) กฎระเบียบใหม่ยังมีความสัมพันธ์ที่คาดว่าระหว่างและ== !=ตัวอย่างเช่นด้วยการประกาศข้างต้นฉันสามารถเขียนทั้งสอง:

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ok!
assert(foo{"Anton", 1} != foo{"Anton", 2}); // ok!

คุณลักษณะเฉพาะนี้ (ผิดนัดoperator==และสมมาตรระหว่าง==และ!=) มาจากหนึ่งในข้อเสนอoperator<=>ที่เป็นส่วนหนึ่งของคุณลักษณะภาษาที่เป็นที่กว้างขึ้น

IMHO ไม่มีเหตุผล "ดี" เหตุผลที่มีคนจำนวนมากที่เห็นด้วยกับการตัดสินใจออกแบบนี้ก็เพราะพวกเขาไม่ได้เรียนรู้ที่จะเชี่ยวชาญพลังของความหมายตามค่า ผู้คนจำเป็นต้องเขียนตัวสร้างสำเนาแบบกำหนดเองจำนวนมากตัวดำเนินการเปรียบเทียบและตัวทำลายเนื่องจากใช้ตัวชี้แบบดิบในการใช้งาน

เมื่อใช้พอยน์เตอร์สมาร์ทที่เหมาะสม (เช่น std :: shared_ptr) ตัวสร้างการคัดลอกเริ่มต้นมักจะใช้ได้

มันตอบ C ++ ไม่ได้ทำ == เพราะ C ไม่ได้และนี่คือเหตุผลว่าทำไม C ถึงมีค่าเริ่มต้นเท่านั้น = แต่ไม่มี == ในตอนแรก C ต้องการทำให้มันง่าย: C Implement = โดย memcpy; อย่างไรก็ตาม == ไม่สามารถใช้งานได้โดย memcmp เนื่องจากการเติมเต็ม เนื่องจากการเติมเต็มไม่ได้ถูกกำหนดค่าเริ่มต้น memcmp จึงบอกว่ามันต่างกันแม้ว่าจะเหมือนกันก็ตาม ปัญหาเดียวกันนี้เกิดขึ้นสำหรับคลาสที่ว่างเปล่า: memcmp บอกว่ามันแตกต่างกันเนื่องจากขนาดของคลาสที่ว่างเปล่าไม่เป็นศูนย์ จะเห็นได้จากด้านบนว่าการใช้ == นั้นซับซ้อนกว่าการใช้ = ใน C. ตัวอย่างโค้ดบางส่วนเกี่ยวกับเรื่องนี้ การแก้ไขของคุณจะได้รับการชื่นชมถ้าฉันผิด

ในวิดีโอนี้Alex Stepanov ผู้สร้าง STL ตอบคำถามนี้เมื่อเวลาประมาณ 13:00 น. เพื่อสรุปโดยดูวิวัฒนาการของ C ++ เขาให้เหตุผลว่า:

• มันโชคร้ายที่== และ! =ไม่ได้ประกาศโดยปริยาย (และ Bjarne เห็นด้วยกับเขา) ภาษาที่ถูกต้องควรมีสิ่งเหล่านั้นพร้อมสำหรับคุณ (เขาดำเนินการต่อไปเพื่อแนะนำคุณไม่ควรกำหนด! =ซึ่งจะแบ่งความหมายของ== )
• เหตุผลนี้เป็นกรณีที่มีราก (เป็นจำนวนมากของปัญหา C ++) ใน C. มีผู้ประกอบการที่ได้รับมอบหมายจะถูกกำหนดโดยปริยายด้วยบิตโดยการโอนบิตแต่ที่จะไม่ทำงานสำหรับ== สามารถอ่านคำอธิบายโดยละเอียดเพิ่มเติมได้ในบทความนี้จาก Bjarne Stroustrup
• ในคำถามที่ตามมาทำไมเมื่อเปรียบเทียบสมาชิกไม่ได้ใช้เขาบอกว่าสิ่งที่น่าอัศจรรย์ : C เป็นภาษาพื้นบ้านและคนที่ใช้สิ่งเหล่านี้เพื่อริตชี่บอกเขาว่าเขาพบว่ามันยากที่จะติดตั้ง!

จากนั้นเขาก็บอกว่าในอนาคต (ไกล) ==และ! =จะถูกสร้างขึ้นโดยปริยาย

C ++ 20 มีวิธีการใช้งานตัวดำเนินการเปรียบเทียบเริ่มต้น

ตัวอย่างจากcppreference.com :

class Point {
    int x;
    int y;
public:
    auto operator<=>(const Point&) const = default;
    // ... non-comparison functions ...
};

// compiler implicitly declares operator== and all four relational operators work
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // ok, calls implicit Point::operator==
std::set<Point> s; // ok
s.insert(pt1); // ok
if (pt1 <= pt2) { /*...*/ } // ok, makes only a single call to Point::operator<=>

มันเป็นไปไม่ได้ที่จะกำหนดค่าเริ่มต้น==แต่คุณสามารถกำหนดค่าเริ่มต้น!=ผ่าน==ที่คุณมักจะควรกำหนดด้วยตัวเอง สำหรับสิ่งนี้คุณควรทำสิ่งต่อไปนี้:

#include <utility>
using namespace std::rel_ops;
...

class FooClass
{
public:
  bool operator== (const FooClass& other) const {
  // ...
  }
};

คุณสามารถดูhttp://www.cplusplus.com/reference/std/utility/rel_ops/สำหรับรายละเอียด

นอกจากนี้ถ้าคุณกำหนดoperator< ผู้ประกอบการสำหรับ <=,>,> = std::rel_opsสามารถสรุปได้จากมันเมื่อใช้

แต่คุณควรระวังเมื่อคุณใช้งานstd::rel_opsเนื่องจากตัวดำเนินการเปรียบเทียบสามารถอนุมานได้สำหรับประเภทที่คุณไม่คาดคิด

เพิ่มเติมวิธีการอนุมานผู้ประกอบการที่เกี่ยวข้องจากขั้นพื้นฐานหนึ่งที่แนะนำคือการใช้เพิ่ม :: ผู้ประกอบการ

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

คุณยังสามารถสร้าง "+" จาก "+ =", - จาก "- =", ฯลฯ ... (ดูรายการทั้งหมดได้ที่นี่ )

C ++ 0x มีข้อเสนอสำหรับฟังก์ชั่นเริ่มต้นดังนั้นคุณสามารถพูดได้ว่าdefault operator==; เราได้เรียนรู้ว่ามันช่วยทำให้สิ่งเหล่านี้ชัดเจน

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

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

มีเหตุผลที่ดีสำหรับสิ่งนี้หรือไม่? เหตุใดการเปรียบเทียบแบบเปรียบเทียบระหว่างสมาชิกจึงเป็นปัญหา

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

ลองพิจารณาตัวอย่างนี้โดยverboseDescriptionเลือกสตริงที่มีความยาวจากชุดคำอธิบายสภาพอากาศที่ค่อนข้างเล็ก

class LocalWeatherRecord {
    std::string verboseDescription;
    std::tm date;
    bool operator==(const LocalWeatherRecord& other){
        return date==other.date
            && verboseDescription==other.verboseDescription;
    // The above makes a lot more sense than
     // return verboseDescription==other.verboseDescription
     //     && date==other.date;
    // because some verboseDescriptions are liable to be same/similar
    }
}

(แน่นอนว่าคอมไพเลอร์จะมีสิทธิ์เพิกเฉยต่อคำสั่งของการเปรียบเทียบถ้ามันรับรู้ว่าพวกเขาไม่มีผลข้างเคียง แต่สันนิษฐานว่ามันยังคงใช้คิวจากซอร์สโค้ดซึ่งมันไม่มีข้อมูลที่ดีกว่าของมันเอง)

เพื่อให้คำตอบสำหรับคำถามนี้ยังคงสมบูรณ์เมื่อเวลาผ่านไป: ตั้งแต่ C ++ 20 สามารถสร้างขึ้นโดยอัตโนมัติด้วยคำสั่ง auto operator<=>(const foo&) const = default;

มันจะสร้างตัวดำเนินการทั้งหมด: ==,! =, <, <=,> และ> =, ดูhttps://en.cppreference.com/w/cpp/language/default_comparisonsสำหรับรายละเอียด

เนื่องจากรูปลักษณ์ของผู้ปฏิบัติ<=>งานจึงเรียกว่าผู้ดำเนินการยานอวกาศ ดูเพิ่มเติมที่เหตุใดเราจึงต้องการยานอวกาศ <=> โอเปอเรเตอร์ใน C ++ .

แก้ไข: ยังอยู่ใน C ++ 11 แทนเรียบร้อยสวยที่สามารถใช้ได้กับstd::tieดูhttps://en.cppreference.com/w/cpp/utility/tuple/tiebool operator<(…)สำหรับตัวอย่างรหัสที่สมบูรณ์แบบด้วย ส่วนที่น่าสนใจเปลี่ยนไปทำงานด้วย==คือ:

#include <tuple>

struct S {
………
bool operator==(const S& rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) == std::tie(rhs.n, rhs.s, rhs.d);
    }
};

std::tie ทำงานร่วมกับผู้ประกอบการเปรียบเทียบทั้งหมดและได้รับการปรับให้เหมาะสมโดยคอมไพเลอร์

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

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

นอกจากนี้ - พวกเขาใช้เวลาเขียนไม่นานเหรอ?!