C++C ++ से शुरुआत करना


टिप्पणियों

'हैलो वर्ल्ड' कार्यक्रम एक सामान्य उदाहरण है जिसका उपयोग केवल संकलक और पुस्तकालय की उपस्थिति की जांच के लिए किया जा सकता है। यह C ++ मानक लाइब्रेरी का उपयोग करता है, जिसमें std::cout from <iostream> , और संकलन के दौरान संभावित उपयोगकर्ता त्रुटि की संभावना को कम करने के लिए केवल एक फ़ाइल है।


C ++ प्रोग्राम को संकलित करने की प्रक्रिया स्वाभाविक रूप से संकलक और ऑपरेटिंग सिस्टम के बीच भिन्न होती है। संकलन और बिल्डिंग विषय में विभिन्न कंपाइलरों के लिए विभिन्न प्लेटफार्मों पर C ++ कोड को संकलित करने के तरीके के बारे में विवरण शामिल हैं।

संस्करण

संस्करण मानक रिलीज़ की तारीख
सी ++ 98 आईएसओ / आईईसी 14882: 1998 1998/09/01
सी ++ 03 आईएसओ / आईईसी 14882: 2003 2003/10/16
सी ++ 11 आईएसओ / आईईसी 14882: 2011 2011-09-01
सी ++ 14 आईएसओ / आईईसी 14882: 2014 2014-12-15
सी ++ 17 TBD 2017/01/01
सी ++ 20 TBD 2020/01/01

नमस्ते दुनिया

यह कार्यक्रम Hello World! प्रिंट करता है Hello World! मानक आउटपुट स्ट्रीम में:

#include <iostream>

int main()
{
    std::cout << "Hello World!" << std::endl;
}
 

इसे कोलिरु पर लाइव देखें।

विश्लेषण

