सीखने के लक्ष्य

इस क्लास के अंत तक, आप सीख चुके होंगे:

• समझना कि फंक्शन्स का उद्देश्य क्या है और वे सी++ में क्यों आवश्यक हैं।
• बनाना सही तरीके से फंक्शन्स ताकि कोड संरचित हो।
• कॉल करना फंक्शन्स को प्रोग्राम के भीतर और यह समझना कि वे कैसे निष्पादित होते हैं।
• अंतर करना उन फंक्शन्स के बीच जो मान वापस लौटाते हैं और जो केवल निर्देशों को निष्पादित करते हैं।
• तुलना करना विभिन्न तरीकों से फंक्शन्स को परिभाषित करने की और यह चुनना कि कौन सा तरीका सबसे उपयुक्त है।

घोषणा, कॉल और फंक्शन्स की परिभाषा

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

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

1. फंक्शन की घोषणा

   इससे पहले कि कोई फंक्शन कोड में उपयोग किया जा सके, कंपाइलर को इसकी उपस्थिति के बारे में सूचित किया जाना चाहिए। यह फंक्शन की घोषणा या प्रोटोटाइप के माध्यम से किया जाता है।

   फंक्शन की घोषणा कंपाइलर को तीन मुख्य बातें बताती है:

   • वह डेटा प्रकार जो फंक्शन लौटाएगा (या void यदि कुछ भी वापस नहीं लौटाता)।
   • फंक्शन का नाम।
   • स्वीकार किए गए पैरामीटर (यदि कोई हो), साथ ही उनके प्रकार।

   फंक्शन की घोषणा का सामान्य सिंटैक्स इस प्रकार है:

   pratyavartan_prakar function_ka_naam (parameter_suchi);
   

   फंक्शन की घोषणा आमतौर पर main() से पहले या हेडर फ़ाइल (.h) में रखी जाती है, जब हम बहु-फ़ाइल प्रोग्रामिंग करते हैं।

2. फंक्शन की कॉल

   एक बार फंक्शन घोषित हो जाने के बाद, हम इसे कॉल कर सकते हैं, अर्थात इसे निष्पादित करने के लिए कोड में उपयोग कर सकते हैं।

   जब कोई फंक्शन कॉल किया जाता है:

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

   फंक्शन कॉल करने का सिंटैक्स इस प्रकार है:

   function_ka_naam (arguments);
   

3. फंक्शन की परिभाषा

   अंत में, फंक्शन की परिभाषा वह भाग है जहाँ उसका व्यवहार निर्दिष्ट किया जाता है। इसमें उन निर्देशों को शामिल किया जाता है जो फंक्शन कॉल होने पर निष्पादित होते हैं।

   फंक्शन की परिभाषा का सामान्य सिंटैक्स इस प्रकार है:

   pratyavartan_prakar function_ka_naam (parameter_suchi) {
       // function kaa sharir: nishpAdit kiye jaane waale nirdesh
       return maan; // (yadi function koii maan lautAtaa hai)
   }
   

   हर फंक्शन परिभाषा को निम्नलिखित नियमों का पालन करना चाहिए:

   • यह घोषणा से मेल खाना चाहिए (यदि पहले घोषित किया गया हो)।
   • यदि फंक्शन कोई मान लौटाता है (उदाहरण के लिए, int), तो इसे return कथन के साथ मान लौटाना चाहिए।
   • यदि फंक्शन void प्रकार का है, तो यह केवल अपने निर्देशों को निष्पादित करता है और return की आवश्यकता नहीं होती।

निष्पादन प्रवाह

जब प्रोग्राम निष्पादित होता है, तो फंक्शन्स main() में दिखाई देने वाले क्रम में कॉल किए जाते हैं। निष्पादन प्रवाह इस प्रकार होता है:

