c++ मुख्य() सी और सी++ में वापस क्या होना चाहिए?




return-value main (16)

main लिए वापसी मूल्य इंगित करना चाहिए कि कार्यक्रम कैसे निकला। सामान्य निकास आम तौर पर main से 0 वापसी मूल्य द्वारा दर्शाया जाता है। असामान्य समाप्ति आमतौर पर गैर-शून्य रिटर्न द्वारा संकेतित होती है लेकिन गैर-शून्य कोडों के व्याख्या के लिए कोई मानक नहीं है। जैसा कि दूसरों द्वारा नोट किया गया है, void main() को सी ++ मानक द्वारा स्पष्ट रूप से प्रतिबंधित किया गया है और इसका उपयोग नहीं किया जाना चाहिए। मान्य सी ++ main हस्ताक्षर हैं:

int main()

तथा

int main(int argc, char* argv[])

जो बराबर है

int main(int argc, char** argv)

यह ध्यान देने योग्य भी है कि सी ++ में, int main() को रिटर्न वैल्यू के बिना छोड़ा जा सकता है जिस बिंदु पर यह 0 लौटने के लिए डिफ़ॉल्ट होता है। यह एक सी 99 प्रोग्राम के साथ भी सच है। चाहे वापसी 0 छोड़ा जाना चाहिए या बहस के लिए खुला नहीं है। वैध सी प्रोग्राम मुख्य हस्ताक्षर की सीमा बहुत अधिक है।

इसके अलावा, main कार्य के साथ दक्षता कोई समस्या नहीं है। सी ++ मानक के अनुसार इसे केवल एक बार दर्ज किया जा सकता है (प्रोग्राम शुरू करना और समाप्ति)। सी के लिए, मामला अलग है और main() प्रवेश main() की अनुमति है, लेकिन शायद इससे बचा जाना चाहिए।

सी main() सी ++ - int main() या void main() - और क्यों में main() फ़ंक्शन को परिभाषित करने के लिए सही (सबसे प्रभावी) तरीका क्या है? यदि int main() तो return 1 return 0 या return 0 ?

इस प्रश्न के कई डुप्लिकेट हैं, जिनमें निम्न शामिल हैं:

सम्बंधित:


Omit return 0

When a C or C++ program reaches the end of main the compiler will automatically generate code to return 0, so there is no need to put return 0; explicitly at the end of main .

Note: when I make this suggestion, it's almost invariably followed by one of two kinds of comments: "I didn't know that." or "That's bad advice!" My rationale is that it's safe and useful to rely on compiler behavior explicitly supported by the standard. For C, since C99; see ISO/IEC 9899:1999 section 5.1.2.2.3:

[...] a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument; reaching the } that terminates the main function returns a value of 0.

For C++, since the first standard in 1998; see ISO/IEC 14882:1998 section 3.6.1:

If control reaches the end of main without encountering a return statement, the effect is that of executing return 0;

All versions of both standards since then (C99 and C++98) have maintained the same idea. We rely on automatically generated member functions in C++, and few people write explicit return; statements at the end of a void function. Reasons against omitting seem to boil down to "it looks weird" . If, like me, you're curious about the rationale for the change to the C standard read this question . Also note that in the early 1990s this was considered "sloppy practice" because it was undefined behavior (although widely supported) at the time.

So I advocate omitting it; others disagree (often vehemently!) In any case, if you encounter code that omits it, you'll know that it's explicitly supported by the standard and you'll know what it means.


The return value of main() shows how the program exited. If the return value is zero it means that the execution was successful while any non-zero value will represent that something went bad in the execution.


Here is a small demonstration of the usage of return codes...

When using the various tools that the Linux terminal provides one can use the return code for example for error handling after the process has been completed. Imagine that the following text file myfile is present:

This is some example in order to check how grep works.

When you execute the grep command a process is created. Once it is through (and didn't break) it returns some code between 0 and 255. For example:

$ grep order myfile

If you do

$ echo $?
$ 0

you will get a 0. Why? Because grep found a match and returned an exit code 0, which is the usual value for exiting with a success. Let's check it out again but with something that is not inside our text file and thus no match will be found:

$ grep foo myfile
$ echo $?
$ 1

Since grep failed to match the token "foo" with the content of our file the return code is 1 (this is the usual case when a failure occurs but as stated above you have plenty of values to choose from).

Now the following bash script (simply type it in a Linux terminal) although very basic should give some idea of error handling:

$ grep foo myfile
$ CHECK=$?
$ [ $CHECK -eq 0] && echo 'Match found'
$ [ $CHECK -ne 0] && echo 'No match was found'
$ No match was found

After the second line nothing is printed to the terminal since "foo" made grep return 1 and we check if the return code of grep was equal to 0. The second conditional statement echoes its message in the last line since it is true due to CHECK == 1.

As you can see if you are calling this and that process it is sometimes essential to see what it has returned (by the return value of main()).


Returning 0 should tell the programmer that the program has successfully finished the job.


What to return depends on what you want to do with the executable. For example if you are using your program with a command line shell, then you need to return 0 for a success and a non zero for failure. Then you would be able to use the program in shells with conditional processing depending on the outcome of your code. Also you can assign any nonzero value as per your interpretation, for example for critical errors different program exit points could terminate a program with different exit values , and which is available to the calling shell which can decide what to do by inspecting the value returned. If the code is not intended for use with shells and the returned value does not bother anybody then it might be omitted. I personally use the signature int main (void) { .. return 0; .. }


त्रुटि के लिए सफलता और शून्य के लिए शून्य पर वापसी 0। यह आपके मानक के साथ क्या हुआ यह जानने के लिए यूनिक्स और डॉस स्क्रिप्टिंग द्वारा उपयोग किया जाने वाला मानक है।


मानक सी - होस्टेड पर्यावरण

एक होस्टेड वातावरण (यह सामान्य है) के लिए, सी 11 मानक (आईएसओ / आईईसी 98 99: 2011) कहता है:

5.1.2.2.1 कार्यक्रम स्टार्टअप

कार्यक्रम स्टार्टअप में बुलाया गया समारोह main नाम दिया गया है। कार्यान्वयन इस समारोह के लिए कोई प्रोटोटाइप घोषित नहीं करता है। इसे एक प्रकार के int साथ परिभाषित किया जाएगा और बिना पैरामीटर के:

int main(void) { /* ... */ }

या दो पैरामीटर के साथ (यहां argc और argv रूप में संदर्भित किया गया है, हालांकि किसी भी नाम का उपयोग किया जा सकता है, क्योंकि वे उस फ़ंक्शन के लिए स्थानीय हैं, जिसमें उन्हें घोषित किया गया है):

int main(int argc, char *argv[]) { /* ... */ }

या उसके बराबर; 10) या कुछ अन्य कार्यान्वयन-परिभाषित तरीके से।