आइए इस कोड के प्रत्येक भाग की विस्तार से जाँच करें:

  • #include <iostream> एक प्रीप्रोसेसर निर्देश है जिसमें मानक C ++ हेडर फ़ाइल iostream की सामग्री शामिल है।

    iostream एक मानक लाइब्रेरी हेडर फ़ाइल है जिसमें मानक इनपुट और आउटपुट स्ट्रीम की परिभाषाएँ हैं। ये परिभाषाएँ नीचे बताए गए std नाम स्थान में शामिल हैं।

    मानक इनपुट / आउटपुट (I / O) स्ट्रीम प्रोग्राम से इनपुट प्राप्त करने और आउटपुट के लिए बाहरी सिस्टम - आमतौर पर टर्मिनल के लिए तरीके प्रदान करते हैं।

  • int main() { ... } main नामक एक नए फ़ंक्शन को परिभाषित करता है। अधिवेशन द्वारा, कार्यक्रम के निष्पादन पर main कार्य को कहा जाता है। C ++ प्रोग्राम में केवल एक main कार्य होना चाहिए, और इसे हमेशा कई प्रकार के int को वापस करना होगा।

    यहाँ, int को फ़ंक्शन का रिटर्न प्रकार कहा जाता है। main फ़ंक्शन द्वारा लौटाया गया मूल्य एक निकास कोड है।

    कन्वेंशन द्वारा, 0 या EXIT_SUCCESS प्रोग्राम एक्जिट कोड को प्रोग्राम को निष्पादित करने वाली प्रणाली द्वारा सफलता के रूप में व्याख्यायित किया जाता है। कोई अन्य रिटर्न कोड एक त्रुटि के साथ जुड़ा हुआ है।

    यदि कोई return स्टेटमेंट मौजूद नहीं है, तो main फ़ंक्शन (और इस प्रकार, प्रोग्राम स्वयं) डिफ़ॉल्ट रूप से 0 देता है। इस उदाहरण में, हमें स्पष्ट रूप से return 0; लिखने की आवश्यकता नहीं है return 0;

    अन्य सभी फ़ंक्शन, जो void प्रकार को वापस करते हैं, को छोड़कर, उनके रिटर्न प्रकार के अनुसार स्पष्ट रूप से एक मूल्य वापस करना चाहिए, या फिर बिल्कुल भी वापस नहीं लौटना चाहिए।

  • std::cout << "Hello World!" << std::endl; प्रिंट "हैलो वर्ल्ड!" मानक आउटपुट स्ट्रीम में:

    • std एक नेमस्पेस है , और :: स्कोप रिज़ॉल्यूशन ऑपरेटर है जो किसी नेमस्पेस के नाम से ऑब्जेक्ट के लिए लुक-अप की अनुमति देता है।

      कई नाम स्थान हैं। यहाँ, हम :: को दिखाने के लिए उपयोग करते हैं कि हम std नाम स्थान से cout का उपयोग करना चाहते हैं। अधिक जानकारी के लिए स्कोप रिज़ॉल्यूशन ऑपरेटर - Microsoft दस्तावेज़ीकरण देखें

    • std::cout मानक आउटपुट स्ट्रीम ऑब्जेक्ट है, जिसे iostream में परिभाषित किया गया है, और यह मानक आउटपुट ( stdout ) पर प्रिंट करता है।

    • << , इस संदर्भ में , स्ट्रीम सम्मिलन ऑपरेटर , तथाकथित है क्योंकि यह किसी ऑब्जेक्ट को स्ट्रीम ऑब्जेक्ट में सम्मिलित करता है

      मानक पुस्तकालय आउटपुट धाराओं में कुछ डेटा प्रकारों के लिए डेटा प्रविष्टि करने के लिए << ऑपरेटर को परिभाषित करता है। stream << content आवेषण content धारा और रिटर्न एक ही है, लेकिन अद्यतन धारा में। यह स्ट्रीम सम्मिलन को जंजीर बनाने की अनुमति देता है: std::cout << "Foo" << " Bar"; कंसोल को "FooBar" प्रिंट करता है।

    • "Hello World!" एक चरित्र स्ट्रिंग शाब्दिक है , या एक "पाठ शाब्दिक।" चरित्र स्ट्रिंग शाब्दिकों के लिए धारा सम्मिलन ऑपरेटर फ़ाइल iostream में परिभाषित किया गया है।

    • std::endl एक विशेष I / O स्ट्रीम मैनिपुलेटर ऑब्जेक्ट है, जिसे फ़ाइल iostream में भी परिभाषित किया गया है। एक जोड़तोड़ को एक धारा में सम्मिलित करने से धारा की स्थिति बदल जाती है।

      स्ट्रीम मैनिपुलेटर std::endl दो काम करता है: सबसे पहले यह एंड-ऑफ-लाइन वर्ण सम्मिलित करता है और फिर यह स्ट्रीम बफर को कंसोल पर दिखाने के लिए टेक्स्ट को मजबूर करने के लिए फ्लश करता है। यह सुनिश्चित करता है कि स्ट्रीम में डाला गया डेटा वास्तव में आपके कंसोल पर दिखाई दे। (स्ट्रीम डेटा आमतौर पर एक बफर में संग्रहीत किया जाता है और फिर बैचों में "फ्लश" किया जाता है जब तक कि आप तुरंत एक फ्लश मजबूर न करें।)

      एक वैकल्पिक विधि जो फ्लश से बचती है:

      std::cout << "Hello World!\n";
       

      जहां newline वर्ण के लिए \n वर्ण भागने का क्रम है

    • अर्धविराम ( ; ) संकलक को सूचित करता है कि एक बयान समाप्त हो गया है। सभी C ++ स्टेटमेंट्स और वर्ग परिभाषाओं को एक समाप्ति / समाप्ति अर्धविराम की आवश्यकता होती है।

टिप्पणियाँ

एक टिप्पणी C ++ कंपाइलर द्वारा किसी भी कार्यात्मक अर्थ के साथ व्याख्या किए बिना स्रोत कोड के अंदर मनमाना पाठ डालने का एक तरीका है। किसी कार्यक्रम के डिजाइन या विधि में अंतर्दृष्टि देने के लिए टिप्पणियों का उपयोग किया जाता है।

C ++ में दो प्रकार की टिप्पणियाँ हैं:

सिंगल-लाइन टिप्पणियाँ

डबल फ़ॉरवर्ड-स्लैश अनुक्रम // सभी पाठ को एक टिप्पणी के रूप में एक नई पंक्ति तक चिह्नित करेगा:

int main()
{
   // This is a single-line comment.
   int a;  // this also is a single-line comment
   int i;  // this is another single-line comment
}
 

