🥃 🚒 🚡 कोड लिखने के लिए कैसे नहीं 🔮 🏢 🥅

प्रोग्रामिंग की बहादुर दुनिया में सिर के बल गोता लगाने के लिए तैयार हैं? देखना चाहते हैं कि कोड की कुछ सरल रेखाएं अप्रत्याशित रूप से कैसे व्यवहार कर सकती हैं?

अगर आपका जवाब "हाँ!" - बिल्ली का स्वागत है।

आपको C या C ++ में कई मनोरंजक कार्य मिलेंगे।

एक स्पष्टीकरण के साथ सही उत्तर हमेशा बिगाड़ने वाले के नीचे छिपा होगा।

सौभाग्य है

सबसे छोटे कार्यक्रम के बारे में

main;

यदि आप इस प्रोग्राम को C भाषा संकलक के साथ संकलित करते हैं तो क्या होता है?

संकलित नहीं।
लिंक नहीं किया गया।
संकलित और जुड़ा हुआ।

उत्तर है:

यह मान्य सी कोड है।
क्यों? सी में, आप रिटर्न प्रकार के कार्यों को छोड़ सकते हैं और जब चर घोषित करते हैं, तो डिफ़ॉल्ट रूप से यह इंट होगा। और सी में भी लिंकिंग के दौरान कार्यों और वैश्विक चर के बीच कोई अंतर नहीं है। इस मामले में, लिंक करने वाला सोचता है कि नाम के तहत मुख्य एक फ़ंक्शन है।

कांटा के बारे में

 #include <iostream> #include <unistd.h> int main() { for(auto i = 0; i < 1000; i++) std::cout << "Hello world!\n"; fork(); }

हैलो वर्ल्ड कितनी बार होगा!

1000
कम
बड़ा

उत्तर है:

प्रदर्शन में सुधार करने के लिए IO संचालन को बफ़र किया जाता है।
फोर्किंग fork() कॉलिंग एक नई प्रक्रिया को कॉपी-ऑन-राइट डुप्लिकेट एड्रेस स्पेस के साथ करेगी।
प्रत्येक प्रक्रिया में बफ़र्ड लाइनें मुद्रित की जाएंगी।

अनुक्रमित के बारे में

 #include <iostream> int main() { int array[] = { 1, 2, 3 }; std::cout << (4, (1, 2)[array]) << std::endl; }

यह कोड क्या छपेगा?

1
2
3
4
संकलन त्रुटि
मानक द्वारा परिभाषित नहीं।

उत्तर है:

पोरग्राम प्रिंट ३।
ऐसा क्यों?
सबसे पहले, सूचकांक को देखें: array[index] == *(array + index) == *(index + array) == index[array]
अगला, हम एक बाइनरी कॉमा ऑपरेटर के साथ काम कर रहे हैं। यह अपने बाएं तर्क को छोड़ देता है और दाईं ओर का मान लौटाता है।

रेगेक्स के बारे में

 #include <regex> #include <iostream> int main() { std::regex re { "(.*|.*)*O" }; std::string str { "0123456789" }; std::cout << std::regex_match(str, re); return 0; }

इस नियमित सीजन में न्यूनतम समय क्या होगा?

~ 1 मि।
~ 100 मि।
~ 1 सेकंड।
~ 1 मि
~ 1 घंटा
~ 1 वर्ष।
अब ब्रह्मांड जीवन

उत्तर है:

हा-हा! जिसका अनुमान नहीं है। संकलक पर निर्भर करता है।
मेरे लैपटॉप पर, क्लैंग लगभग 100 एमएस का परिणाम दिखाता है।
जीसीसी 57 सेकंड! एक मिनट! सच में!
ऐसा क्यों?
नियमित अभिव्यक्ति को लागू करने के लिए 2 दृष्टिकोण हैं।
एक नियमित अभिव्यक्ति को O(n**2) में एक राज्य मशीन में बदलना है, लंबाई एन अक्षर की एक नियमित अभिव्यक्ति के लिए।
मीटर वर्णों की स्ट्रिंग के साथ मिलान की कठिनाई O(m) । इस तरह की एक नियमित अभिव्यक्ति बैकट्रैकिंग का समर्थन नहीं करती है।
दूसरी गहराई खोज के साथ एक लालची खोज का एक सा है। समर्थन करता है।
और फिर भी, एसटीएल में नियमित अभिव्यक्ति के संचालन की जटिलता बिल्कुल भी परिभाषित नहीं है। यह अच्छा है कि उन्होंने इसे एक मिनट में प्रबंधित किया।

चाल और मेमने के बारे में

 #include <iostream> struct Foo { Foo() { std::cout << "Foo()\n"; } Foo(Foo&&) { std::cout << "Foo(Foo&&)\n"; } Foo(const Foo&) { std::cout << "Foo(const Foo&)\n"; } }; int main() { Foo f; auto a = [f = std::move(f)]() { return std::move(f); }; Foo f2(a()); return 0; }

प्रोग्राम किस लाइन पर प्रिंट करता है?

Foo()
Foo(Foo&&)
Foo(const Foo&)

उत्तर है:

