दिलचस्प पोस्ट
पायथन: गुणन ओवरराइड क्या यह सी फ़िशर-येट्स फेरबदल सही है? जावा अर्रे लिस्ट की प्रतिलिपि स्विफ्ट में आवश्यक तर्क लेबल कब हैं? time.sleep – थ्रेड या प्रक्रिया सोता है? रोटेशन एंड्रॉइड पर गतिविधि पुनः आरंभ क्या ऐंजरीआरजेएस को आंशिक रूप से शुरू करने के लिए कोई रास्ता नहीं है और जब आवश्यक हो? टूटी यूटीएफ 8 एन्कोडिंग फिक्सिंग java runtime.getruntime () कमांड लाइन प्रोग्राम निष्पादित करने से आउटपुट प्राप्त कर रहा है UIButton छवि + पाठ IOS LINQ लैम्ब्डा में कई तालिकाओं के बीच जुड़ने के लिए कैसे करें एक एकल SQL क्वेरी में एकाधिक पंक्तियाँ डालना? एक दृश्य का निर्माण करने के लिए '*' का प्रयोग क्यों करना बुरा है? PHP में सीएसवी फ़ाइल से डेटा कैसे निकालें Windows पर स्पार्क कैसे सेट अप करें?

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

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


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

  • सी के main() फ़ंक्शन के लिए मान्य हस्ताक्षर क्या हैं?
  • main() प्रकार का वापसी main() फ़ंक्शन
  • void main() बीच अंतर void main() और int main() ?
  • सी ++ में main() के हस्ताक्षर
  • main() की उचित घोषणा क्या है? – सी ++ के लिए, वाकई बहुत ही अच्छे उत्तर के साथ।
  • सी में main() फ़ंक्शंस की शैलियाँ
  • सी में main() विधि का वापसी प्रकार
  • int main() बनाम void main() सी में

सम्बंधित:

  • सी ++ – int main(int argc, char **argv)
  • सी ++ – int main(int argc, char *argv[])
  • क्या char *envp[] main() पोर्टेबल के लिए तीसरे तर्क के रूप में char *envp[] ?
  • क्या int main() फ़ंक्शन सभी कंपाइलर्स में एक मान लौटाएगा?
  • सी और सी ++ में main() फ़ंक्शन का प्रकार उपयोगकर्ता को परिभाषित करने के लिए क्यों छोड़ दिया जाता है?
  • क्यों int main(){} संकलन करता है?
  • सी ++ 14 में main() की कानूनी परिभाषाएं?

वेब के समाधान से एकत्रित समाधान "सी (सी) और सी ++ में मुख्य () क्या रिटर्न चाहिए?"

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

 int main() 

तथा

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

जो कि के बराबर है

 int main(int argc, char** argv) 

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

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

स्वीकृत उत्तर को सी ++ के लिए लक्षित किया गया लगता है, इसलिए मैंने सोचा कि मैं सी से संबंधित एक जवाब जोड़ूंगा, और यह कुछ तरीकों से अलग है

आईएसओ / आईईसी 9899: 1989 (सी 90):

main() को या तो घोषित किया जाना चाहिए:

 int main(void) int main(int argc, char **argv) 

या उसके बराबर। उदाहरण के लिए, int main(int argc, char *argv[]) दूसरा एक के बराबर है इसके अलावा, int रिटर्न प्रकार को छोड़ा जा सकता है क्योंकि यह एक डिफ़ॉल्ट है

यदि कोई क्रियान्वयन इस परमिट करता है, तो main() को अन्य तरीकों से घोषित किया जा सकता है, लेकिन यह प्रोग्राम कार्यान्वयन को परिभाषित करता है, और अब कड़ाई से अनुरूप नहीं है।

मानक वापसी के लिए 3 मान को परिभाषित करता है जो सख्ती से अनुरूप हैं (अर्थात, कार्यान्वयन परिभाषित व्यवहार पर निर्भर नहीं होता है): 0 और एक सफल समापन के लिए EXIT_FAILURE , और एक असफल समाप्ति के लिए EXIT_FAILURE । कोई भी अन्य मान गैर मानक और कार्यान्वयन परिभाषित हैं main() अन्तर्निहित व्यवहार से बचने के लिए अंत में एक स्पष्ट return स्टेटमेंट होना चाहिए।

अंत में, एक कार्यक्रम से main() कॉल करने के साथ-साथ मानक मानदंड से कुछ भी गलत नहीं है

आईएसओ / आईईसी 9899: 1 999 (सी 99):

C99 के लिए, सब कुछ ऊपर के समान है:

  • int रिटर्न टाइप को छोड़ा नहीं जा सकता।
  • आप main() से रिटर्न स्टेटमेंट को रद्द कर सकते हैं। यदि आप करते हैं, और main() समाप्त हो जाते हैं, तो एक निहित return 0

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

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

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

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

    अनुमतियां 1 :

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

    टिप्पणियाँ:

    पूर्व दो को स्पष्ट रूप से स्वीकृत रूपों के रूप में कहा गया है, दूसरों को निहित रूप से अनुमति दी जाती है क्योंकि सी 90 ने वापसी प्रकार और फ़ंक्शन मापदंडों के लिए "निहित इंट" की अनुमति दी थी। किसी अन्य रूप की अनुमति नहीं है

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

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

  • C99 ने पर्यावरण का आयोजन किया

    अनुमत रूप 3 :

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

    टिप्पणियाँ:

    C99 ने "निहित इंट" हटा दिया है, इसलिए main() अब मान्य नहीं है।

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

    कुछ कंपलर्स ने बाद के रास्ते में मानक की व्याख्या करने के लिए चुना है। बेशक, कोई आसानी से यह स्पष्ट नहीं कर सकता कि वे अपने आप में मानक का हवाला देते हुए कड़ाई से अनुरूप नहीं हैं, क्योंकि यह अस्पष्ट है

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

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

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

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

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

    स्वीकृत रूपों 7 :

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

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


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

6.11.6 समारोह घोषणाकर्ता

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


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

    अनुमत रूप 9 :

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

    टिप्पणियाँ:

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

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

    स्टार्टअप पर कॉल किया गया फ़ंक्शन का नाम कार्यान्वयन-परिभाषित है यदि इसे मुख्य नाम दिया गया है तो उसे प्रपत्रों का पालन करना चाहिए 10 :

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

    अनुमत रूप 11 :

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

    टिप्पणियाँ:

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

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

    स्टार्टअप पर कॉल किया गया फ़ंक्शन का नाम कार्यान्वयन-परिभाषित है यदि इसे मुख्य नाम दिया गया है, तो उसे प्रपत्रों का पालन करना चाहिए 12 :

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

संदर्भ

  1. एएनएसआई X3.159-198 9 2.1.2.2 होस्टेड वातावरण "प्रोग्राम स्टार्टअप"

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

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

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

     int main(int argc, char *argv[]) { /* ... */ } 
  2. एएनएसआई X3.159-198 9 2.1.2.1 वातावरण का पर्यावरण:

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

  3. आईएसओ 9899: 1 99 5.1.2.2 होस्टेड पर्यावरण -> 5.1.2.2.1 कार्यक्रम स्टार्टअप

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

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

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

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

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

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

    आर्गव्स स्ट्रिंग्स के प्रतिनिधित्व में कुछ अवांछित विविधता को रोकने के लिए और मुख्य द्वारा लौटाए जाने वाले मूल्यों के अर्थ में मुख्य और अस्थायी (आविष्कार), मुख्य और अस्थायी (देखें §7.20.4.2) के आर्गुमेंट के व्यवहार को संहिताबद्ध किया गया है।

    मुख्य से तर्क के रूप में argc और argv का विवरण व्यापक पूर्व अभ्यास को पहचानता है। argv [argc] को सूची के अंत के लिए एक बेमानी जांच प्रदान करने के लिए एक रिक्त सूचक होना आवश्यक है, आम अभ्यास के आधार पर भी।

    मुख्य एकमात्र ऐसा कार्य है जो पोर्टेबल रूप से शून्य या दो तर्क के साथ घोषित किया जा सकता है (अन्य फ़ंक्शन के तर्कों को आवंटन और परिभाषा के बीच बिल्कुल सटीक होना चाहिए।) यह विशेष मामला केवल मुख्य तर्क को छोड़ने के व्यापक अभ्यास को स्वीकार करता है, जब प्रोग्राम प्रोग्राम तर्क स्ट्रिंग्स तक नहीं पहुंचता है। हालांकि कई कार्यान्वयन मुख्य रूप से दो से अधिक तर्कों का समर्थन करते हैं, लेकिन इस तरह के अभ्यास न तो धन्य हैं और न ही मानक द्वारा निषिद्ध है; एक ऐसा कार्यक्रम जो मुख्य रूप से तीन तर्कों के साथ परिभाषित करता है, कड़ाई से अनुरूप नहीं है (§J.5.1 देखें।)

  5. आईएसओ 9899: 1 99 5.1.2.2 होस्टेड पर्यावरण -> 5.1.2.2.3 कार्यक्रम समाप्ति

    मुख्य फ़ंक्शन का रिटर्न प्रकार इंट के साथ संगत एक प्रकार है, प्रारंभिक कॉल से मुख्य फ़ंक्शन पर रिटर्न मुख्य कार्य द्वारा लौटा मूल्य के साथ बाहर निकलने के फ़ंक्शन को कॉल करने के बराबर है; 11) तक पहुँचने से मुख्य कार्य समाप्त करता है, 0 का मान देता है। यदि वापसी का प्रकार int के साथ संगत नहीं है, तो मेजबान वातावरण में समाप्ति की स्थिति अनिर्दिष्ट है।

  6. आईएसओ 9899: 1999 5.1.2.1 फ्रीस्टैंडिंग पर्यावरण

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

  7. आईएसओ 9899: 2011 5.1.2.2 होस्ट किया गया पर्यावरण -> 5.1.2.2.1 कार्यक्रम स्टार्टअप

    यह खंड ऊपर उल्लेखित C99 के समान है।

  8. आईएसओ 9899: 1999 5.1.2.1 फ्रीस्टैंडिंग पर्यावरण

    यह खंड ऊपर उल्लेखित C99 के समान है।

  9. आईएसओ 14882: 2003 3.6.1 मुख्य फ़ंक्शन

    कार्यान्वयन मुख्य फ़ंक्शन को पूर्वनिर्धारित नहीं करेगा। यह फ़ंक्शन अतिभारित नहीं होगा। 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.

Keep in mind that,even though you're returning an int, some OSes (Windows) truncate the returned value to a single byte (0-255).

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() then the closing { will return 0 by default

  2. Return 0 or return 1 will be received by the environment variable of the OS. So if you are not using that environment variable then you should 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 environment variable $? which receives the last one byte of return value of main() .

So if you are writing any script then you should take care of the return value of main() , otherwise don't.

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.

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.

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.

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; .. }

If you really have issues related to efficiency of returning an integer from a process, you should probably avoid to call that process so many times that this return value becomes an issue.

If you are doing this (call a process so many times), you should find a way to put your logic directly inside the caller, or in a DLL file, without allocate a specific process for each call; the multiple process allocations bring you the relevant efficiency problem in this case.

In detail, if you only want to know if returning 0 is more or less efficient than returning 1, it could depend from the compiler in some cases, but generically, assuming they are read from the same source (local, field, constant, embedded in the code, function result, etc.) it requires exactly the same number of clock cycles.

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.

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

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) .

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()).

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.

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.

void main() is forbidden after C90. main should return a value. I used to return 0.