1. कंपाइलर फंक्शन की घोषणा को पहचानता है।
2. main() में जब फंक्शन कॉल मिलता है, तो प्रोग्राम नियंत्रण फंक्शन की परिभाषा में स्थानांतरित हो जाता है।
3. फंक्शन अपने निर्देश निष्पादित करता है।
4. यदि फंक्शन कोई मान लौटाता है, तो यह उस पंक्ति पर लौटता है जहाँ इसे कॉल किया गया था।
5. प्रोग्राम प्रवाह main() में या कॉल करने वाले फंक्शन में वापस चला जाता है।

पूर्व घोषणा का महत्व

किसी फंक्शन को उपयोग में लेने से पहले उसकी घोषणा करना महत्वपूर्ण होता है क्योंकि सी++ कंपाइलर कोड को ऊपर से नीचे पढ़ता है। यदि हम किसी फंक्शन को उसकी परिभाषा या घोषणा से पहले कॉल करने का प्रयास करते हैं, तो हमें एक त्रुटि प्राप्त होगी।

इसका समाधान करने के दो मुख्य तरीके हैं:

1. फंक्शन को main() से पहले घोषित करें और बाद में परिभाषित करें (जैसा कि हमने अब तक देखा है)।
2. फंक्शन को main() से पहले परिभाषित करें, जिससे पूर्व घोषणा की आवश्यकता समाप्त हो जाती है।

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

दृष्टिकोण: घोषणा – कॉल – परिभाषा

सी++ में फंक्शन्स को संरचित करने के सबसे सामान्य तरीकों में से एक है घोषणा – कॉल – परिभाषा। इस पद्धति का पालन करते हुए, हम अपने कोड को तीन मुख्य चरणों में व्यवस्थित करते हैं:

1. घोषणा: कंपाइलर को फंक्शन की उपस्थिति के बारे में सूचित किया जाता है, जिसमें उसका नाम, रिटर्न टाइप और पैरामीटर्स (यदि कोई हो) शामिल होते हैं।
2. कॉल: फंक्शन को मुख्य कोड (main() में अधिकांश मामलों में) के अंदर बुलाया जाता है, जिससे उसका कोड निष्पादित होता है।
3. परिभाषा: फंक्शन का कार्यान्वयन विस्तृत किया जाता है, जिसमें यह निर्दिष्ट होता है कि जब इसे कॉल किया जाए तो यह किन निर्देशों को निष्पादित करेगा।

यह संरचना कोड के संगठन में सुधार करती है, जिससे उसका रखरखाव और विस्तार आसान हो जाता है। आइए इस दृष्टिकोण को एक उदाहरण के माध्यम से समझते हैं:

उदाहरण: फंक्शन consoladice()

निम्नलिखित कोड में, हम घोषणा – कॉल – परिभाषा की अनुक्रमिक प्रक्रिया का पालन कर रहे हैं:

#include <iostream>
using namespace std;
// pehle function kii ghoshna karate hain
void consoladice();
int main() {
    // function ko call karate hain
    consoladice();
    return 0;
}
// pehle se ghoshit function ki paribhasha karate hain
void consoladice() {
    cout << "Yah ek sadharan string ya literal hai." << endl;
    cout << "Ab main tumhe number paanch dikhaata hoon. Yah raha: " << 5 << endl;
    cout << "Dekhein ki 10/5 ka parinaam kya hota hai. Parinaam hai: " << 10/5 << endl;
    cout << "Pi ka ek samanya approximation 22/7 hota hai. Parinaam hai: " << 22/7 << endl;
    cout << "C++ mein 22/7 aur 22.0/7 likhne ka matlab alag hota hai." << endl;
    cout << "Chhoti si badlaav se dekhte hain ki 22.0/7 ka parinaam hai " << 22.0/7 << endl;
    cout << "Kya yeh ek achhi approximation nahi lagti?" << endl;
}

इस कोड के अपेक्षित आउटपुट:

Yah ek sadharan string ya literal hai.
Ab main tumhe number paanch dikhaata hoon. Yah raha: 5
Dekhein ki 10/5 ka parinaam kya hota hai. Parinaam hai: 2
Pi ka ek samanya approximation 22/7 hota hai. Parinaam hai: 3
C++ mein 22/7 aur 22.0/7 likhne ka matlab alag hota hai.
Chhoti si badlaav se dekhte hain ki 22.0/7 ka parinaam hai 3.14286
Kya yeh ek achhi approximation nahi lagti?