सी-स्टाइल / ब्लॉक टिप्पणियाँ

अनुक्रम /* का उपयोग टिप्पणी ब्लॉक की शुरुआत की घोषणा करने के लिए किया जाता है और अनुक्रम */ का उपयोग टिप्पणी के अंत की घोषणा करने के लिए किया जाता है। प्रारंभ और अंत अनुक्रमों के बीच के सभी पाठ की व्याख्या एक टिप्पणी के रूप में की जाती है, भले ही वह पाठ अन्यथा मान्य C ++ वाक्यविन्यास हो। इन्हें कभी-कभी "सी-स्टाइल" टिप्पणी कहा जाता है, क्योंकि यह टिप्पणी वाक्यविन्यास सी ++ की पूर्ववर्ती भाषा सी से विरासत में मिली है:

int main()
{
   /*
    *  This is a block comment.
    */
   int a;
}
 

किसी भी ब्लॉक टिप्पणी में, आप अपनी इच्छानुसार कुछ भी लिख सकते हैं। जब कंपाइलर प्रतीक */ सामना करता है, तो यह ब्लॉक टिप्पणी को समाप्त करता है:

int main()
{
   /* A block comment with the symbol /*
      Note that the compiler is not affected by the second /*
      however, once the end-block-comment symbol is reached,
      the comment ends.
   */
   int a;
}
 

उपरोक्त उदाहरण C ++ (और C) कोड मान्य है। हालाँकि, ब्लॉक कमेंट के अंदर अतिरिक्त /* होने से कुछ कंपाइलर्स को चेतावनी मिल सकती है।

ब्लॉक टिप्पणियां भी एक पंक्ति के भीतर शुरू और समाप्त हो सकती हैं। उदाहरण के लिए:

void SomeFunction(/* argument 1 */ int a, /* argument 2 */ int b);
 

टिप्पणियों का महत्व

सभी प्रोग्रामिंग भाषाओं के साथ, टिप्पणियां कई लाभ प्रदान करती हैं:

  • कोड के स्पष्ट प्रलेखन को पढ़ने / बनाए रखने में आसान बनाने के लिए
  • उद्देश्य और कोड की कार्यक्षमता का स्पष्टीकरण
  • इतिहास या कोड के पीछे तर्क पर विवरण
  • सीधे कॉपीराइट / लाइसेंस, प्रोजेक्ट नोट्स, विशेष धन्यवाद, अंशदाता क्रेडिट आदि का स्रोत कोड में प्लेसमेंट।

हालाँकि, टिप्पणियों में भी उनकी गिरावट है:

  • कोड में किसी भी परिवर्तन को प्रतिबिंबित करने के लिए उन्हें बनाए रखा जाना चाहिए
  • अत्यधिक टिप्पणियां कोड को कम पठनीय बनाते हैं

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

टिप्पणी मार्कर कोड अक्षम करने के लिए उपयोग किया जाता है

विकास के दौरान, टिप्पणियों को कोड को हटाने के बिना इसे जल्दी से अक्षम करने के लिए भी इस्तेमाल किया जा सकता है। यह अक्सर परीक्षण या डीबगिंग उद्देश्यों के लिए उपयोगी होता है, लेकिन अस्थायी संपादन के अलावा किसी भी अन्य चीज़ के लिए अच्छी शैली नहीं है। यह अक्सर "बाहर टिप्पणी" के रूप में जाना जाता है।

इसी तरह, संदर्भ उद्देश्यों के लिए एक टिप्पणी में कोड के एक टुकड़े के पुराने संस्करणों को रखना, क्योंकि यह एक वर्जनिंग सिस्टम के माध्यम से कोड के इतिहास की खोज करने की तुलना में बहुत कम मूल्य की पेशकश करते हुए फाइलों को बंद कर देता है।

समारोह

एक फ़ंक्शन कोड की एक इकाई है जो बयानों के अनुक्रम का प्रतिनिधित्व करता है।

फ़ंक्शंस तर्कों या मूल्यों को स्वीकार कर सकते हैं और एकल मान (या नहीं) लौटा सकते हैं। किसी फ़ंक्शन का उपयोग करने के लिए, एक फ़ंक्शन कॉल का उपयोग तर्क मानों पर किया जाता है और फ़ंक्शन कॉल का उपयोग स्वयं इसके वापसी मान से बदल दिया जाता है।

प्रत्येक फ़ंक्शन का एक प्रकार का हस्ताक्षर होता है - इसके तर्कों के प्रकार और इसके वापसी प्रकार के प्रकार।

कार्यविधि और गणितीय कार्य की अवधारणाओं से प्रेरित हैं।

  • नोट: C ++ फ़ंक्शन अनिवार्य रूप से प्रक्रियाएं हैं और गणितीय कार्यों की सटीक परिभाषा या नियमों का पालन नहीं करते हैं।

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

  • नोट: लोकप्रिय फ़ंक्शन परिभाषाएँ अन्य शामिल फ़ाइलों (अक्सर सुविधा के लिए और कई फ़ाइलों में पुन: उपयोग) में छिपी हो सकती हैं। यह हेडर फ़ाइलों का एक सामान्य उपयोग है।

समारोह घोषणा

एक फ़ंक्शन घोषणा अपने नाम के साथ एक फ़ंक्शन के अस्तित्व की घोषणा करता है और संकलक के लिए हस्ताक्षर करता है। सिंटैक्स निम्नानुसार है:

int add2(int i); // The function is of the type (int) -> (int)
 

ऊपर के उदाहरण में, int add2(int i) फ़ंक्शन कंपाइलर के लिए निम्नलिखित की घोषणा करता है:

  • वापसी प्रकार int
  • फ़ंक्शन का नाम add2
  • फ़ंक्शन के तर्कों की संख्या 1 है:
    • पहला तर्क टाइप int
    • पहला तर्क नाम से समारोह की सामग्री में करने के लिए भेजा जाएगा i

तर्क नाम वैकल्पिक है; समारोह के लिए घोषणा निम्नलिखित भी हो सकती है:

int add2(int); // Omitting the function arguments' name is also permitted.
 

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

int add2(int i);  // The compiler will note that add2 is a function (int) -> int
int add2(int j);  // As add2 already has a definition of (int) -> int, the compiler
                  // will regard this as an error.
 

यदि कोई फ़ंक्शन कुछ भी नहीं देता है, तो उसका रिटर्न प्रकार void रूप में लिखा जाता void । यदि यह कोई पैरामीटर नहीं लेता है, तो पैरामीटर सूची खाली होनी चाहिए।

void do_something(); // The function takes no parameters, and does not return anything.
                     // Note that it can still affect variables it has access to.
 

फंक्शन कॉल

इसे घोषित किए जाने के बाद एक फ़ंक्शन कहा जा सकता है। उदाहरण के लिए, निम्न कार्यक्रम main के कार्य के भीतर 2 के मूल्य के साथ add2 को बुलाता है:

#include <iostream>

int add2(int i);    // Declaration of add2

// Note: add2 is still missing a DEFINITION.
// Even though it doesn't appear directly in code,
// add2's definition may be LINKED in from another object file.

int main()
{
    std::cout << add2(2) << "\n";  // add2(2) will be evaluated at this point,
                                   // and the result is printed.
    return 0;  
}
 

यहाँ, add2(2) एक फ़ंक्शन कॉल के लिए सिंटैक्स है।

कार्य की परिभाषा

एक फ़ंक्शन परिभाषा * एक घोषणा के समान है, इसके अलावा इसमें वह कोड भी होता है जिसे तब निष्पादित किया जाता है जब फ़ंक्शन को उसके शरीर के भीतर बुलाया जाता है।

add2 लिए फ़ंक्शन परिभाषा का एक उदाहरण हो सकता है:

int add2(int i)       // Data that is passed into (int i) will be referred to by the name i
{                     // while in the function's curly brackets or "scope."
                    
    int j = i + 2;    // Definition of a variable j as the value of i+2.
    return j;         // Returning or, in essence, substitution of j for a function call to
                      // add2.
}
 

कार्य अतिभार

आप एक ही नाम लेकिन विभिन्न मापदंडों के साथ कई कार्य बना सकते हैं।

int add2(int i)           // Code contained in this definition will be evaluated
{                         // when add2() is called with one parameter.
    int j = i + 2;
    return j;
}

int add2(int i, int j)    // However, when add2() is called with two parameters, the
{                         // code from the initial declaration will be overloaded,
    int k = i + j + 2 ;   // and the code in this declaration will be evaluated
    return k;             // instead.
}
 

दोनों फ़ंक्शन को समान नाम add2 द्वारा बुलाया जाता है, लेकिन वास्तविक फ़ंक्शन जिसे कॉल किया जाता है वह कॉल में मापदंडों की मात्रा और प्रकार पर सीधे निर्भर करता है। ज्यादातर मामलों में, C ++ कंपाइलर किस फ़ंक्शन को कॉल करने के लिए गणना कर सकता है। कुछ मामलों में, प्रकार स्पष्ट रूप से कहा जाना चाहिए।

डिफ़ॉल्ट पैरामीटर

फ़ंक्शन मापदंडों के लिए डिफ़ॉल्ट मान केवल फ़ंक्शन घोषणाओं में निर्दिष्ट किए जा सकते हैं।

int multiply(int a, int b = 7); // b has default value of 7.
int multiply(int a, int b)
{
    return a * b;               // If multiply() is called with one parameter, the
}                               // value will be multiplied by the default, 7.
 

इस उदाहरण में, multiply() को एक या दो मापदंडों के साथ कहा जा सकता है। यदि केवल एक पैरामीटर दिया जाता है, तो b का डिफ़ॉल्ट मान होगा 7. डिफ़ॉल्ट तर्कों को फ़ंक्शन के उत्तरार्द्ध तर्कों में रखा जाना चाहिए। उदाहरण के लिए:

int multiply(int a = 10, int b = 20); // This is legal 
int multiply(int a = 10, int b);      // This is illegal since int a is in the former
 

विशेष समारोह कॉल - ऑपरेटर्स

C ++ में विशेष फ़ंक्शन कॉल मौजूद हैं जिनमें name_of_function(value1, value2, value3) तुलना में अलग-अलग वाक्यविन्यास हैं। सबसे आम उदाहरण ऑपरेटरों का है।

कुछ विशेष चरित्र अनुक्रम, जो संकलक द्वारा कॉल फ़ंक्शन को कम किया जाएगा, जैसे कि ! , + , - , * , % , और << और भी बहुत कुछ। ये विशेष वर्ण सामान्य रूप से गैर-प्रोग्रामिंग उपयोग से जुड़े होते हैं या सौंदर्यशास्त्र के लिए उपयोग किए जाते हैं (जैसे कि + वर्ण आमतौर पर C ++ प्रोग्रामिंग के साथ-साथ प्राथमिक गणित में दोनों के अतिरिक्त प्रतीक के रूप में पहचाना जाता है)।

C ++ एक विशेष सिंटैक्स के साथ इन वर्ण अनुक्रमों को संभालता है; लेकिन, संक्षेप में, एक ऑपरेटर की प्रत्येक घटना एक फ़ंक्शन कॉल में कम हो जाती है। उदाहरण के लिए, निम्नलिखित C ++ अभिव्यक्ति:

3+3
 

निम्नलिखित फ़ंक्शन कॉल के बराबर है:

operator+(3, 3)
 

सभी ऑपरेटर फ़ंक्शन नाम के साथ शुरू operator

हालांकि C ++ के तत्काल पूर्ववर्ती, C, ऑपरेटर फ़ंक्शन नामों को C ++ में विभिन्न प्रकार के हस्ताक्षर के साथ अतिरिक्त परिभाषा प्रदान करके अलग-अलग अर्थ नहीं दिए जा सकते हैं, यह मान्य है। एक अद्वितीय फ़ंक्शन नाम के तहत अतिरिक्त फ़ंक्शन परिभाषा "छिपाना" को C ++ में ऑपरेटर ओवरलोडिंग के रूप में संदर्भित किया जाता है, और यह अपेक्षाकृत सामान्य है, लेकिन C ++ में सार्वभौमिक नहीं है।

प्रीप्रोसेसर

प्रीप्रोसेसर कंपाइलर का एक महत्वपूर्ण हिस्सा है

यह स्रोत कोड को संपादित करता है, कुछ बिट्स को काटता है, दूसरों को बदलता है, और अन्य चीजों को जोड़ता है।

स्रोत फ़ाइलों में, हम प्रीप्रोसेसर निर्देशों को शामिल कर सकते हैं। ये निर्देश विशिष्ट कार्य करने के लिए प्रीप्रोसेसर को बताते हैं। एक निर्देश एक नई लाइन पर # के साथ शुरू होता है। उदाहरण:

#define ZERO 0
 

पहला प्रीप्रोसेसर निर्देश जो आपको मिलेंगे वह संभवतः है

#include <something>
 

निर्देश। यह जो something करता है वह सभी को लेता something और इसे आपकी फ़ाइल में सम्मिलित करता है जहां निर्देश था। हैलो वर्ल्ड कार्यक्रम लाइन से शुरू होता है

#include <iostream>
 

यह पंक्ति उन फ़ंक्शन और ऑब्जेक्ट्स को जोड़ती है जो आपको मानक इनपुट और आउटपुट का उपयोग करने देते हैं।

C भाषा, जो प्रीप्रोसेसर का उपयोग भी करती है, उसमें C ++ भाषा जितनी अधिक हेडर फाइलें नहीं हैं, लेकिन C ++ में आप सभी C हेडर फाइलों का उपयोग कर सकते हैं।


अगला महत्वपूर्ण निर्देश शायद यही है

#define something something_else
 

निर्देश। यह पूर्वप्रक्रमक कि के रूप में यह फ़ाइल साथ चला जाता है, इसके बारे में हर घटना को प्रतिस्थापित करना चाहिए बताता है something के साथ something_else । यह कार्यों के समान चीजें भी बना सकता है, लेकिन यह शायद उन्नत सी ++ के रूप में गिना जाता है।

something_else की आवश्यकता नहीं है, लेकिन यदि आप something को कुछ नहीं के रूप में परिभाषित करते हैं, तो पूर्वप्रक्रमक निर्देशों के बाहर, something की सभी घटनाएं गायब हो जाएंगी।

यह वास्तव में वजह से, उपयोगी है #if , #else और #ifdef निर्देशों। इनके लिए प्रारूप निम्नलिखित होगा:

#if something==true
//code
#else
//more code
#endif

#ifdef thing_that_you_want_to_know_if_is_defined
//code
#endif
 

ये निर्देश उस कोड को सम्मिलित करते हैं जो सही बिट में है, और झूठे बिट्स को हटाता है। इसका उपयोग कोड के बिट्स के लिए किया जा सकता है जो केवल कुछ ऑपरेटिंग सिस्टम पर शामिल हैं, पूरे कोड को फिर से लिखे बिना।

मानक C ++ संकलन प्रक्रिया

निष्पादन योग्य C ++ प्रोग्राम कोड आमतौर पर एक कंपाइलर द्वारा निर्मित होता है।

एक कंपाइलर एक प्रोग्राम है जो प्रोग्रामिंग भाषा से कोड को दूसरे रूप में अनुवादित करता है जो (अधिक) सीधे कंप्यूटर के लिए निष्पादन योग्य है। कोड का अनुवाद करने के लिए संकलक का उपयोग करना संकलन कहलाता है

C ++ को अपनी "पैरेंट" भाषा से इसकी संकलन प्रक्रिया का रूप विरासत में मिला है, C नीचे एक सूची है जो C ++ में संकलन के चार प्रमुख चरण दिखा रहा है:

  1. C ++ प्रीप्रोसेसर किसी भी शामिल हेडर फ़ाइलों की सामग्री को सोर्स कोड फ़ाइल में कॉपी करता है, मैक्रो कोड उत्पन्न करता है, और उनके मूल्यों के साथ #define का उपयोग करके परिभाषित प्रतीकात्मक स्थिरांक को प्रतिस्थापित करता है।
  2. C ++ प्रीप्रोसेसर द्वारा निर्मित विस्तारित स्रोत कोड फ़ाइल को मंच के लिए उपयुक्त विधानसभा भाषा में संकलित किया गया है।
  3. कंपाइलर द्वारा उत्पन्न कोडांतरक कोड को प्लेटफॉर्म के लिए उपयुक्त ऑब्जेक्ट कोड में इकट्ठा किया जाता है।
  4. कोडांतरक द्वारा उत्पन्न ऑब्जेक्ट कोड फ़ाइल एक निष्पादन योग्य फ़ाइल का उत्पादन करने के लिए उपयोग किए जाने वाले किसी भी पुस्तकालय कार्यों के लिए ऑब्जेक्ट कोड फ़ाइलों के साथ एक साथ जुड़ा हुआ है।
  • नोट: कुछ संकलित कोड को एक साथ जोड़ा गया है, लेकिन अंतिम कार्यक्रम बनाने के लिए नहीं। आमतौर पर, इस "लिंक किए गए" कोड को एक प्रारूप में भी पैक किया जा सकता है जिसे अन्य कार्यक्रमों द्वारा उपयोग किया जा सकता है। यह "पैकेज्ड, यूनेबल कोड" का बंडल है, जिसे C ++ प्रोग्रामर एक लाइब्रेरी के रूप में संदर्भित करते हैं

कई सी ++ संकलक आसानी से या अतिरिक्त विश्लेषण के लिए संकलन प्रक्रिया के कुछ हिस्सों को मर्ज या अन-मर्ज कर सकते हैं। कई सी ++ प्रोग्रामर विभिन्न उपकरणों का उपयोग करेंगे, लेकिन सभी उपकरण आम तौर पर इस सामान्यीकृत प्रक्रिया का पालन करेंगे जब वे एक कार्यक्रम के उत्पादन में शामिल होते हैं।

नीचे दिया गया लिंक इस चर्चा का विस्तार करता है और मदद करने के लिए एक अच्छा ग्राफिक प्रदान करता है। [१]: http://facademy.cs.niu.edu/~mcmahon/CS241/Notes@comp>.html

फ़ंक्शन प्रोटोटाइप और घोषणाओं की दृश्यता

C ++ में, कोड को उपयोग से पहले घोषित या परिभाषित किया जाना चाहिए। उदाहरण के लिए, निम्न संकलन समय त्रुटि उत्पन्न करता है:

int main()
{
  foo(2); // error: foo is called, but has not yet been declared
}

void foo(int x) // this later definition is not known in main
{
}
 

इसे हल करने के दो तरीके हैं: main() में इसके उपयोग से पहले foo() की परिभाषा या घोषणा करना। यहाँ एक उदाहरण है:

void foo(int x) {}  //Declare the foo function and body first

int main()
{
  foo(2); // OK: foo is completely defined beforehand, so it can be called here.
}
 

हालाँकि, इसके उपयोग से पहले केवल एक "प्रोटोटाइप" घोषणा डालकर फ़ंक्शन को "फॉरवर्ड-डिक्लेयर" करना संभव है और बाद में फ़ंक्शन बॉडी को परिभाषित करना:

void foo(int);  // Prototype declaration of foo, seen by main
                // Must specify return type, name, and argument list types
int main()
{
  foo(2); // OK: foo is known, called even though its body is not yet defined
}

void foo(int x) //Must match the prototype
{
    // Define body of foo here
}
 

प्रोटोटाइप में रिटर्न प्रकार ( void ), फ़ंक्शन का नाम ( foo ) और तर्क सूची चर प्रकार ( int ) निर्दिष्ट करना होगा, लेकिन तर्कों के नाम की आवश्यकता नहीं है

स्रोत फ़ाइलों के संगठन में इसे एकीकृत करने का एक सामान्य तरीका एक प्रोटोटाइप फ़ाइल बनाना है जिसमें सभी प्रोटोटाइप घोषणाएँ हैं:

// foo.h
void foo(int); // prototype declaration
 

और फिर पूरी परिभाषा कहीं और प्रदान करें:

// foo.cpp --> foo.o
#include "foo.h" // foo's prototype declaration is "hidden" in here
void foo(int x) { } // foo's body definition
 

और फिर, एक बार संकलित किए जाने पर, संबंधित ऑब्जेक्ट फ़ाइल foo.o को संकलित ऑब्जेक्ट फ़ाइल में लिंक करें जहां यह लिंकिंग चरण में उपयोग किया जाता है, main.o :

// main.cpp --> main.o
#include "foo.h" // foo's prototype declaration is "hidden" in here
int main() { foo(2); } // foo is valid to call because its prototype declaration was beforehand.
// the prototype and body definitions of foo are linked through the object files
 

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