C++ में तुलना ऑपरेटर और लॉजिकल ऑपरेटर

यह क्या है और क्यों?

कल्पना करो कि तुम एक कंप्यूटर गेम खेल रहे हो। तुम्हारे पास 100 जीवन हैं। जब तुम एक राक्षस से मिलते हो, गेम जाँचता है: "क्या जीवन 0 से अधिक हैं?"। अगर हाँ — तुम लड़ सकते हो। अगर नहीं — गेम कहता है: "Game Over"।

प्रोग्रामिंग में ऐसी जाँचें तुलना ऑपरेटरों और तार्किक ऑपरेटरों द्वारा की जाती हैं। ये प्रोग्राम को निर्णय लेने में मदद करते हैं। उदाहरण के लिए:

• जाँचना कि खाते में पर्याप्त पैसे हैं या नहीं
• पता लगाना कि शाम हो गई है या नहीं
• समझना कि क्या खिलाड़ी दरवाजा खोल सकता है (क्या उसके पास चाबी है या वह कोड जानता है)

इनके बिना प्रोग्राम एक ऐसे रोबोट जैसा होगा जो बिना देखे कि आसपास क्या हो रहा है, वही काम करता रहेगा। इनके साथ यह स्मार्ट बन जाता है!

सिंटैक्स और कोड उदाहरण

C++ में तुलना ऑपरेटर इस प्रकार दिखते हैं:

==  // बराबर (ध्यान दें: दो बराबर के निशान!)
!=  // बराबर नहीं
>   // बड़ा
<   // छोटा
>=  // बड़ा या बराबर
<=  // छोटा या बराबर

और तार्किक ऑपरेटर कई शर्तों को जोड़ते हैं:

&&  // और (दोनों शर्तें true होनी चाहिए)
||  // या (कम से कम एक शर्त true हो)
!   // नहीं (true को false में और false को true में बदलता है)

उदाहरण 1: उम्र की जाँच

#include <iostream>
using namespace std;

int main() {
    int age = 14;
    
    // जाँच: क्या उम्र 18 से बड़ी या बराबर है?
    if (age >= 18) {
        cout << "तुम वयस्क हो!" << endl;
    } else {
        cout << "तुम अभी बच्चे हो." << endl;
    }
    // आउटपुट: "तुम अभी बच्चे हो."
    // क्योंकि 14, 18 से बड़ा या बराबर नहीं है
    return 0;
}

उदाहरण 2: तार्किक और (&&)

#include <iostream>
using namespace std;

int main() {
    bool has_key = true;
    bool knows_code = false;
    
    // दरवाजा खोलने के लिए, चाबी और कोड दोनों चाहिए
    if (has_key && knows_code) {
        cout << "दरवाजा खुला!" << endl;
    } else {
        cout << "पहुँच अस्वीकृत." << endl;
    }
    // आउटपुट: "पहुँच अस्वीकृत."
    // क्योंकि knows_code = false
    return 0;
}

उदाहरण 3: तार्किक या (||)

#include <iostream>
using namespace std;

int main() {
    int temperature = 30; // डिग्री
    
    // टहलने जाएँ, अगर गर्मी है या सूखा है
    if (temperature > 20 || temperature < 10) {
        cout << "चलो टहलने चलें!" << endl;
    } else {
        cout << "घर पर बैठें." << endl;
    }
    // आउटपुट: "चलो टहलने चलें!"
    // क्योंकि 30 > 20 (पहली शर्त true है)
    return 0;
}

उदाहरण 4: तार्किक नहीं (!)

#include <iostream>
using namespace std;

int main() {
    bool is_raining = false;
    
    // अगर बारिश नहीं हो रही है, तो टहलने चलें
    if (!is_raining) {
        cout << "वाह, टहलने चलें!" << endl;
    } else {
        cout << "छाता ले लें." << endl;
    }
    // आउटपुट: "वाह, टहलने चलें!"
    // क्योंकि !false = true
    return 0;
}

उदाहरण 5: जटिल शर्त

#include <iostream>
using namespace std;

int main() {
    int age = 16;
    bool has_license = false;
    bool with_parents = true;
    
    // गाड़ी चला सकते हैं, अगर:
    // (उम्र >= 18 और लाइसेंस है) या (माता-पिता के साथ)
    if ((age >= 18 && has_license) || with_parents) {
        cout << "गाड़ी चला सकते हैं!" << endl;
    } else {
        cout << "गाड़ी नहीं चला सकते." << endl;
    }
    // आउटपुट: "गाड़ी चला सकते हैं!"
    // क्योंकि with_parents = true
    return 0;
}

Python से तुलना

Python में वही ऑपरेटर लगभग समान दिखते हैं, लेकिन महत्वपूर्ण अंतर हैं:

Python में उदाहरण:

age = 14
if age >= 18:
    print("You are an adult!")
else:
    print("You are still a child.")
# Output: "You are still a child."

मुख्य अंतर: Python में तार्किक ऑपरेटर शब्दों (and, or, not) में लिखे जाते हैं, जबकि C++ में प्रतीकों (&&, ||, !) में। साथ ही, Python में अर्धविराम और घुंघराले कोष्ठक की आवश्यकता नहीं है — इसके बजाय इंडेंटेशन का उपयोग किया जाता है।

शुरुआती लोगों की सामान्य गलतियाँ

गलती 1: = और == में भ्रम

एक बराबर का निशान (=) असाइनमेंट है। दो (==) तुलना है।

// गलत:
if (x = 5) { ... }  // त्रुटि! x में 5 असाइन करता है

// सही:
if (x == 5) { ... }  // जाँचता है कि x पाँच के बराबर है या नहीं

गलती 2: संक्रियाओं की प्राथमिकता भूल जाना

जैसे गणित में: पहले गुणा, फिर जोड़। तर्क में भी एक क्रम है: पहले !, फिर &&, फिर ||।

// अस्पष्ट हो सकता है:
if (a || b && c) // पहले b && c निष्पादित होगा, फिर a || परिणाम

// कोष्ठक का उपयोग करना बेहतर है:
if (a || (b && c)) // अब स्पष्ट है

गलती 3: विभिन्न प्रकारों की तुलना करना

int x = 5;
double y = 5.0;
if (x == y) { ... } // काम करता है, लेकिन अप्रत्याशित हो सकता है

// एक ही प्रकार में बदलना बेहतर है:
if (x == (int)y) { ... }

गलती 4: = का उपयोग करना