C में स्ट्रक्चर वेरिएबल्स पर ऑपरेशन्स

स्ट्रक्चर वेरिएबल्स पर अनुमत ऑपरेशन्स

यहां हम देखेंगे कि स्ट्रक्चर वेरिएबल्स पर किस प्रकार के ऑपरेशन्स किए जा सकते हैं। मूल रूप से स्ट्रक्चर के लिए केवल एक ऑपरेशन किया जा सकता है: **असाइनमेंट ऑपरेशन**। इक्वलिटी चेक या अन्य जैसे कुछ अन्य ऑपरेशन्स स्ट्रक्चर के लिए उपलब्ध नहीं हैं।

उदाहरण: वैध असाइनमेंट

#include <stdio.h>

typedef struct {
    int real, imag;
} complex;

void displayComplex(complex c) {
    printf("(%d + %di)\n", c.real, c.imag);
}

int main() {
    complex c1 = {5, 2};
    complex c2 = {8, 6};
    
    printf("Complex numbers are:\n");
    displayComplex(c1);
    displayComplex(c2);
    
    // असाइनमेंट काम करता है
    complex c3 = c1;  // मेंबर-वाइज कॉपी
    c3.real = 10;
    
    return 0;
}

आउटपुट

Complex numbers are:
(5 + 2i)
(8 + 6i)

काम नहीं करने वाले ऑपरेशन्स

इक्वलिटी तुलना (==) - काम नहीं करता

#include <stdio.h>

typedef struct {
    int real, imag;
} complex;

int main() {
    complex c1 = {5, 2};
    complex c2 = c1;
    
    // त्रुटि: स्ट्रक्चर्स के लिए == ऑपरेटर परिभाषित नहीं है
    if (c1 == c2) {
        printf("Complex numbers are same.\n");
    } else {
        printf("Complex numbers are not same.\n");
    }
    
    return 0;
}

आउटपुट

[Error] invalid operands to binary == (have 'complex' and 'complex')

समाधान: कस्टम तुलना फ़ंक्शन

#include <stdio.h>
#include <stdbool.h>

typedef struct {
    int real, imag;
} complex;

// कस्टम तुलना फ़ंक्शन
bool complex_equal(complex a, complex b) {
    return a.real == b.real && a.imag == b.imag;
}

int main() {
    complex c1 = {5, 2};
    complex c2 = {5, 2};
    complex c3 = {8, 6};
    
    if (complex_equal(c1, c2))
        printf("c1 और c2 समान हैं\n");
    else
        printf("c1 और c2 समान नहीं हैं\n");
    
    if (complex_equal(c1, c3))
        printf("c1 और c3 समान हैं\n");
    else
        printf("c1 और c3 समान नहीं हैं\n");
    
    return 0;
}

स्ट्रक्चर ऑपरेशन्स सारांश

C++ में: ऑपरेटर ओवरलोडिंग

C++ में, आप स्ट्रक्चर्स/क्लासेस के लिए ऑपरेटर्स ओवरलोड कर सकते हैं:

struct Complex {
    int real, imag;
    
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }
    
    Complex operator+(const Complex& other) const {
        return {real + other.real, imag + other.imag};
    }
};