सी ++ 17: "फोल्ड" अवधारणा में "कास्ट के नीचे प्राथमिकता के साथ ऑपरेटर" का क्या अर्थ है?

Question

http://en.cppreference.com/w/cpp/language/fold की वेबसाइट कैसे गुना अवधारणा का उपयोग करने का एक उदाहरण देता है, और यह कहते हैं:

एक गैर देशी अंग्रेजी वक्ता के रूप में, मैं सजा पाने छोड़ने नहीं है:

has an operator with precedence below cast at the top level 

इसका वास्तव में क्या अर्थ है, और यह उदाहरण है, यह क्या इंगित करता है? क्या आप इसे समझाने में मदद कर सकते हैं?

बहुत बहुत धन्यवाद।

Answer 1

कास्टिंग ऑपरेटर ((Typename)expr) C++'s operator precedence rules में एक बहुत ही उच्च पूर्वता है। बहुत कम ऑपरेटरों की तुलना में अधिक प्राथमिकता है। कास्ट स्तर या अधिक प्राथमिकता के ऑपरेटर बहुत ही विशेष ऑपरेशन होते हैं, आमतौर पर एक अभिव्यक्ति के लिए आवेदन करते हैं।

अभिव्यक्ति में args + ... + 1 * 2, ... बाएं और दाएं दोनों पर लागू होता है। लेकिन "दाहिने ओर" वास्तव में क्या मतलब है? यह सिर्फ + 1 हिस्सा मतलब यह है, या यह + 1 * 2 मतलब है?

उच्च पूर्वता के साथ ऑपरेटरों के मामले में, यह स्पष्ट है क्या आशय है। उदाहरण के लिए, args + ... + func() के लिए, यह स्पष्ट है कि () समारोह कॉल ऑपरेटर func और args + ... + func के लिए नहीं करने के लिए लागू होता है। ऐसा नहीं है कि आप बाद कि आप कोष्ठक स्पष्ट रूप से अगर तुमने किया था ((args + ... + func)()) का उपयोग करने के लिए मजबूर कर रहे हैं चाहते हो जाएगा तो संभावना नहीं है।

हालांकि चार्ट में 3 नीचे पूर्वता के स्तर के लिए, चीजों को और अधिक बादल लोगों को समझने के लिए हो गया है। तो सामान्य प्राथमिकता नियमों का उपयोग करने के बजाय, सी ++ उपयोगकर्ता को इसके बारे में स्पष्ट होने के लिए मजबूर करता है। आपके पास args + ... + (1 * 2) या (args + ... + 1) * 2 हो सकता है। लेकिन आपको यह स्पष्ट करना होगा कि आप कौन सी चाहते हैं।

Answer 2

इसका मतलब है कि यदि कई ऑपरेटरों के साथ एक अभिव्यक्ति संदिग्ध है, तो ऑपरेटर जो "उपरोक्त" हैं, उन्हें कास्ट ऑपरेटर से पहले बुलाया जाएगा, और ऑपरेटर जो "नीचे कास्ट" हैं, को कास्ट ऑपरेटर के बाद बुलाया जाएगा। 2 + 2 * 2 गुणन में के रूप में 6 जिसके परिणामस्वरूप इसके पहले निष्पादित किया जाना चाहिए, नहीं, बल्कि 8.

चलो निम्नलिखित दो वर्गों जो एक दूसरे के castable हैं पर विचार करें:

class E2; 

class E1 { 
public: 

    operator E2(); 

    E1 operator++(int) { 
    std::cout << "E1 Post-inc\n"; 
    return *this; 
    } 

    E1 operator*(const E1&) { 
    std::cout << "E1 * E1\n"; 
    return *this; 
    } 
}; 

class E2 { 
public: 

    operator E1() { 
    std::cout << "Cast E1 -> E2\n"; 
    return E1(); 
    } 

    E2 operator++(int) { 
    std::cout << "E2 Post-inc\n"; 
    return *this; 
    } 

    E2 operator*(const E2&) { 
    std::cout << "E2 * E2\n"; 
    return *this; 
    } 
}; 

E1::operator E2() { 
    std::cout << "Cast E2 -> E1\n"; 
    return E2(); 
} 

तब के घोषित करते

E1 e1; 
E2 e2; 

और

(E1)e2++; 

ई 1 और ई 2 दोनों ऑपरेटिंग हैं या ++, तो इस अभिव्यक्ति में पहले क्या किया जाना चाहिए: कास्ट या वृद्धि? Precedence table जवाब है कि बढ़ाने के पहले किया जाना चाहिए, ताकि कार्यक्रम प्रिंट

E2 Post-inc 
Cast E1 -> E2 

फिर, के एक अधिक जटिल उदाहरण की कोशिश करते हैं:

e1 * (E1)e2++; 

यहाँ हम 3 क्रिया (कोड में उनकी उपस्थिति के क्रम में) है : गुणा, कास्ट और वृद्धि। अगर निष्पादन होगा तो क्या होगा?प्राथमिकता तालिका का कहना है कि वृद्धि पहले है, कास्ट दूसरा है (यह वृद्धि के नीचे है) और गुणा अंतिम है, क्योंकि यह दोनों के नीचे है। तो उत्पादन होगा:

E2 Post-inc 
Cast E1 -> E2 
E1 * E1 

ध्यान दें कि आप आसानी से संचालन कोष्ठकों का उपयोग क्रम बदल सकते हैं। उदाहरण के लिए, अगर हम बदलने के e1 * (E1)e2++;(e1 * (E1)e2)++; के साथ, हम

Cast E1 -> E2 
E1 * E1 
E1 Post-inc