यदि उन्हें घोषित किया जाता है, तो मुख्य कार्य के पैरामीटर निम्नलिखित बाधाओं का पालन करेंगे:

  • argc का मान nonnegative होगा।
  • argv[argc] एक शून्य सूचक होगा।
  • यदि argc का मान शून्य से बड़ा है, तो सरणी सदस्य argv[0] argv[argc-1] समावेशी के माध्यम से स्ट्रिंग्स में पॉइंटर्स होंगे, जिन्हें प्रोग्राम स्टार्टअप से पहले होस्ट वातावरण द्वारा कार्यान्वयन-परिभाषित मान दिए जाते हैं। इसका उद्देश्य होस्टेड वातावरण में कहीं और से प्रोग्राम स्टार्टअप से पहले निर्धारित प्रोग्राम जानकारी को आपूर्ति करना है। यदि मेजबान वातावरण दोनों अपरकेस और लोअरकेस में अक्षरों के साथ तारों की आपूर्ति करने में सक्षम नहीं है, तो कार्यान्वयन सुनिश्चित करेगा कि तारों को लोअरकेस में प्राप्त किया जाता है।
  • यदि argc का मान शून्य से बड़ा है, तो argv[0] द्वारा इंगित स्ट्रिंग प्रोग्राम नाम का प्रतिनिधित्व करती है; argv[0][0] शून्य नाम होगा यदि प्रोग्राम का नाम मेजबान वातावरण से उपलब्ध नहीं है। यदि argc का मान एक से अधिक है, तो argv[argc-1] argv[1] द्वारा argv[argc-1] argv[1] द्वारा इंगित तार argv[argc-1] प्रोग्राम पैरामीटर का प्रतिनिधित्व करते हैं।
  • पैरामीटर argc और argv और argv सरणी द्वारा इंगित तारों को प्रोग्राम द्वारा संशोधित किया जाएगा, और प्रोग्राम स्टार्टअप और प्रोग्राम समाप्ति के बीच अपने अंतिम संग्रहीत मूल्यों को बनाए रखा जाएगा।

10) इस प्रकार, int को int टाइप के रूप में परिभाषित टाइपिफ़ नाम द्वारा प्रतिस्थापित किया जा सकता है, या argv के प्रकार को char **argv रूप में लिखा जा सकता है, और इसी तरह।

सी 99 या सी 11 में कार्यक्रम समाप्ति

main() से लौटाए गए मान को कार्यान्वयन-परिभाषित तरीके से 'पर्यावरण' में प्रेषित किया जाता है।

5.1.2.2.3 कार्यक्रम समाप्ति

1 यदि main फ़ंक्शन का रिटर्न प्रकार int के साथ संगत प्रकार है, तो प्रारंभिक कॉल से main फ़ंक्शन पर वापसी main कार्य द्वारा लौटाए गए मान के साथ exit फ़ंक्शन को कॉल करने के बराबर होती है; 11) main कार्य को समाप्त करने वाले } तक पहुंचने से 0 का मान मिलता है। यदि वापसी का प्रकार int के साथ संगत नहीं है, तो होस्ट वातावरण में लौटाई गई समाप्ति स्थिति निर्दिष्ट नहीं है।

11) 6.2.4 के अनुसार, main भंडारण अवधि में घोषित स्वचालित भंडारण अवधि वाले ऑब्जेक्ट्स का जीवनकाल पूर्व मामले में समाप्त हो गया है, यहां तक ​​कि जहां बाद में वे नहीं होंगे।

ध्यान दें कि 0 को 'सफलता' के रूप में अनिवार्य है। यदि आप चाहें तो EXIT_FAILURE और EXIT_SUCCESS <stdlib.h> से उपयोग कर सकते हैं, लेकिन 0 अच्छी तरह से स्थापित है, और ऐसा ही है 1. 255 से अधिक कोड से बाहर निकलें कोड भी देखें ?

