c++ - Int x{y=5} क्यों संभव है?




initialization declaration (3)

int main() {
    int y;
    int x{ y = 5 };
    //x is 5
}

यह कैसे संभव है, चूंकि y = 5 एक गणना योग्य अभिव्यक्ति नहीं है?

इसके अलावा, कंपाइलर या आईडीई मुख्य के बारे में शिकायत क्यों नहीं करता () इंट वापस नहीं करता है?


यह कैसे संभव है, चूंकि y = 5 एक गणना योग्य अभिव्यक्ति नहीं है?

यह एक असाइनमेंट है, और असाइनमेंट यील्ड वैल्यूज, यानी "लेफ्ट ऑपरेंड के [expr.ass/3] टाइप", देखें [expr.ass/3] । इसलिए y = 5 परिणाम y , जो कि 5 , जिसका उपयोग x को प्रारंभ करने के लिए किया जाता है।

अपने दूसरे प्रश्न के संबंध में, main पर संदर्भ देखें (या [basic.start.main/5] ):

मुख्य फ़ंक्शन के शरीर को return स्टेटमेंट को शामिल करने की आवश्यकता नहीं होती है: यदि return स्टेटमेंट का सामना किए बिना नियंत्रण मुख्य के अंत तक पहुंचता है, तो प्रभाव return 0; को निष्पादित करने का है return 0;

इसलिए, संकलक या आईडीई आपको main के अंत में एक लापता return स्टेटमेंट के बारे में चेतावनी देता है जो कि गलत होगा। बेशक, तथ्य यह है कि आपको हमेशा गैर- void कार्यों से वस्तुओं को return करना चाहिए main निष्पादित एक तरह का है ... ठीक है, ऐतिहासिक कारण से मुझे लगता है।


मैं आपके आखिरी सवाल से शुरू करूंगा

इसके अलावा, कंपाइलर या आईडीई मुख्य के बारे में शिकायत क्यों नहीं करता () इंट वापस नहीं करता है?

सी ++ मानक के अनुसार (6.6.1 मुख्य कार्य)

5 मुख्य विवरण में रिटर्न स्टेटमेंट में मुख्य फ़ंक्शन को छोड़ने का प्रभाव होता है (स्वचालित स्टोरेज अवधि के साथ किसी भी ऑब्जेक्ट को नष्ट करना) और एसटीडी कॉल करना :: रिटर्न वैल्यू के साथ तर्क के रूप में बाहर निकलें। यदि नियंत्रण मुख्य के यौगिक-बयान के अंत से बहता है, तो प्रभाव ऑपरेंड 0 के साथ वापसी के बराबर है (यह भी देखें 18.3)।

और इस सवाल के सापेक्ष

यह कैसे संभव है, चूंकि y = 5 एक गणना योग्य अभिव्यक्ति नहीं है?

C ++ स्टैंडर्ड (8.18 असाइनमेंट और कंपाउंड असाइनमेंट ऑपरेटर्स) से

1 असाइनमेंट ऑपरेटर (=) और कंपाउंड असाइनमेंट ऑपरेटर सभी ग्रुप को राइट-टू-लेफ्ट करते हैं। सभी को अपने बाएं ऑपरेंड के रूप में एक परिवर्तनीय अंतराल की आवश्यकता होती है और बाएं ऑपरेंड का जिक्र करते हुए एक अंतराल लौटाता है।

इस घोषणा को प्रायोजित करें

int x{ y = 5 };

समान रूप से दो बयानों में विभाजित किया जा सकता है

y = 5;
int x{ y };

इसके अलावा C ++ में आप निम्न तरीके से चर y का संदर्भ बना सकते हैं

int &x{ y = 5 };

यहाँ एक प्रदर्शन कार्यक्रम है

#include <iostream>

int main() 
{
    int y;
    int &x{ y = 5 };    

    std::cout << "y = " << y << '\n';

    x = 10;

    std::cout << "y = " << y << '\n';
}

इसका आउटपुट है

y = 5
y = 10

आप यह घोषणा कर सकते हैं

int x{ y = 5 };

फिर से लिखना भी पसंद करते हैं

int x = { y = 5 };

हालाँकि इस बात पर ध्यान दें कि इन दोनों के बीच अंतर है (उपरोक्त घोषणाओं के समान ही) दो घोषणाएँ।

auto x{ y = 5 };

तथा

auto x = { y = 5 };

पहली घोषणा में चर x का प्रकार int । दूसरी घोषणा में चर x का प्रकार std::initializer_list<int>

अंतर को अधिक दृश्यमान बनाने के लिए देखें कि वस्तुओं के मूल्यों का उत्पादन कैसे किया जाता है।

#include <iostream>

int main() 
{
    int y;
    auto x1 { y = 5 };  

    std::cout << "x1 = " << x1 << '\n';

    auto x2 = { y = 10 };   

    std::cout << "*x2.begin()= " << *x2.begin() << '\n';

    std::cout << "y = " << y << '\n';

    return 0;
}

कार्यक्रम का आउटपुट है

x1 = 5
*x2.begin()= 10
y = 10

operator=() एक मूल्य में परिणाम करता है, जो कि चर को सौंपा गया मूल्य है। इस वजह से, इस तरह से चेन असाइनमेंट करना संभव है:

int x, y, z;
x = y = z = 1;





assignment-operator