कुछ सामान्य मामले जहां मूल्यांकन आदेश अभी तक अनिर्दिष्ट है , के साथ निर्दिष्ट और मान्य हैं C++17। कुछ अपरिभाषित व्यवहार अब अनिर्दिष्ट है।
i = 1;
f(i++, i)
अपरिभाषित था, लेकिन अब अनिर्दिष्ट है। विशेष रूप से, जो निर्दिष्ट नहीं है वह वह क्रम है जिसमें प्रत्येक तर्क fका दूसरों के सापेक्ष मूल्यांकन किया जाता है। i++पहले iया इसके विपरीत मूल्यांकन किया जा सकता है । वास्तव में, यह एक ही संकलक के अधीन होने के बावजूद एक अलग क्रम में दूसरी कॉल का मूल्यांकन कर सकता है।
हालांकि, प्रत्येक तर्क के मूल्यांकन को किसी भी अन्य तर्क के निष्पादन से पहले, सभी दुष्प्रभावों के साथ, पूरी तरह से निष्पादित करने की आवश्यकता होती है। तो आपको मिल सकता है f(1, 1)(दूसरे तर्क का मूल्यांकन पहले) या f(1, 2)(पहले तर्क का मूल्यांकन पहले)। लेकिन आपको कभी f(2, 2)भी या उस प्रकृति का कुछ भी नहीं मिलेगा ।
std::cout << f() << f() << f();
अनिर्दिष्ट था, लेकिन यह ऑपरेटर की पूर्वता के साथ संगत हो जाएगा ताकि fधारा का पहला मूल्यांकन पहली बार (नीचे उदाहरण में) आएगा।
f(g(), h(), j());
अभी भी जी, एच, और जे के अनिर्दिष्ट मूल्यांकन आदेश है। ध्यान दें कि getf()(g(),h(),j()), नियमों का getf()मूल्यांकन पहले किया जाएगा g, h, j।
प्रस्ताव पाठ से निम्नलिखित उदाहरण पर भी ध्यान दें:
std::string s = "but I have heard it works even if you don't believe in it"
s.replace(0, 4, "").replace(s.find("even"), 4, "only")
.replace(s.find(" don't"), 6, "");
इसका उदाहरण द C ++ प्रोग्रामिंग लैंग्वेज , 4th एडिशन, स्ट्रॉस्ट्रुप, और अनिर्दिष्ट व्यवहार के रूप में आता है, लेकिन C ++ 17 के साथ यह उम्मीद के मुताबिक काम करेगा। पुन: प्रयोज्य कार्यों ( .then( . . . )) के साथ इसी तरह के मुद्दे थे ।
एक अन्य उदाहरण के रूप में, निम्नलिखित पर विचार करें:
#include <iostream>
#include <string>
#include <vector>
#include <cassert>
struct Speaker{
int i =0;
Speaker(std::vector<std::string> words) :words(words) {}
std::vector<std::string> words;
std::string operator()(){
assert(words.size()>0);
if(i==words.size()) i=0;
auto word = words[i] + (i+1==words.size()?"\n":",");
++i;
return word;
}
};
int main() {
auto spk = Speaker{{"All", "Work", "and", "no", "play"}};
std::cout << spk() << spk() << spk() << spk() << spk() ;
}
C ++ 14 के साथ और इससे पहले कि हम (और करेंगे) इस तरह के परिणाम प्राप्त करेंगे
play
no,and,Work,All,
के बजाय
All,work,and,no,play
ध्यान दें कि ऊपर जैसा प्रभाव है
(((((std::cout << spk()) << spk()) << spk()) << spk()) << spk()) ;
लेकिन फिर भी, C ++ 17 से पहले कोई गारंटी नहीं थी कि पहली कॉल स्ट्रीम में पहले आएगी।
संदर्भ: स्वीकृत प्रस्ताव से :
उपसर्ग अभिव्यक्तियों का मूल्यांकन बाएं से दाएं किया जाता है। इसमें फ़ंक्शन कॉल और सदस्य चयन अभिव्यक्तियाँ शामिल हैं।
असाइनमेंट अभिव्यक्तियों का मूल्यांकन दाईं से बाईं ओर किया जाता है। इसमें कंपाउंड असाइनमेंट शामिल हैं।
ऑपरेटर्स को शिफ्ट करने वाले ऑपरेटरों का मूल्यांकन बाएं से दाएं किया जाता है। सारांश में, निम्नलिखित अभिव्यक्तियों का मूल्यांकन क्रम में किया जाता है a, फिर b, c, फिर d:
- अब
- a-> ख
- एक -> * ख
- ए (बी १, बी २, बी ३)
- b @ = a
- एक [ख]
- a << b
- एक >> बी
इसके अलावा, हम निम्नलिखित अतिरिक्त नियम का सुझाव देते हैं: एक अधिभार ऑपरेटर को शामिल करने वाली अभिव्यक्ति के मूल्यांकन का क्रम संबंधित बिल्ट-इन ऑपरेटर से जुड़े आदेश से निर्धारित होता है, न कि फ़ंक्शन कॉल के लिए नियम।
नोट संपादित करें: मेरा मूल उत्तर गलत व्याख्या किया गया है a(b1, b2, b3)। के आदेश b1, b2, b3अभी भी अनिर्दिष्ट है। (साभार @KABoissonneault, सभी टिप्पणीकार।)
हालांकि, (@Yakk बताते हैं) और यह महत्वपूर्ण है: यहां तक कि जब b1, b2, b3, गैर तुच्छ अभिव्यक्ति कर रहे हैं उनमें से प्रत्येक पूरी तरह से मूल्यांकन किया जाता है और संबंधित समारोह पैरामीटर से बंधा अन्य लोगों का मूल्यांकन किया जाना शुरू कर रहे हैं इससे पहले कि। मानक इस प्रकार बताता है:
§5.2.2 - फंक्शन कॉल 5.2.2.4:
। । । अभिव्यक्ति-सूची और किसी भी डिफ़ॉल्ट तर्क में प्रत्येक अभिव्यक्ति से पहले उपसर्ग-अभिव्यक्ति अनुक्रमित है। हर मान संगणना और साइड इफेक्ट एक पैरामीटर के आरंभीकरण के साथ जुड़ा हुआ है, और खुद को इनिशियलाइज़ेशन, किसी भी बाद के पैरामीटर के आरंभीकरण के साथ जुड़े हर मूल्य गणना और साइड इफेक्ट से पहले अनुक्रमित किया जाता है।
हालाँकि, इन नए वाक्यों में से एक GitHub ड्राफ्ट से गायब है :
हर मान संगणना और साइड इफेक्ट एक पैरामीटर के आरंभीकरण के साथ जुड़ा हुआ है, और खुद को इनिशियलाइज़ेशन, किसी भी बाद के पैरामीटर के आरंभीकरण के साथ जुड़े हर मूल्य गणना और साइड इफेक्ट से पहले अनुक्रमित किया जाता है।
इसका उदाहरण है । यह अपवाद की सुरक्षा के साथ दशकों पुरानी समस्याओं ( हर्ब सटर द्वारा बताई गई ) को हल करता है जहां चीजें पसंद हैं
f(std::unique_ptr<A> a, std::unique_ptr<B> b);
f(get_raw_a(), get_raw_a());
अगर कोई कॉल get_raw_a()दूसरे कच्चे पॉइंटर को उसके स्मार्ट पॉइंटर पैरामीटर से बांधने से पहले फेंक देगा तो लीक हो जाएगी।
जैसा कि टीसी द्वारा बताया गया है, उदाहरण के लिए त्रुटिपूर्ण है क्योंकि यूनिक_प्ट्र कच्चे संकेतक से निर्माण स्पष्ट है, जिससे इसे संकलित होने से रोका जा सके। *
इस शास्त्रीय प्रश्न पर भी ध्यान दें ( C को टैग नहीं, C ++ ):
int x=0;
x++ + ++x;
अभी भी अपरिभाषित है।