सी 8 9 (और इसलिए माइक्रोसॉफ्ट सी में) में, इस बारे में कोई बयान नहीं है कि क्या होता है यदि main() फ़ंक्शन रिटर्न करता है लेकिन रिटर्न वैल्यू निर्दिष्ट नहीं करता है; इसलिए यह अपरिभाषित व्यवहार की ओर जाता है।

7.22.4.4 exit समारोह

¶5 अंत में, मेजबान वातावरण में नियंत्रण वापस कर दिया जाता है। यदि status का मान शून्य या EXIT_SUCCESS , तो स्थिति का कार्यान्वयन-परिभाषित रूप सफल समाप्ति वापस कर दिया जाता है। यदि status का मान EXIT_FAILURE , तो असफल समाप्ति की स्थिति का कार्यान्वयन-परिभाषित रूप वापस कर दिया जाता है। अन्यथा वापस लौटाई गई स्थिति कार्यान्वयन-परिभाषित है।

मानक सी ++ - होस्टेड पर्यावरण

सी ++ 11 मानक (आईएसओ / आईईसी 14882: 2011) कहता है:

3.6.1 मुख्य समारोह [basic.start.main]

¶1 एक कार्यक्रम में मुख्य नामक वैश्विक कार्य शामिल होगा, जो प्रोग्राम की नामित शुरुआत है। [...]

¶2 एक कार्यान्वयन मुख्य समारोह को पूर्वनिर्धारित नहीं करेगा। यह फ़ंक्शन ओवरलोड नहीं किया जाएगा। इसमें एक प्रकार का प्रकार int int होगा, लेकिन अन्यथा इसका प्रकार कार्यान्वयन परिभाषित किया गया है। सभी कार्यान्वयन मुख्य की निम्नलिखित परिभाषाओं दोनों की अनुमति देंगे:

int main() { /* ... */ }

तथा

int main(int argc, char* argv[]) { /* ... */ }

बाद के रूप में argc कार्यक्रम से पारित तर्कों की संख्या होगी जिसमें कार्यक्रम चलाया जाता है। अगर argc nonzero है तो इन तर्कों को argv[0] माध्यम से argv[argc-1] argv[0] माध्यम से null-terminated multibyte तारों (NTMBSs) (17.5.2.1.4.2) के प्रारंभिक वर्णों के लिए पॉइंटर्स के रूप में प्रदान किया जाएगा और argv[0] होगा एनटीएमबीएस के शुरुआती चरित्र के लिए सूचक जो प्रोग्राम का आह्वान करने के लिए इस्तेमाल किए गए नाम का प्रतिनिधित्व करता है या ""argc का मान गैर-नकारात्मक होगा। argv[argc] का मान 0 होगा। [नोट: यह अनुशंसा की जाती है कि argv बाद कोई और (वैकल्पिक) पैरामीटर जोड़ा जाए। नोट नोट]

¶3 फ़ंक्शन main उपयोग किसी प्रोग्राम के भीतर नहीं किया जाएगा। main का लिंक (3.5) कार्यान्वयन-परिभाषित है। [...]

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

return 0;

सी ++ मानक स्पष्ट रूप से कहता है "यह [मुख्य कार्य] में एक प्रकार का प्रकार int , लेकिन अन्यथा इसका प्रकार कार्यान्वयन परिभाषित किया गया है", और सी मानक को विकल्पों के रूप में समर्थित करने के लिए समान दो हस्ताक्षर की आवश्यकता होती है। इसलिए सी ++ मानक द्वारा 'शून्य मुख्य ()' की अनुमति नहीं है, हालांकि गैर-मानक कार्यान्वयन विकल्पों को रोकने के लिए ऐसा कुछ भी नहीं हो सकता है। ध्यान दें कि C ++ उपयोगकर्ता को main कॉल करने से मना करता है (लेकिन सी मानक नहीं है)।

§18.5 का अनुच्छेद सी ++ 11 मानक में प्रारंभ और समाप्ति है जो §7.22.4.4 से अनुच्छेद के समान है, एक फुटनोट के अलावा सी 11 मानक (ऊपर उद्धृत) में exit कार्य (जो केवल EXIT_SUCCESS और EXIT_FAILURE को <cstdlib> में परिभाषित किया गया है)।

मानक सी - सामान्य विस्तार

क्लासिकल, यूनिक्स सिस्टम तीसरे संस्करण का समर्थन करते हैं:

int main(int argc, char **argv, char **envp) { ... }

तीसरा तर्क स्ट्रिंग्स के पॉइंटर्स की एक नल-टर्मिनेटेड सूची है, जिनमें से प्रत्येक एक पर्यावरण चर है जिसमें एक नाम, एक बराबर चिह्न है, और एक मूल्य (संभवतः खाली) है। यदि आप इसका उपयोग नहीं करते हैं, तो भी आप ' extern char **environ; माध्यम से पर्यावरण पर पहुंच सकते हैं extern char **environ; '। लंबे समय तक, उसमें कोई हेडर नहीं था जिसने इसे घोषित किया था, लेकिन POSIX 2008 मानक अब इसे <unistd.h> में घोषित करने की आवश्यकता है।

यह सी मानक द्वारा एक सामान्य विस्तार के रूप में मान्यता प्राप्त है, अनुलग्नक जे में प्रलेखित:

जे.5.1 पर्यावरण तर्क

¶1 एक होस्टेड वातावरण में, मुख्य फ़ंक्शन को तीसरा तर्क प्राप्त होता है, char *envp[] , जो बिंदुओं के पॉइंटर्स की एक नल-टर्मिनेटेड सरणी को इंगित करता है, जिनमें से प्रत्येक स्ट्रिंग को इंगित करता है जो इस निष्पादन के लिए पर्यावरण के बारे में जानकारी प्रदान करता है कार्यक्रम का (5.1.2.2.1)।

माइक्रोसॉफ्ट सी

माइक्रोसॉफ्ट वीएस 2010 कंपाइलर दिलचस्प है। वेबसाइट कहती है:

मुख्य के लिए घोषणा वाक्यविन्यास है

 int main();

या, वैकल्पिक रूप से,

int main(int argc, char *argv[], char *envp[]);

वैकल्पिक रूप से, main और wmain कार्यों को लौटा void (कोई वापसी मूल्य) के रूप में घोषित किया जा सकता है। यदि आप शून्य या wmain रूप में main या wmain घोषित करते हैं, तो आप रिटर्न स्टेटमेंट का उपयोग कर मूल प्रक्रिया या ऑपरेटिंग सिस्टम में निकास कोड वापस नहीं कर सकते हैं। main या wmain void रूप में घोषित होने पर निकास कोड वापस करने के लिए, आपको exit फ़ंक्शन का उपयोग करना होगा।

यह स्पष्ट नहीं है कि क्या होता है (माता-पिता या ओएस में क्या निकास कोड वापस किया जाता है) जब void main() से बाहर निकलने वाला प्रोग्राम बाहर निकलता है - और एमएस वेब साइट भी चुप है।

दिलचस्प बात यह है कि एमएस main() के दो-तर्क संस्करण को निर्धारित नहीं करता है कि सी और सी ++ मानकों की आवश्यकता होती है। यह केवल एक तीन तर्क फार्म निर्धारित करता है जहां तीसरा तर्क char **envp , जो पर्यावरण चर की सूची में एक सूचक है।

माइक्रोसॉफ्ट पेज में कुछ अन्य विकल्प भी सूचीबद्ध हैं - wmain() जो विस्तृत चरित्र तार लेता है, और कुछ और।

इस पृष्ठ का माइक्रोसॉफ्ट Visual Studio 2005 संस्करण void main() को वैकल्पिक विकल्प के रूप में सूचीबद्ध नहीं करता है। माइक्रोसॉफ्ट Visual Studio 2008 बाद के versions करते हैं।

मानक सी - फ्रीस्टैंडिंग पर्यावरण

जैसा कि पहले उल्लेख किया गया है, ऊपर दी गई आवश्यकताओं को होस्टेड वातावरण पर लागू होते हैं। यदि आप एक फ्रीस्टैंडिंग पर्यावरण (जो एक होस्टेड पर्यावरण का विकल्प है) के साथ काम कर रहे हैं, तो मानक कहने के लिए बहुत कम है। एक फ्रीस्टैंडिंग पर्यावरण के लिए, प्रोग्राम स्टार्टअप पर बुलाए गए फ़ंक्शन को main नहीं कहा जाना चाहिए और इसके रिटर्न प्रकार पर कोई बाधा नहीं है। मानक कहता है:

5.1.2 निष्पादन वातावरण

दो निष्पादन वातावरण परिभाषित किए गए हैं: फ्रीस्टैंडिंग और होस्टेड। दोनों मामलों में, प्रोग्राम स्टार्टअप तब होता है जब निष्पादित वातावरण द्वारा नामित सी फ़ंक्शन को कॉल किया जाता है। स्थिर स्टोरेज अवधि के साथ सभी ऑब्जेक्ट्स प्रोग्राम स्टार्टअप से पहले प्रारंभ किए जाएंगे (उनके प्रारंभिक मानों पर सेट करें)। इस तरह के प्रारंभिकरण का तरीका और समय अन्यथा निर्दिष्ट नहीं है। कार्यक्रम समाप्ति निष्पादन पर्यावरण पर नियंत्रण देता है।

5.1.2.1 फ्रीस्टैंडिंग पर्यावरण

एक फ्रीस्टैंडिंग वातावरण में (जिसमें सी प्रोग्राम निष्पादन किसी ऑपरेटिंग सिस्टम के किसी भी लाभ के बिना हो सकता है), कार्यक्रम स्टार्टअप में बुलाए गए फ़ंक्शन का नाम और प्रकार कार्यान्वयन-परिभाषित है। क्लॉज 4 द्वारा आवश्यक न्यूनतम सेट के अलावा, फ्रीस्टैंडिंग प्रोग्राम के लिए उपलब्ध कोई लाइब्रेरी सुविधाएं कार्यान्वयन-परिभाषित हैं।

एक फ्रीस्टैंडिंग पर्यावरण में कार्यक्रम समाप्ति का प्रभाव कार्यान्वयन-परिभाषित है।

खंड 4 अनुरूपता का पार संदर्भ इस प्रकार है:

¶5 सख्ती से अनुरूप कार्यक्रम इस अंतर्राष्ट्रीय मानक में निर्दिष्ट भाषा और पुस्तकालय की केवल उन विशेषताओं का उपयोग करेगा। 3) यह उत्पादन को किसी भी निर्दिष्ट, अपरिभाषित, या कार्यान्वयन-परिभाषित व्यवहार पर निर्भर नहीं करेगा, और न्यूनतम कार्यान्वयन सीमा से अधिक नहीं होगा।

¶6 कार्यान्वयन के दो रूपों की मेजबानी और फ्रीस्टैंडिंग की मेजबानी की जाती है। एक अनुरूप मेजबान कार्यान्वयन किसी भी सख्ती से अनुरूप कार्यक्रम स्वीकार करेगा। एक अनुरूप फ्रीस्टैंडिंग कार्यान्वयन किसी सख्ती से अनुरूप कार्यक्रम को स्वीकार करेगा जिसमें पुस्तकालय खंड (खंड 7) में निर्दिष्ट सुविधाओं का उपयोग मानक शीर्षकों <float.h> , <iso646.h> , <limits.h> की सामग्री तक ही सीमित <limits.h> , <stdalign.h> , <stdarg.h> , <stdbool.h> , <stddef.h> , <stdint.h> , और <stdnoreturn.h> । एक अनुरूप कार्यान्वयन में एक्सटेंशन (अतिरिक्त लाइब्रेरी फ़ंक्शंस सहित) हो सकते हैं, बशर्ते वे किसी सख्ती से अनुरूप प्रोग्राम के व्यवहार को परिवर्तित न करें। 4)

¶7 एक अनुरूप कार्यक्रम वह है जो एक अनुरूप कार्यान्वयन के लिए स्वीकार्य है। 5)

3) सख्ती से अनुरूप कार्यक्रम सशर्त विशेषताओं का उपयोग कर सकते हैं (6.10.8.3 देखें) बशर्ते उपयोग संबंधित मैक्रो का उपयोग कर उपयुक्त सशर्त समावेशन प्रीप्रोकैसिंग निर्देश द्वारा संरक्षित किया जाए। उदाहरण के लिए:

#ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
    /* ... */
    fesetround(FE_UPWARD);
    /* ... */
#endif

4) इसका तात्पर्य यह है कि एक अनुरूप कार्यान्वयन इस अंतर्राष्ट्रीय मानक में स्पष्ट रूप से आरक्षित लोगों के अलावा कोई पहचानकर्ता नहीं रखता है।

5) कड़ाई से अनुरूप कार्यक्रमों को कार्यान्वयन के अनुरूप अधिकतम पोर्टेबल होने का इरादा है। अनुरूप कार्यक्रम एक अनुरूप कार्यान्वयन की गैर-पोर्टेबल सुविधाओं पर निर्भर हो सकते हैं।

यह ध्यान देने योग्य है कि एक फ्रीस्टैंडिंग वातावरण की आवश्यकता वाला एकमात्र हेडर जो वास्तव में किसी भी फ़ंक्शन को परिभाषित करता है <stdarg.h> (और यहां तक ​​कि वे हो सकते हैं - और अक्सर - मैक्रोज़)।

मानक सी ++ - फ्रीस्टैंडिंग पर्यावरण

जैसे सी मानक दोनों होस्टेड और फ्रीस्टैंडिंग वातावरण को पहचानता है, वैसे ही सी ++ मानक भी होता है। (आईएसओ / आईईसी 14882: 2011 से उद्धरण।)

1.4 कार्यान्वयन अनुपालन [intro.compliance]

¶7 दो प्रकार के कार्यान्वयन परिभाषित किए गए हैं: एक होस्टेड कार्यान्वयन और एक फ्रीस्टैंडिंग कार्यान्वयन । एक होस्टेड कार्यान्वयन के लिए, यह अंतर्राष्ट्रीय मानक उपलब्ध पुस्तकालयों के सेट को परिभाषित करता है। एक फ्रीस्टैंडिंग कार्यान्वयन एक ऐसा होता है जिसमें एक ऑपरेटिंग सिस्टम के लाभ के बिना निष्पादन हो सकता है, और पुस्तकालयों के कार्यान्वयन-निर्धारित सेट में कुछ भाषा-समर्थन पुस्तकालय (17.6.1.3) शामिल हैं।

¶8 एक अनुरूप कार्यान्वयन में एक्सटेंशन (अतिरिक्त लाइब्रेरी फ़ंक्शंस सहित) हो सकते हैं, बशर्ते वे किसी भी अच्छी तरह से गठित कार्यक्रम के व्यवहार को परिवर्तित न करें। इस अंतर्राष्ट्रीय मानक के अनुसार बीमार गठित ऐसे एक्सटेंशन का उपयोग करने वाले कार्यक्रमों का निदान करने के लिए कार्यान्वयन की आवश्यकता है। ऐसा करने के बाद, वे इस तरह के कार्यक्रमों को संकलित और निष्पादित कर सकते हैं।

¶ 9 प्रत्येक कार्यान्वयन में दस्तावेज शामिल होगा जो सभी सशर्त रूप से समर्थित संरचनाओं की पहचान करता है जो यह सभी लोकेल-विशिष्ट विशेषताओं का समर्थन और परिभाषित नहीं करता है। 3

3) यह दस्तावेज कार्यान्वयन-परिभाषित व्यवहार को भी परिभाषित करता है; 1.9 देखें।

17.6.1.3 फ्रीस्टैंडिंग कार्यान्वयन [अनुपालन]

दो प्रकार के कार्यान्वयन परिभाषित किए गए हैं: होस्टेड और फ्रीस्टैंडिंग (1.4)। एक होस्टेड कार्यान्वयन के लिए, यह अंतर्राष्ट्रीय मानक उपलब्ध हेडर के सेट का वर्णन करता है।

एक फ्रीस्टैंडिंग कार्यान्वयन में हेडर के कार्यान्वयन-निर्धारित सेट होते हैं। इस सेट में तालिका 16 में दिखाए गए कम से कम शीर्षलेख शामिल होंगे।

शीर्षलेख <cstdlib> दिए गए संस्करण कम से कम कार्यों को abort at_quick_exit , at_quick_exit , at_quick_exit , exit , और quick_exit (18.5)। इस तालिका में सूचीबद्ध अन्य शीर्षलेख एक होस्टेड कार्यान्वयन के लिए समान आवश्यकताओं को पूरा करेंगे।

तालिका 16 - फ्रीस्टैंडिंग कार्यान्वयन के लिए सी ++ शीर्षलेख

Subclause                           Header(s)
                                    <ciso646>
18.2  Types                         <cstddef>
18.3  Implementation properties     <cfloat> <limits> <climits>
18.4  Integer types                 <cstdint>
18.5  Start and termination         <cstdlib>
18.6  Dynamic memory management     <new>
18.7  Type identification           <typeinfo>
18.8  Exception handling            <exception>
18.9  Initializer lists             <initializer_list>
18.10 Other runtime support         <cstdalign> <cstdarg> <cstdbool>
20.9  Type traits                   <type_traits>
29    Atomics                       <atomic>

सी में int main() का उपयोग करने के बारे में क्या?

सी 11 मानक का मानक §5.1.2.2.1 पसंदीदा नोटेशन - int main(void) दिखाता है - लेकिन मानक में दो उदाहरण भी हैं जो int main() : §6.5.3.4 ¶8 और §6.7.6.3 दिखाते हैं ¶20 । अब, यह ध्यान रखना महत्वपूर्ण है कि उदाहरण 'मानक' नहीं हैं; वे केवल दृष्टांत हैं। यदि उदाहरणों में बग हैं, तो वे मानक के मुख्य पाठ को सीधे प्रभावित नहीं करते हैं। उन्होंने कहा, वे अपेक्षित व्यवहार के दृढ़ता से संकेतक हैं, इसलिए यदि मानक में int main() शामिल है, तो यह सुझाव देता है कि int main() को प्रतिबंधित नहीं किया गया है, भले ही यह पसंदीदा नोटेशन न हो।

_Alignof sizeof और _Alignof ऑपरेटरों

...

¶8 उदाहरण 3 इस उदाहरण में, एक चर लंबाई लंबाई सरणी का आकार गणना की जाती है और फ़ंक्शन से लौटा दी जाती है:

#include <stddef.h>

size_t fsize3(int n)
{
    char b[n+3]; // variable length array
    return sizeof b; // execution time sizeof
}
int main()
{
    size_t size;
    size = fsize3(10); // fsize3 returns 13
    return 0;
}

main() in C89 and K&R C unspecified return types default to 'int`.

return 1? return 0?
  1. If you do not write a return statement in int main() , the closing { will return 0 by default.

  2. return 0 or return 1 will be received by the parent process. In a shell it goes into a shell variable, and if you are running your program form a shell and not using that variable then you need not worry about the return value of main() .

See How can I get what my main function has returned? ।

$ ./a.out
$ echo $?

This way you can see that it is the variable $? which receives the least significant byte of the return value of main() .

In Unix and DOS scripting, return 0 on success and non-zero for error are usually returned. This is the standard used by Unix and DOS scripting to find out what happened with your program and controlling the whole flow.


What is the correct (most efficient) way to define the main() function in C and C++ — int main() or void main() — and why?

Those words "(most efficient)" don't change the question. Unless you're in a freestanding environment, there is one universally correct way to declare main() , and that's as returning int.

What should main() return in C and C++?

It's not what should main() return, it's what does main() return. main() is, of course, a function that someone else calls. You don't have any control over the code that calls main() . Therefore, you must declare main() with a type-correct signature to match its caller. You simply don't have any choice in the matter. You don't have to ask yourself what's more or less efficient, or what's better or worse style, or anything like that, because the answer is already perfectly well defined, for you, by the C and C+ standards. Just follow them.

If int main() then return 1 or return 0?

0 for success, nonzero for failure. Again, not something you need to (or get to) pick: it's defined by the interface you're supposed to be conforming to.


This basically depends on your execution environment (the OS). C implies that it will be run by a UNIX like OS which expects the program to return a (small? 1 Byte? can't remember) integer to indicate success / failure.

You should probably just use int main(int argc, char** argv) .


I was under the impression that standard specifies that main doesn't need a return value as a successful return was OS based (zero in one could be either a success or a failure in another), therefore the absence of return was a cue for the compiler to insert the successful return itself.

However I usually return 0.


The return value can be used by the operating system to check how the program was closed.

Return value 0 usually means OK in most operating systems (the ones I can think of anyway).

It also can be checked when you call a process yourself, and see if the program exited and finished properly.

It's NOT just a programming convention.


ध्यान दें कि सी और सी ++ मानक दो प्रकार के कार्यान्वयन को परिभाषित करते हैं: फ्रीस्टैंडिंग और होस्टेड।

  • सी 0 9 पर्यावरण का आयोजन किया

    अनुमत रूप 1 :

    int main (void)
    int main (int argc, char *argv[])
    
    main (void)
    main (int argc, char *argv[])
    /*... etc, similar forms with implicit int */
    

    टिप्पणियाँ:

    पूर्व दो को स्पष्ट रूप से अनुमत रूपों के रूप में वर्णित किया गया है, अन्य लोगों को निस्संदेह अनुमति दी गई है क्योंकि सी 9 0 ने रिटर्न प्रकार और फ़ंक्शन पैरामीटर के लिए "अंतर्निहित int" की अनुमति दी है। कोई अन्य रूप की अनुमति नहीं है।

  • सी 9 0 फ्रीस्टैंडिंग पर्यावरण

    मुख्य रूप से किसी भी रूप या नाम की अनुमति है 2

  • सी 99 ने पर्यावरण की मेजबानी की

    अनुमत रूप 3 :

    int main (void)
    int main (int argc, char *argv[])
    /* or in some other implementation-defined manner. */
    

    टिप्पणियाँ:

    सी 99 "अंतर्निहित int" हटा दिया गया है इसलिए main() अब मान्य नहीं है।

    एक अजीब, संदिग्ध वाक्य "या कुछ अन्य कार्यान्वयन-परिभाषित तरीके से" पेश किया गया है। इसका अर्थ या तो " int main() के पैरामीटर भिन्न हो सकते हैं" या "मुख्य रूप से कोई कार्यान्वयन-परिभाषित फ़ॉर्म हो सकता है" के रूप में व्याख्या किया जा सकता है।

    कुछ कंप्यूटर्स ने बाद में मानक की व्याख्या करना चुना है। तर्कसंगत रूप से, कोई आसानी से यह नहीं कह सकता कि वे मानक को उद्धृत करके सख्ती से अनुरूप नहीं हैं, क्योंकि यह संदिग्ध है।

    हालांकि, main() पूरी तरह से जंगली रूपों को अनुमति देने के लिए शायद (?) इस नई वाक्य का इरादा नहीं था। सी 99 तर्क (मानक नहीं) का तात्पर्य है कि वाक्य int main 4 के लिए अतिरिक्त पैरामीटर को संदर्भित करता है।

    फिर भी होस्टेड पर्यावरण कार्यक्रम की समाप्ति के लिए अनुभाग उस मामले के बारे में बहस करता है जहां मुख्य int 5 वापस नहीं आता है। यद्यपि यह अनुभाग मानक कैसे घोषित किया जाना चाहिए इसके लिए मानक नहीं है, यह निश्चित रूप से तात्पर्य है कि मेजबान सिस्टम पर भी पूरी तरह कार्यान्वयन-परिभाषित तरीके से मुख्य घोषित किया जा सकता है।

  • सी 99 फ्रीस्टैंडिंग पर्यावरण

    मुख्य रूप से किसी भी रूप या नाम की अनुमति है 6

  • सी 11 होस्टेड पर्यावरण

    अनुमत रूप 7 :

    int main (void)
    int main (int argc, char *argv[])
    /* or in some other implementation-defined manner. */
    
  • सी 11 फ्रीस्टैंडिंग पर्यावरण

    मुख्य रूप से किसी भी रूप या नाम की अनुमति है 8

ध्यान दें कि int main() को उपर्युक्त संस्करणों में से किसी भी सी में किसी भी होस्ट किए गए कार्यान्वयन के लिए वैध रूप के रूप में सूचीबद्ध नहीं किया गया था। सी में, सी ++, () और (void) विपरीत अलग-अलग अर्थ हैं। पूर्व एक अश्लील विशेषता है जिसे भाषा से हटाया जा सकता है। सी 11 भविष्य की भाषा दिशाएं देखें:

6.11.6 फंक्शन घोषणाकर्ता

खाली कोष्ठक के साथ फ़ंक्शन घोषणाकर्ताओं का उपयोग (प्रोटोटाइप-प्रारूप पैरामीटर प्रकार घोषणाकर्ता नहीं) एक अश्लील सुविधा है।

  • सी ++ 03 होस्टेड वातावरण

    अनुमत रूप 9 :

    int main ()
    int main (int argc, char *argv[])
    

    टिप्पणियाँ:

    पहले फॉर्म में खाली कोष्ठक नोट करें। सी ++ और सी इस मामले में अलग हैं, क्योंकि सी ++ में इसका मतलब है कि फ़ंक्शन में कोई पैरामीटर नहीं है। लेकिन सी में इसका मतलब है कि यह कोई पैरामीटर ले सकता है।

  • सी ++ 03 फ्रीस्टैंडिंग पर्यावरण

    स्टार्टअप पर बुलाए गए फ़ंक्शन का नाम कार्यान्वयन-परिभाषित है। यदि इसे main() नाम दिया गया है main() इसे निर्दिष्ट रूपों का पालन करना होगा 10 :

    // implementation-defined name, or 
    int main ()
    int main (int argc, char *argv[])
    
  • सी ++ 11 होस्टेड वातावरण

    अनुमत रूप 11 :

    int main ()
    int main (int argc, char *argv[])
    

    टिप्पणियाँ:

    मानक का पाठ बदल दिया गया है लेकिन इसका एक ही अर्थ है।

  • सी ++ 11 फ्रीस्टैंडिंग पर्यावरण

    स्टार्टअप पर बुलाए गए फ़ंक्शन का नाम कार्यान्वयन-परिभाषित है। यदि इसे main() नाम दिया गया है main() इसे निर्दिष्ट रूपों का पालन करना होगा 12 :

    // implementation-defined name, or 
    int main ()
    int main (int argc, char *argv[])
    

संदर्भ

  1. एएनएसआई एक्स 3.159-1989 2.1.2.2 होस्टेड वातावरण। "कार्यक्रम स्टार्टअप"

    कार्यक्रम स्टार्टअप में बुलाया गया समारोह मुख्य नाम दिया गया है। कार्यान्वयन इस समारोह के लिए कोई प्रोटोटाइप घोषित नहीं करता है। इसे एक प्रकार के int के साथ परिभाषित किया जाएगा और बिना पैरामीटर के:

    int main(void) { /* ... */ } 
    

    या दो पैरामीटर के साथ (यहां argc और argv के रूप में संदर्भित किया गया है, हालांकि किसी भी नाम का उपयोग किया जा सकता है, क्योंकि वे उस फ़ंक्शन के लिए स्थानीय हैं, जिसमें उन्हें घोषित किया गया है):

    int main(int argc, char *argv[]) { /* ... */ }
    
  2. एएनएसआई एक्स 3.159-1989 2.1.2.1 फ्रीस्टैंडिंग पर्यावरण:

    एक फ्रीस्टैंडिंग वातावरण में (जिसमें सी प्रोग्राम निष्पादन किसी ऑपरेटिंग सिस्टम के किसी भी लाभ के बिना हो सकता है), कार्यक्रम स्टार्टअप में बुलाए गए फ़ंक्शन का नाम और प्रकार कार्यान्वयन-परिभाषित है।

  3. आईएसओ 98 99: 1 999 5.1.2.2 होस्टेड वातावरण -> 5.1.2.2.1 प्रोग्राम स्टार्टअप

    कार्यक्रम स्टार्टअप में बुलाया गया समारोह मुख्य नाम दिया गया है। कार्यान्वयन इस समारोह के लिए कोई प्रोटोटाइप घोषित नहीं करता है। इसे एक प्रकार के int के साथ परिभाषित किया जाएगा और बिना पैरामीटर के:

    int main(void) { /* ... */ } 
    

    या दो पैरामीटर के साथ (यहां argc और argv के रूप में संदर्भित किया गया है, हालांकि किसी भी नाम का उपयोग किया जा सकता है, क्योंकि वे उस फ़ंक्शन के लिए स्थानीय हैं, जिसमें उन्हें घोषित किया गया है):

    int main(int argc, char *argv[]) { /* ... */ }
    

    या समकक्ष; 9) या कुछ अन्य कार्यान्वयन-परिभाषित तरीके से।

  4. अंतर्राष्ट्रीय मानक के लिए तर्क - प्रोग्रामिंग भाषाएं - सी, संशोधन 5.10। 5.1.2.2 होस्टेड वातावरण -> 5.1.2.2.1 प्रोग्राम स्टार्टअप

    The behavior of the arguments to main, and of the interaction of exit, main and atexit (see §7.20.4.2) has been codified to curb some unwanted variety in the representation of argv strings, and in the meaning of values returned by main.

    The specification of argc and argv as arguments to main recognizes extensive prior practice. argv[argc] is required to be a null pointer to provide a redundant check for the end of the list, also on the basis of common practice.

    main is the only function that may portably be declared either with zero or two arguments. (The number of other functions' arguments must match exactly between invocation and definition.) This special case simply recognizes the widespread practice of leaving off the arguments to main when the program does not access the program argument strings. While many implementations support more than two arguments to main, such practice is neither blessed nor forbidden by the Standard; a program that defines main with three arguments is not strictly conforming (see §J.5.1.).

  5. ISO 9899:1999 5.1.2.2 Hosted environment --> 5.1.2.2.3 Program termination

    If the return type of the main function is a type compatible with int, a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument;11) reaching the } that terminates the main function returns a value of 0. If the return type is not compatible with int, the termination status returned to the host environment is unspecified.

  6. ISO 9899:1999 5.1.2.1 Freestanding environment

    In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined.

  7. ISO 9899:2011 5.1.2.2 Hosted environment -> 5.1.2.2.1 Program startup

    This section is identical to the C99 one cited above.

  8. ISO 9899:1999 5.1.2.1 Freestanding environment

    This section is identical to the C99 one cited above.

  9. ISO 14882:2003 3.6.1 Main function

    An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main:

    int main() { /* ... */ }
    

    तथा

    int main(int argc, char* argv[]) { /* ... */ }
    
  10. ISO 14882:2003 3.6.1 Main function

    It is implementation-defined whether a program in a freestanding environment is required to define a main function.

  11. ISO 14882:2011 3.6.1 Main function

    An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both

    — a function of () returning int and

    — a function of (int, pointer to pointer to char) returning int

    as the type of main (8.3.5).

  12. ISO 14882:2011 3.6.1 Main function

    This section is identical to the C++03 one cited above.


In C++ the main function should be declared as int main() and not void main() as the compiler then throws an error in the case of void main. The main function can take any number of arguments like int main(int k,int l,int arr[]) or int main(void).

#include <iostream>
using namespace std;

int main(void) {
    // your code goes here
    cout<<"a";
    return 0;
}

आउटपुट:

Success #stdin #stdout 0s 4416KB
a

Coming to the return part it should return only 0 else the compiler throws an error. for example if you return 1,you will get the desired output but it also throws a runtime error.

उदाहरण

#include <iostream>
using namespace std;

int main(int k,float m,char g, int arr[]) {
    // your code goes here
    k=0;
    cout<<k;
    g='a';
    cout<<g;
    cout<<"a";
    return 1;
}

आउटपुट:

Runtime error   #stdin #stdout 0s 4448KB
0aa

मेरा मानना ​​है कि main() को EXIT_SUCCESS या EXIT_FAILURE वापस करना चाहिए। वे stdlib.h में परिभाषित हैं





return-type