घोषणा – कॉल – परिभाषा दृष्टिकोण को बेहतर समझने के लिए, कोड के तीन महत्वपूर्ण हिस्सों पर ध्यान दें:

1. लाइन 5: फंक्शन की घोषणा
   • void consoladice(); कंपाइलर को सूचित करता है कि कोड में एक फंक्शन consoladice() होगा।
   • यह निर्दिष्ट करता है कि इसका रिटर्न टाइप void है, यानी यह कोई मान वापस नहीं करेगा।
   • हालांकि consoladice() की परिभाषा अभी ज्ञात नहीं है, यह घोषणा कंपाइलर को इसे बाद में पहचानने की अनुमति देती है।
2. लाइन 9: फंक्शन की कॉल
   • main() के अंदर, consoladice(); को कॉल किया जाता है।
   • इस बिंदु पर, चूंकि फंक्शन पहले ही घोषित किया जा चुका है, कंपाइलर इसे पहचान सकता है।
   • जब फंक्शन कॉल किया जाता है, तो प्रोग्राम का नियंत्रण उसकी परिभाषा की ओर स्थानांतरित हो जाता है, और उसमें लिखे गए निर्देश निष्पादित होते हैं।
3. लाइन 14 से 22: फंक्शन की परिभाषा
   • यहां consoladice() फंक्शन की संपूर्ण परिभाषा दी गई है।
   • इस उदाहरण में, फंक्शन विभिन्न संदेशों को कंसोल पर प्रिंट करता है, जिनमें कुछ संख्याएं और गणितीय गणनाएं शामिल हैं।
   • एक महत्वपूर्ण बात यह है कि 22/7 और 22.0/7 में अंतर होता है। जब हम 22/7 लिखते हैं, तो दोनों संख्याएं पूर्णांक (integers) होती हैं, इसलिए परिणाम 3 मिलता है (integer division)। लेकिन जब हम 22.0/7 लिखते हैं, तो यह फ्लोटिंग-पॉइंट गणना करता है, जिससे परिणाम 3.14286 आता है।

दृष्टिकोण: पहले घोषणा और कार्यान्वयन, फिर कॉल

सी++ में, घोषणा – कॉल – परिभाषा दृष्टिकोण के अलावा, हमारी फंक्शन्स को संरचित करने का एक और वैध तरीका भी है: पहले घोषणा और कार्यान्वयन, फिर कॉल। इस पद्धति में, हम फंक्शन को पहले ही परिभाषित कर देते हैं, फिर main() में इसका उपयोग करते हैं।

इस दृष्टिकोण में, हम फंक्शन की अलग से घोषणा करने और इसे main() के बाद परिभाषित करने के बजाय, सीधे इसे main() से पहले घोषित और परिभाषित कर देते हैं। इसका लाभ यह है कि हमें अलग से घोषणा करने की आवश्यकता नहीं होती, जिससे कोड अधिक कॉम्पैक्ट और छोटे प्रोग्राम्स में पढ़ने में आसान हो जाता है।

इस दृष्टिकोण की सामान्य संरचना इस प्रकार होती है:

// pehle se function ki paribhasha dete hain
pratyavartan_prakar function_ka_naam (parameter_suchi) {
    // function ka sharir
    return maan; // yadi zaroori ho
}
int main() {
    // function ko call karte hain
    function_ka_naam (arguments);
}

क्योंकि फंक्शन main() से पहले परिभाषित किया गया है, कंपाइलर इसे पहले से पहचान लेता है, इसलिए हमें अलग से घोषणा करने की आवश्यकता नहीं होती।

उदाहरण: फंक्शन consoladice() बिना पूर्व घोषणा के

अब इस दृष्टिकोण को लागू करने वाला एक व्यावहारिक उदाहरण देखते हैं:

#include <iostream>
using namespace std;
// function ko pehle se define karte hain
void consoladice() {
    cout << "Yah ek sadharan string ya literal hai." << endl;
    cout << "Ab main tumhe number paanch dikhaata hoon. Yah raha: " << 5 << endl;
    cout << "Dekhein ki 10/5 ka parinaam kya hota hai. Parinaam hai: " << 10/5 << endl;
    cout << "Pi ka ek samanya approximation 22/7 hota hai. Parinaam hai: " << 22/7 << endl;
    cout << "C++ mein 22/7 aur 22.0/7 likhne ka matlab alag hota hai." << endl;
    cout << "Chhoti si badlaav se dekhte hain ki 22.0/7 ka parinaam hai " << 22.0/7 << endl;
    cout << "Kya yeh ek achhi approximation nahi lagti?" << endl;
}
int main() {
    // function ko call karte hain
    consoladice();
    return 0;
}

इस कोड में निम्नलिखित मुख्य बिंदु देखे जा सकते हैं:

1. लाइन 5 से 13: फंक्शन की घोषणा और परिभाषा साथ में

   consoladice() फंक्शन को सीधे main() से पहले परिभाषित किया गया है, जिससे अलग से घोषणा करने की जरूरत नहीं पड़ती।

2. लाइन 17: main() के अंदर फंक्शन को कॉल किया गया है

   क्योंकि फंक्शन पहले से परिभाषित किया गया है, कंपाइलर इसे पहचान सकता है और इसे बिना किसी त्रुटि के निष्पादित कर सकता है।

3. आउटपुट समान है

   कार्यात्मक रूप से, यह दृष्टिकोण वही परिणाम उत्पन्न करता है जैसा कि घोषणा – कॉल – परिभाषा दृष्टिकोण में, लेकिन अधिक कॉम्पैक्ट संरचना में।

✅ फायदे:

• छोटे प्रोग्राम्स में कोड अधिक स्पष्ट और कॉम्पैक्ट होता है।
• अलग से घोषणा करने की जरूरत नहीं होती, जिससे कोड की लंबाई कम हो जाती है।
• ऐसे स्क्रिप्ट्स में पढ़ने में आसान, जहां सभी फंक्शन्स एक ही फाइल में होते हैं।

❌ नुकसान:

• बड़े प्रोग्राम्स में, यदि बहुत सारे फंक्शन्स पहले से परिभाषित हों, तो यह संगठन को मुश्किल बना सकता है।
• जब कई फाइल्स (.h और .cpp) के साथ काम किया जाता है, तो यह दृष्टिकोण कम प्रभावी होता है क्योंकि आमतौर पर घोषणा को अलग हेडर फाइल में रखा जाता है।

वापसी मान का प्रसार

अब तक, हमने केवल उन्हीं फंक्शन्स का उपयोग किया है जो केवल निर्देशों को निष्पादित करते हैं और कोई मान वापस नहीं लौटाते। हालाँकि, कई मामलों में, यह आवश्यक होता है कि एक फंक्शन कोई मान लौटाए ताकि उसे अन्य गणनाओं में उपयोग किया जा सके या किसी वेरिएबल में संग्रहीत किया जा सके। इस प्रक्रिया को वापसी मान का प्रसार कहा जाता है।

इस अनुभाग में, हम यह समझेंगे कि वे फंक्शन्स कैसे कार्य करते हैं जो कोई मान लौटाते हैं, वे void प्रकार के फंक्शन्स से कैसे भिन्न होते हैं, और हम इस तंत्र का C++ में कैसे उपयोग कर सकते हैं।

व्यावहारिक उदाहरण: एक आयत का क्षेत्रफल निकालने वाला फंक्शन

वापसी मान के प्रसार को स्पष्ट करने के लिए, हम एक फंक्शन बनाएंगे जो एक आयत की आधार और ऊँचाई को प्राप्त करेगा और उसका क्षेत्रफल गणना करेगा।

#include <iostream>
using namespace std;
// function jo ayat ka kshetrafal gannana karta hai aur parinaam lautata hai
double calcularArea(double base, double altura) {
    return base * altura;
}
int main() {
    double base, altura;
    
    // upayogakarta se moolya prapt karte hain
    cout << "Aayt ki base darj karein: ";
    cin >> base;
    cout << "Aayt ki uchchayi darj karein: ";
    cin >> altura;
    // function ko call karte hain aur iska parinaam store karte hain
    double area = calcularArea(base, altura);
    // parinaam dikhate hain
    cout << "Aayt ka kshetrafal hai: " << area << endl;
    
    return 0;
}

1. फंक्शन calcularArea() एक मान लौटाता है
   • यह दो मान (base और altura) को पैरामीटर्स के रूप में लेता है।
   • base * altura के माध्यम से क्षेत्रफल की गणना करता है।
   • return का उपयोग करके गणना के परिणाम को उस भाग में भेजता है जहां इसे कॉल किया गया था।
2. main() में वापसी मान का उपयोग
   • उपयोगकर्ता base और altura को दर्ज करता है।
   • calcularArea() फंक्शन को कॉल किया जाता है और इसका परिणाम area वेरिएबल में संग्रहीत किया जाता है।
   • अंत में, परिणाम कंसोल में प्रदर्शित किया जाता है।
3. void फंक्शन से मुख्य अंतर

   यदि calcularArea() का प्रकार void होता, तो हमें परिणाम को सीधे फंक्शन के अंदर प्रदर्शित करना पड़ता, बजाय इसके कि इसे main() में उपयोग करें।

उदाहरण: यह जाँचने वाला फंक्शन कि कोई संख्या सम है या विषम

#include <iostream>
using namespace std;
// function jo yah janchata hai ki sankhya sam hai ya nahi
bool esPar(int numero) {
    return numero % 2 == 0;
}
int main() {
    int numero;
    cout << "Koi sankhya darj karein: "; cin >> numero;
    if (esPar(numero)) {
        cout << "Sankhya sam hai." << endl;
    } else {
        cout << "Sankhya visham hai." << endl;
    }
    return 0;
}

यहां, esPar() फंक्शन true लौटाता है यदि संख्या सम होती है और false यदि संख्या विषम होती है, जिससे main() फंक्शन यह तय कर सकता है कि कौन सा संदेश प्रदर्शित किया जाए।

रिकर्सन: स्वयं को कॉल करने वाले फंक्शन्स

रिकर्सन एक तकनीक है जिसमें एक फंक्शन खुद को कॉल करता है ताकि किसी समस्या को छोटे संस्करणों में विभाजित करके हल किया जा सके। यह विशेष रूप से ऐसे एल्गोरिदम में उपयोगी होता है जैसे कि फैक्टोरियल की गणना, फिबोनाची श्रेणी और डेटा संरचनाओं जैसे कि ट्री ट्रैवर्सल में।

उदाहरण: किसी संख्या का फैक्टोरियल

किसी संख्या n का फैक्टोरियल इस प्रकार परिभाषित किया जाता है:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

इसे ध्यान में रखते हुए, हम इसे C++ में निम्नलिखित तरीके से कोड कर सकते हैं:

#include <iostream>
using namespace std;
 
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Koi sankhya darj karein: "; cin >> numero;
    cout << "Sankhya " << numero << " ka factorial hai: " << factorial(numero) << endl;
    return 0;
}

इस कोड में:

• factorial(n) फंक्शन खुद को n-1 के साथ कॉल करता है जब तक कि यह आधार मामले (n == 0 या n == 1) तक नहीं पहुँचता।
• फंक्शन पुनरावृत्ति के माध्यम से हल होता है, मूल्यों को गुणा करता है जब तक कि अंतिम परिणाम नहीं मिल जाता।

उदाहरण: फिबोनाची संख्या

फिबोनाची संख्याएँ इस अनुक्रम का अनुसरण करती हैं: 1, 1, 2, 3, 5, 8, 13, \cdots. इस श्रेणी की विशेषता यह है कि प्रत्येक संख्या अपने पिछले दो संख्याओं के योग के बराबर होती है।

गणितीय रूप से, यदि fibo(n) वह फंक्शन है जो फिबोनाची संख्या की गणना करता है, तो इसे निम्नलिखित संरचना से परिभाषित किया जा सकता है:

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

निम्नलिखित C++ कोड फिबोनाची संख्याओं को प्रदर्शित करता है:

#include<iostream>
 
using namespace std;
 
int fibo(int numero) {
    if (numero == 0 || numero == 1) {
        return 1;
    }
    return fibo(numero - 1) + fibo(numero - 2);
}
 
int main() {
    int x = 0, i = 0;
    cout << "Koi sankhya darj karein: "; cin >> x;
     
    while (i < x) {
        cout << "Fibonacci kram mein sthiti " << i + 1 << " ki sankhya hai: " << fibo(i) << endl;
        i = i + 1;
    }   
}

एक फंक्शन से बहु-वापसी मान

सी++ में, एक फंक्शन कई मान लौटा सकता है, जिसके लिए std::pair, std::tuple या वेरिएबल रेफरेंस जैसी संरचनाओं का उपयोग किया जा सकता है।

उदाहरण: std::pair का उपयोग करके दो मान लौटाने वाला फंक्शन

#include <iostream>
#include <utility> // std::pair ka upayog karne ke liye
using namespace std;
 
pair<int, int> dividir(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int numerator = 0, denominator = 1;
     
    cout << "Ansh darj karein: "; cin >> numerator;
    cout << "Har darj karein: "; cin >> denominator;
     
    pair<int, int> result = dividir(numerator, denominator);
 
    cout << "Bhagfal: " << result.first << endl;
    cout << "Sheshfal: " << result.second << endl;
 
    return 0;
}

यहां, dividir() फंक्शन दो मान लौटाता है: एक पूर्णांक भागफल और एक शेषफल।

उदाहरण: std::tuple का उपयोग करके तीन मान लौटाने वाला फंक्शन

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operations(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int sum = 0, difference = 0, product = 0;
    int a = 0, b = 0;
    
    cout << "Koi ek sankhya darj karein: "; cin >> a;
    cout << "Ek aur sankhya darj karein: "; cin >> b;
    
    std::tie(sum, difference, product) = operations(a, b);
    cout << "Yog: " << sum << ", Antar: " << difference << ", Gunank: " << product << endl;
    return 0;
}

फंक्शन ओवरलोडिंग (sobrecarga de funciones)

फंक्शन ओवरलोडिंग हमें एक ही नाम से कई फंक्शन्स को परिभाषित करने की अनुमति देता है, लेकिन उनके पैरामीटर्स की संख्या या प्रकार अलग होते हैं। इससे कोड की पठनीयता और पुन: उपयोग क्षमता में सुधार होता है।