Foo(const Foo&) । डिफ़ॉल्ट रूप से, लैम्ब्डा प्रतिरक्षा हैं। [] में निर्दिष्ट सभी मूल्यों के लिए const जोड़ा const ।
यह लैम्ब्डा को सामान्य कार्यों की तरह व्यवहार करने की अनुमति देता है। समान तर्क के लिए, समान मान लौटाएं।
इस मामले में क्या होता है? जब हम किसी फंक्शन से मूव f बनाने की कोशिश करते हैं, तो हम const Foo&& प्राप्त करते हैं।
यह एक बहुत ही अजीब बात है, संकलक को पता नहीं है कि इसके साथ कैसे काम किया जाए और Foo कॉपी किया जाए। आप इसे एक परिवर्तनशील लंबोदर घोषित करके ठीक कर सकते हैं:

 auto a = [f = std::move(f)]() mutable { return std::move(f); };

या Foo(const Foo&&) से एक कंस्ट्रक्टर बनाएं।

एक्स और बार के बारे में

 #include <iostream> int x = 0; int bar(int(x)); int main() { std::cout << bar; }

यदि आप इसे संकलित करने और चलाने की कोशिश करते हैं तो क्या होता है?

0 प्रिंट करेगा
1 छपेगा
0x0 प्रिंट करेगा
संकलित नहीं
लिंक नहीं किया गया

उत्तर है:

कार्यक्रम 1 प्रिंट होगा।
ऐसा क्यों?
int bar(int(x)); एक फ़ंक्शन घोषणा है, यह int bar(int x); बराबर है int bar(int x); ।
यदि आप एक टाइप कास्ट चाहते हैं, तो आपको इस int bar((int(x))); तरह लिखना होगा int bar((int(x))); ।
फिर हम फ़ंक्शन के पते को आउटपुट करने की कोशिश करते हैं, यह स्पष्ट रूप से बूल को डाली जाएगी, फ़ंक्शन का पता शून्य नहीं हो सकता है, अर्थात। true ।
bar() फ़ंक्शन का उपयोग नहीं किया जाता है। इसलिए, जब लिंक करना कोई अप्रतिबंधित प्रतीक नहीं होगा।

इनलाइन के बारे में

 #include <iostream> inline size_t factorial(size_t n) { if (n == 0) return 1; return n * factorial(n - 1); } int main() { std::cout << factorial(5) << std::endl; }

कार्यक्रम इस g++ -c main.cpp -o main.o && g++ foo.cpp -o foo.o && g++ foo.o main.o -o test तरह त्रुटियों के बिना संकलन और लिंक करता है। इसे चलाने से क्या होता है?

120 छपेगा।
कुछ भी हो सकता है।

उत्तर है:

कुछ भी हो सकता है। यह C ++ है।
इनलाइन शब्द में सभी कैच। यह केवल संकलक के लिए एक संकेत है।
यह बस इस फ़ंक्शन को ऑब्जेक्ट फ़ाइल में संकलित कर सकता है (सबसे अधिक संभावना है, यह पुनरावर्ती कार्यों के लिए ऐसा करेगा)।
लिंकर इनलाइन फ़ंक्शंस के डुप्लिकेट्स को बाहर फेंक सकता है जो कोड में निर्मित नहीं हैं।
परिणाम फ़ाइल जो आमतौर पर पहली फ़ाइल में दिखाई देती है वह वह है जो पहली ऑब्जेक्ट फ़ाइल में मिली थी।
अगर foo.cpp में प्रोग्राम 0 प्रिंट करेगा:

 #include <cstddef> inline size_t factorial(size_t n) { if (n == 0) return 0; return 2 * n * factorial(n - 1); } int foo(size_t n) { return factorial(n); }

डिजाइनरों के बारे में

 #include <iostream> struct Foo { Foo() { std::cout << "Foo()\n"; } Foo(const Foo&) { std::cout << "Foo(const Foo&)\n"; } Foo(int) { std::cout << "Foo(int)\n"; } Foo(int, int) { std::cout << "Foo(int, int)\n"; } Foo(const Foo&, int) { std::cout << "Foo(const Foo&, int)\n"; } Foo(int, const Foo&) { std::cout << "Foo(int, const Foo&)\n"; } }; void f(Foo) {} struct Bar { int i, j; Bar() { f(Foo(i, j)); f(Foo(i)); Foo(i, j); Foo(i); Foo(i, j); } }; int main() { Bar(); }

कौन सी लाइन अंतिम छपेगी?

Foo(int, int)
Foo(const Foo&, int)
Foo(int, const Foo&)
Foo(int)

उत्तर है:

अंतिम पंक्ति Foo(const Foo&, int) ।
Foo(i) एक चर की घोषणा है, यह Foo i बराबर है, जिसका अर्थ है कि कक्षा i का क्षेत्र कार्यक्षेत्र से गायब हो जाएगा।

निष्कर्ष

आशा है कि आप इसे वास्तविक कोड में कभी नहीं देख पाएंगे।

कोड लिखने के लिए कैसे नहीं

सबसे छोटे कार्यक्रम के बारे में

कांटा के बारे में

अनुक्रमित के बारे में

रेगेक्स के बारे में

चाल और मेमने के बारे में

एक्स और बार के बारे में

इनलाइन के बारे में

डिजाइनरों के बारे में

निष्कर्ष

More articles: