विषय पर बढ़ें

अंतिम अद्यतन：2026-10-12

C++20 थ्री-वे comparison ऑपरेटर <=>

तीन प्रकार के ordering

थ्री-वे comparison ऑपरेटर <=> को spaceship operator भी कहते हैं, इसके रिटर्न वैल्यू में तीन प्रकार के ordering होते हैं, नीचे gcc सोर्स कोड के नज़रिए गहराई से चर्चा करते हैं।

नोट: आलसी लोगों के लिए, इस सेक्शन के उदाहरण 星球 पर अपडेट किए जा चुके हैं।

उपयोग: <=>

#include <compare>
#include <iostream>

int main() {
   auto c1 = 1.1 <=> 2.2;
   auto c2 = -1 <=> 1;
   std::cout << typeid(c1).name() << std::endl;
   std::cout << typeid(c2).name() << std::endl;
}

आउटपुट:

St16partial_ordering
St15strong_ordering
  1. 1.1 <=> 2.2: यह दो floating-point संख्याओं की तुलना है। Floating-point संख्याओं के लिए, स्टैंडर्ड लाइब्रेरी std::partial_ordering लौटाती है, क्योंकि floating-point संख्याओं में NaN मान मौजूद होते हैं, जिससे इनके बीच तुलना कठोर total ordering नहीं होती। std::partial_ordering परिणाम को <, >, == या unordered होने की अनुमति देता है।

हम gcc कोड के static वेरिएबल का उपयोग करके देख सकते हैं कि partial_ordering आख़िर में कम, अधिक, बराबर, unordered में से क्या है:

static const partial_ordering less;
static const partial_ordering equivalent;
static const partial_ordering greater;
static const partial_ordering unordered;

यदि हम forced conversion करें तो त्रुटि मिलेगी:

comp.cc:6:36: error: conversion from 'std::partial_ordering' to non-scalar type 'std::strong_ordering' requested
    6 |   std::strong_ordering c1 = 1.1 <=> 2.2;

2. `-1 <=> 1`: यह दो पूर्णांकों की तुलना है। पूर्णांकों के लिए, स्टैंडर्ड लाइब्रेरी `std::strong_ordering` लौटाती है, क्योंकि पूर्णांकों की तुलना कठोर total ordering संबंध है, कोई अनिश्चित स्थिति नहीं। `std::strong_ordering` केवल `<`, `>` या `==` लौटाता है।

इसी तरह, नीचे दिए 4 static मेंबरों का उपयोग किया जा सकता है।

static const strong_ordering less;
static const strong_ordering equal;
static const strong_ordering equivalent;
static const strong_ordering greater;

इसलिए, c1 का प्रकार std::partial_ordering है, जबकि c2 का प्रकार std::strong_ordering है, यही बताता है कि आउटपुट में प्रकार अलग-अलग क्यों आए।

partial_ordering और strong_ordering के अलावा, <=> weak_ordering भी लौटा सकता है, इसके static मेंबर ये हैं:

static const weak_ordering less;
static const weak_ordering equivalent;
static const weak_ordering greater;

equal और equivalent

ऊपर दिए तीनों ordering में देखा जा सकता है कि बराबर होने के लिए दो शब्द आए हैं: equal और equivalent, इन दोनों में क्या अंतर है?

यहाँ सीधे cppreference देखें, दोनों के बीच कोई अंतर नहीं। हालांकि, std::strong_ordering एकमात्र ऐसी श्रेणी है जो equality परिभाषित करती है। बाक़ी सभी श्रेणियाँ केवल equivalence परिभाषित करती हैं। यह ऊपर के static मेंबरों की पुष्टि भी करता है, strong_ordering के लिए दो हैं, बाक़ियों के पास केवल equivalent है।

यदि तुलना तुलना किए जा रहे items के बीच strong ordering उत्पन्न करती है, तो equivalence और equality एक ही हैं। इसे व्यक्त करने के लिए दो शब्द इसलिए हैं, क्योंकि अन्य प्रकार के orderings के लिए ऐसा नहीं होता। Weak और partial में equalityबिल्कुल नहीं होती; वे केवल equivalence देते हैं।

Equivalence का अर्थ है दो ऑब्जेक्ट तुलना में बराबर हो सकते हैं। Equality और भी मज़बूत चीज़ को दर्शाती है; यदि वे तुलना में बराबर हैं, तो किसी भी const उपयोग में एक की जगह दूसरा रखा जा सकता है: जब तक a == b सत्य है, f(a) == f(b) वाला गुण सत्य है, जहाँ f ऐसा फ़ंक्शन है जो केवल पैरामीटर के सार्वजनिक const मेंबरों से पहुँच योग्य comparison-निर्णायक state को पढ़ता है। यदि किसी प्रकार की तुलना equality की अनुमति देती है (जो strong ordering की शर्त है), तो वह equivalence भी अनुमति देती है। इसलिए, strong ordering तुलना के लिए दोनों एक ही हैं।

https://en.cppreference.com/w/cpp/utility/compare/strong_ordering

थ्री-वे comparison ऑपरेटर क्यों उपयोग करें?

थ्री-वे comparison ऑपरेटर (<=>) एक ही ऑपरेशन में दो मानों का ordering संबंध निर्धारित कर देता है, जबकि पारंपरिक comparison ऑपरेटरों को कई बार तुलना करनी पड़ती है।

पारंपरिक comparison ऑपरेटरों की सीमाएँ:

  • यदि a == b असत्य है, तो आप नहीं जान सकते कि a < b है या a > b।
  • यदि a != b सत्य है, तो आप नहीं जान सकते कि a < b है या a > b।
  • यदि a < b असत्य है, तो आप नहीं जान सकते कि a == b है या a > b।
  • यदि a > b असत्य है, तो आप नहीं जान सकते कि a == b है या a < b।
  • यदि a <= b सत्य है, तो आप नहीं जान सकते कि a == b है या a < b।
  • यदि a >= b सत्य है, तो आप नहीं जान सकते कि a == b है या a > b।

ये सीमाएँ बताती हैं कि पारंपरिक comparison ऑपरेटर एक बार में दो मानों का पूरा संबंध निर्धारित नहीं कर सकते, पूरा परिणाम पाने के लिए कई बार तुलना करनी पड़ती है।

यह सेक्शन समाप्त

संबंधित विषय

टिप्पणियाँ