#include <iostream>
#include <string> // std::string ka upayog karne ke liye
#include <cmath>
using namespace std;
// varg ya vritt ka kshetrafal (ek parameter wali aakriti)
double area(double lado) {
    return lado * lado;
}
// aayat ka kshetrafal (do parameter wali aakriti)
double area(double base, double altura) {
    return base * altura;
}
// tribhuj ka kshetrafal (teen parameter wali aakriti)
double area(double a, double b, double c){
    return 0.25 * sqrt((a + b + c) * (a + b - c) * (a - b + c) * (-a + b + c));
}
int main() {
    string figura;
    double result = 0;
    double l1 = 0, l2 = 0, l3 = 0;
    // upayogakarta se aakriti ka naam maangte hain
    cout << "Kaunsi aakriti hai? (varg, vritt, aayat ya tribhuj): ";
    cin >> figura;
    // aakriti ka pata lagane ke liye if-else ka upayog
    if (figura == "varg") {
        cout << "Iska ek taraf ka lambai kitna hai? "; cin >> l1;
        result = area(l1);
        cout << "Varg ka kshetrafal hai: " << result << endl;
    } 
    else if (figura == "aayat") {
        cout << "Iski aadhar lambai kitni hai? "; cin >> l1;
        cout << "Iski uchchayi kitni hai? "; cin >> l2;
        result = area(l1, l2);
        cout << "Aayat ka kshetrafal hai: " << result << endl;
    } 
    else if (figura == "vritt") {
        l1 = 3.141592653; // pi ka maan
        cout << "Vritt ka trijya kitna hai? "; cin >> l2;
        result = area(l1, l2);
        cout << "Vritt ka kshetrafal hai: " << result << endl;
    } 
    else if (figura == "tribhuj") {
        cout << "Tribhuj ke teen taraf ki lambai darj karein:" << endl;
        cout << "Taraf 1: "; cin >> l1;
        cout << "Taraf 2: "; cin >> l2;
        cout << "Taraf 3: "; cin >> l3;
            
        if ((l1 + l2 + l3) * (l1 + l2 - l3) * (l1 - l2 + l3) * (-l1 + l2 + l3) < 0) {
            cout << "Yah tribhuj sambhav nahi hai." << endl;
        }    
        else {
            result = area(l1, l2, l3);
            cout << "Tribhuj ka kshetrafal hai: " << result << endl;
        }            
    }
    else {
        cout << "Amaanayaakriti darj ki gayi hai." << endl;
    }
    return 0;
}

सी++ में Inline फंक्शन्स

सी++ में inline फंक्शन्स एक तरीका प्रदान करते हैं जिससे प्रोग्राम के प्रदर्शन को अनुकूलित किया जा सकता है, जिससे फंक्शन कॉल्स की ओवरहेड को कम किया जा सके। पारंपरिक कॉल की बजाय, कंपाइलर कोशिश करता है कि फंक्शन के कोड को सीधे हर उस स्थान पर फैलाए जहाँ इसे कॉल किया जाता है।

Inline फंक्शन का सिंटैक्स

inline pratyavartan_prakar function_ka_naam (parameter_suchi) {
    // function ka sharir
    return maan; // yadi zaroori ho
}

Inline का उपयोग करने से, हमें किसी अन्य मेमोरी पते पर कूदने की आवश्यकता नहीं होती, जिससे निष्पादन समय को कम किया जा सकता है।

Inline फंक्शन और पारंपरिक फंक्शन के बीच अंतर

Inline फंक्शन का उदाहरण

#include
using namespace std;

inline int cuadrado(int x) {
return x * x;
}

int main() {
cout << "5 ka square hai: " << cuadrado(5) << endl; return 0; } [/code>

🔍 कंपाइलर का प्रोसेस:

1. कंपाइलर cuadrado(5) कॉल को सीधे 5 * 5 से बदल देता है।
2. कार्य निष्पादन के लिए कोई कूद नहीं होता।
3. गणना उसी लाइन पर की जाती है जहाँ फंक्शन को कॉल किया गया था।

Inline के फायदे और नुकसान

✅ फायदे

• फंक्शन कॉल ओवरहेड को समाप्त करता है: छोटे और बार-बार कॉल किए जाने वाले फंक्शन्स में निष्पादन समय कम कर सकता है।
• कंपाइलर द्वारा अनुकूलन को आसान बनाता है: CPU रजिस्टर और स्टैक का उपयोग कम कर सकता है, जिससे प्रदर्शन में सुधार होता है।
• फंक्शन के कोड को संकलन के समय उपलब्ध कराता है।

❌ नुकसान

• बाइनरी का आकार बढ़ाता है: यदि फंक्शन को बड़े प्रोग्राम में कई बार उपयोग किया जाता है, तो कोड हर कॉल पर दोहराया जाएगा।
• हमेशा inline विस्तार की गारंटी नहीं होती: यदि कंपाइलर मानता है कि यह अनुकूल नहीं है, तो वह inline अनुरोध को नजरअंदाज कर सकता है।