functions c with types examples
उनके उपयोग के साथ C ++ में कार्यों के प्रकार।
अब तक के हमारे पहले के ट्यूटोरियल में, हमने C ++ में विभिन्न अवधारणाओं को देखा है जैसे चर, भंडारण वर्ग, ऑपरेटर, सरणियाँ, तार आदि।
इस ट्यूटोरियल में, हम आगे बढ़ेंगे और फ़ंक्शन की अवधारणा पर चर्चा करेंगे। फ़ंक्शंस को विधियाँ, सबरूटीन या प्रक्रियाएँ भी कहा जाता है।
=> यहाँ विस्तृत C ++ प्रशिक्षण ट्यूटोरियल श्रृंखला के माध्यम से पढ़ें।
आप क्या सीखेंगे:
- कैसे हम एक समारोह परिभाषित करते हैं?
- C ++ में कार्यों के प्रकार
- समारोह घोषणा
- कार्य की परिभाषा
- एक समारोह बुला रहा है
- औपचारिक और वास्तविक पैरामीटर
- वापसी मान
- शून्य कार्य
- कार्य करने के लिए पैरामीटर पारित करना
- डिफ़ॉल्ट पैरामीटर
- कास्ट पैरामीटर्स
- इनलाइन कार्य
- कार्यों में संरचनाओं का उपयोग करना
- निष्कर्ष
- अनुशंसित पाठ
कैसे हम एक समारोह परिभाषित करते हैं?
एक फ़ंक्शन स्टेटमेंट का एक सेट है जो एक विशिष्ट कार्य करने के लिए एक साथ रखा जाता है। यह कुछ दोहराए गए कार्यों को करने वाले कथन हो सकते हैं या कुछ विशेष कार्यों जैसे मुद्रण आदि को निष्पादित करने वाले कथन हो सकते हैं।
फ़ंक्शंस का एक उपयोग कोड को फ़ंक्शन नामक छोटी इकाइयों में तोड़कर सरल बनाना है। फ़ंक्शंस का उपयोग करने के पीछे एक और विचार यह है कि यह हमें एक ही कोड को बार-बार लिखने से बचाता है। हमें बस एक फ़ंक्शन लिखना है और फिर जब और जैसा आवश्यक हो तब बिना किसी कथन के एक ही सेट को बार-बार लिखना है।
C ++ में कार्यों के प्रकार
C ++ में, हमारे पास दो प्रकार के फ़ंक्शन हैं जैसा कि नीचे दिखाया गया है।
अंतर्निहित कार्य
अंतर्निहित कार्यों को लाइब्रेरी फ़ंक्शन भी कहा जाता है। ये वे कार्य हैं जो C ++ द्वारा प्रदान किए गए हैं और हमें इन्हें स्वयं लिखने की आवश्यकता नहीं है। हम सीधे अपने कोड में इन कार्यों का उपयोग कर सकते हैं।
ये फ़ंक्शन C ++ की हेडर फ़ाइलों में रखे गए हैं। उदाहरण के लिए , वे हेडर हैं जिनके पास क्रमशः गणित कार्य और स्ट्रिंग फ़ंक्शन हैं।
आइए एक कार्यक्रम में अंतर्निहित कार्यों का उपयोग करने का एक उदाहरण देखें।
#include #include using namespace std; int main() { string name; cout << 'Enter the input string:'; getline (std::cin, name); cout << 'String entered: ' << name << '!
'; int size = name.size(); cout<<'Size of string : '< आउटपुट:
इनपुट स्ट्रिंग दर्ज करें: सॉफ्टवेयर टेस्टिंग मदद
स्ट्रिंग दर्ज की गई: सॉफ्टवेयर परीक्षण मदद!
स्ट्रिंग का आकार: 21
यहाँ हम हेडर का उपयोग कर रहे हैं और। पुस्तकालय में डेटा प्रकार और अन्य इनपुट / आउटपुट फ़ंक्शन परिभाषित हैं। स्ट्रिंग, गेटलाइन जैसे आकार के कार्य, हेडर का एक हिस्सा हैं।
उपयोगकर्ता-परिभाषित कार्य
C ++ भी अपने उपयोगकर्ताओं को अपने स्वयं के कार्यों को परिभाषित करने की अनुमति देता है। ये उपयोगकर्ता द्वारा परिभाषित कार्य हैं। हम प्रोग्राम में कहीं भी फ़ंक्शन को परिभाषित कर सकते हैं और फिर कोड के किसी भी हिस्से से इन कार्यों को कॉल कर सकते हैं। चरों की तरह, इसे उपयोग करने से पहले घोषित किया जाना चाहिए, कार्यों को भी बुलाया जाना चाहिए।
आइए हम उपयोगकर्ता-परिभाषित कार्यों पर विस्तार से चर्चा करें।
उपयोगकर्ता-परिभाषित कार्यों (या बस कार्यों) के लिए सामान्य वाक्यविन्यास नीचे दिया गया है:
return_type functionName(param1,param2,….param3) { Function body; }
जैसा कि ऊपर दिखाया गया है, प्रत्येक फ़ंक्शन में है:
- वापसी प्रकार: यह मान है कि फ़ंक्शन किसी विशिष्ट कार्य को करने के बाद कॉलिंग फ़ंक्शन पर लौटते हैं।
- फ़ंक्शन का नाम : किसी फ़ंक्शन को नाम देने के लिए प्रयुक्त पहचानकर्ता।
- पैरामीटर सूची: उपरोक्त वाक्य रचना में param1, param2,… paramn द्वारा अस्वीकृत। ये ऐसे तर्क हैं जो फ़ंक्शन को कॉल किए जाने पर फ़ंक्शन को दिए जाते हैं। पैरामीटर सूची वैकल्पिक है यानी हमारे पास ऐसे कार्य हो सकते हैं जिनके कोई पैरामीटर नहीं हैं।
- समारोह शरीर: बयानों का एक समूह जो एक विशिष्ट कार्य करता है।
जैसा कि पहले ही उल्लेख किया गया है, हमें इसका उपयोग करने से पहले एक फ़ंक्शन को 'घोषित' करने की आवश्यकता है।
समारोह घोषणा
एक फ़ंक्शन डिक्लेरेशन कंपाइलर को फ़ंक्शन के प्रकार, उसके उपयोग के प्रकार और उसके डेटा प्रकारों के बारे में बताता है। फ़ंक्शन में मापदंडों के नाम शामिल हैं, घोषणा वैकल्पिक है। फ़ंक्शन घोषणा को फ़ंक्शन प्रोटोटाइप भी कहा जाता है।
हमने आपके संदर्भ के लिए नीचे दी गई फ़ंक्शन घोषणा के कुछ उदाहरण दिए हैं।
int sum(int, int);
घोषणा से ऊपर एक फ़ंक्शन 'योग' है जो दो पूर्णांकों को पैरामीटर के रूप में लेता है और एक पूर्णांक मान लौटाता है।
void swap(int, int);
इसका मतलब है कि स्वैप फ़ंक्शन इंट के दो मापदंडों को लेता है और किसी भी मूल्य को वापस नहीं करता है और इसलिए रिटर्न प्रकार शून्य है।
void display();
फ़ंक्शन प्रदर्शन किसी भी पैरामीटर को नहीं लेता है और किसी भी प्रकार को वापस नहीं करता है।
कार्य की परिभाषा
एक फ़ंक्शन परिभाषा में वह सब कुछ होता है जो एक फ़ंक्शन घोषणा में होता है और इसके अतिरिक्त इसमें ब्रेसिज़ ({}) में संलग्न फ़ंक्शन का शरीर भी होता है।
इसके अलावा, इसमें नामांकित पैरामीटर भी होना चाहिए। जब फ़ंक्शन को कॉल किया जाता है, तो प्रोग्राम का नियंत्रण फ़ंक्शन परिभाषा को पास करता है ताकि फ़ंक्शन कोड निष्पादित हो सके। जब फ़ंक्शन का निष्पादन समाप्त हो जाता है, तो नियंत्रण उस बिंदु पर वापस जाता है जहां फ़ंक्शन को बुलाया गया था।
स्वैप फ़ंक्शन की उपरोक्त घोषणा के लिए, परिभाषा नीचे दी गई है:
void swap(int a, int b){ b = a + b; a = b - a; b = b - a; }
ध्यान दें कि एक फ़ंक्शन की घोषणा और परिभाषा एक साथ जा सकती है। यदि हम संदर्भित करने से पहले किसी फ़ंक्शन को परिभाषित करते हैं तो एक अलग घोषणा की आवश्यकता नहीं है।
एक फंक्शन को प्रदर्शित करने के लिए एक पूर्ण प्रोग्रामिंग उदाहरण लेते हैं।
#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<'
After swapping: '; cout<<'a = '< एक समारोह बुला रहा है जब हमारे कार्यक्रम में कोई फ़ंक्शन होता है, तो आवश्यकता के आधार पर हमें इस फ़ंक्शन को कॉल करने या आमंत्रित करने की आवश्यकता होती है। जब फ़ंक्शन को कॉल किया जाता है या आमंत्रित किया जाता है, तो फ़ंक्शन वांछित परिणाम प्रदान करने के लिए बयानों के अपने सेट को निष्पादित करेगा।
कार्यक्रम में कहीं से भी समारोह को बुलाया जा सकता है। यदि प्रोग्राम एक से अधिक फ़ंक्शन का उपयोग कर रहा है, तो इसे मुख्य फ़ंक्शन से या किसी अन्य फ़ंक्शन से कॉल किया जा सकता है। किसी अन्य फ़ंक्शन को कॉल करने वाले फ़ंक्शन को 'कॉलिंग फ़ंक्शन' कहा जाता है।
स्वैपिंग संख्याओं के उपरोक्त उदाहरण में, स्वैप फ़ंक्शन को मुख्य फ़ंक्शन में कहा जाता है। इसलिए मुख्य फ़ंक्शन कॉलिंग फ़ंक्शन बन जाता है।
औपचारिक और वास्तविक पैरामीटर
हमने पहले ही देखा है कि हमारे पास कार्यों के लिए पैरामीटर हो सकते हैं। फ़ंक्शन के पैरामीटर फ़ंक्शन नाम की फ़ंक्शन सूची के रूप में फ़ंक्शन परिभाषा में प्रदान किए जाते हैं। जब फ़ंक्शन कहा जाता है तो हमें इन मापदंडों के वास्तविक मूल्यों को पास करना होगा ताकि इन वास्तविक मूल्यों का उपयोग करके फ़ंक्शन अपने कार्य को अंजाम दे सके।
फ़ंक्शन परिभाषा में परिभाषित पैरामीटर को कहा जाता है औपचारिक पैरामीटर । फ़ंक्शन कॉल में पैरामीटर जो वास्तविक मूल्य हैं उन्हें कहा जाता है वास्तविक पैरामीटर।
स्वैपिंग संख्याओं के उपरोक्त उदाहरण में, हमने औपचारिक और वास्तविक मापदंडों के लिए टिप्पणियां लिखी हैं। कॉलिंग फ़ंक्शन में अर्थात मुख्य, दो पूर्णांकों का मान पढ़ा जाता है और स्वैप फ़ंक्शन को पास कर दिया जाता है। ये वास्तविक पैरामीटर हैं।
हम फ़ंक्शन परिभाषा की पहली पंक्ति में इन मापदंडों की परिभाषा देख सकते हैं। ये औपचारिक पैरामीटर हैं।
ध्यान दें कि औपचारिक और वास्तविक तर्क का प्रकार मेल खाना चाहिए। औपचारिक और वास्तविक मापदंडों का क्रम भी मेल खाना चाहिए।
वापसी मान
एक बार फ़ंक्शन अपना इच्छित कार्य करता है, तो उसे कॉलिंग फ़ंक्शन पर परिणाम लौटा देना चाहिए। इसके लिए, हमें फ़ंक्शन के रिटर्न प्रकार की आवश्यकता है। फ़ंक्शन कॉलिंग फ़ंक्शन के लिए एक एकल मान लौटा सकता है। फ़ंक्शन प्रोटोटाइप के साथ फ़ंक्शन का रिटर्न प्रकार घोषित किया जाता है।
आइए वापसी प्रकारों को प्रदर्शित करने के लिए दो संख्याओं को जोड़ने का एक उदाहरण लें।
#include using namespace std; int sum(int a, int b){ return (a+b); } int main() { int a, b, result; cout<>a>>b; result = sum(a,b); cout<<'
Sum of the two numbers : '< आउटपुट:
जोड़े जाने वाले दो नंबर दर्ज करें: 11 11
बाहरी जॉइन और लेफ्ट जॉइन में क्या अंतर है
दो संख्याओं का योग: 22
उपरोक्त उदाहरण में, हमारे पास एक फ़ंक्शन योग है जो दो पूर्णांक पैरामीटर लेता है और एक पूर्णांक प्रकार देता है। मुख्य फ़ंक्शन में, हम कंसोल इनपुट से दो पूर्णांक पढ़ते हैं और इसे सम फ़ंक्शन में पास करते हैं। जैसा कि रिटर्न प्रकार एक पूर्णांक है, हमारे पास एलएचएस पर परिणाम चर है और आरएचएस एक फ़ंक्शन कॉल है।
जब किसी फ़ंक्शन को निष्पादित किया जाता है, तो फ़ंक्शन राशि द्वारा लौटाए गए अभिव्यक्ति (ए + बी) परिणाम चर को सौंपा जाता है। यह दिखाता है कि फ़ंक्शन का रिटर्न मान कैसे उपयोग किया जाता है।
शून्य कार्य
हमने देखा है कि फ़ंक्शन के सामान्य सिंटैक्स को परिभाषित करने के लिए वापसी प्रकार की आवश्यकता होती है। लेकिन अगर हमारे पास ऐसा कोई फ़ंक्शन है जो किसी भी मूल्य को वापस नहीं करता है, तो उस स्थिति में, हम रिटर्न प्रकार के रूप में क्या निर्दिष्ट करते हैं? इसका उत्तर यह है कि हम वैधता प्रकार 'शून्य' का उपयोग करते हैं ताकि यह इंगित किया जा सके कि फ़ंक्शन मान वापस नहीं करता है।
ऐसे मामले में फ़ंक्शन को 'शून्य फ़ंक्शन' कहा जाता है और इसका प्रोटोटाइप जैसा होगा
शून्य फ़ंक्शननाम (param1, param2,… .param 3);
ध्यान दें : एक बयान 'वापसी;' को शामिल करने के लिए एक अच्छा अभ्यास माना जाता है। स्पष्टता के लिए शून्य फ़ंक्शन के अंत में।
कार्य करने के लिए पैरामीटर पारित करना
हमने पहले ही वास्तविक और औपचारिक मापदंडों की अवधारणा को देखा है। हम यह भी जानते हैं कि वास्तविक पैरामीटर एक फ़ंक्शन के मानों को पास करते हैं जो प्रारूप मापदंडों द्वारा प्राप्त होता है। इसे मापदंडों का पासिंग कहा जाता है।
C ++ में, हमारे पास कुछ तरीके हैं जो पैरामीटर पर चर्चा करने के लिए नीचे दिए गए हैं।
मान से पास करें
पहले से चर्चा किए गए दो पूर्णांकों को स्वैप करने के कार्यक्रम में, हमने देखा है कि हम पूर्णांक gers a ’और and b’ को मुख्य रूप से पढ़ते हैं और उन्हें स्वैप समारोह में भेज देते हैं। यह वैल्यू तकनीक से पास है।
पासिंग पैरामीटर की वैल्यू तकनीक द्वारा पास करने में, वास्तविक मापदंडों के मूल्यों की प्रतियां औपचारिक मापदंडों को पारित की जाती हैं। इसके कारण, वास्तविक और औपचारिक पैरामीटर विभिन्न मेमोरी स्थानों पर संग्रहीत किए जाते हैं। इस प्रकार, फ़ंक्शन के अंदर औपचारिक मापदंडों में किए गए परिवर्तन फ़ंक्शन के बाहर प्रतिबिंबित नहीं होते हैं।
हम एक बार फिर से दो नंबरों की अदला-बदली करके इसे बेहतर तरीके से समझ सकते हैं।
#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<'
After swapping inside Swap:
'; cout<<'a = '< संदर्भ द्वारा पास करें संदर्भ द्वारा पास अभी तक एक और तकनीक है जिसका उपयोग सी ++ द्वारा कार्यों के मापदंडों को पारित करने के लिए किया जाता है। इस तकनीक में, वास्तविक मापदंडों की प्रतियों को पारित करने के बजाय, हम वास्तविक मापदंडों के संदर्भ में पास करते हैं।
ध्यान दें: संदर्भ कुछ और नहीं बल्कि चरों के उपनाम हैं या सरल शब्दों में, यह एक और नाम है जो एक चर को दिया जाता है। इसलिए एक चर और उसका संदर्भ एक ही स्मृति स्थान साझा करते हैं। हम अपने बाद के ट्यूटोरियल में विस्तार से संदर्भ सीखेंगे।
संदर्भ तकनीक से गुजरने पर, हम वास्तविक मापदंडों के इन संदर्भों का उपयोग करते हैं और परिणामस्वरूप, फ़ंक्शन में औपचारिक मापदंडों में किए गए परिवर्तन कॉलिंग फ़ंक्शन पर वापस दिखाई देते हैं।
हम अपने पाठकों के लिए अवधारणा को बेहतर ढंग से समझने के लिए अपने स्वैप फ़ंक्शन को संशोधित करते हैं।
#include #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< इसलिए स्वैप फ़ंक्शन में औपचारिक मापदंडों में किए गए परिवर्तन मुख्य कार्य को दर्शाते हैं और हमें स्वैप किए गए मान मिलते हैं।
पॉइंटर से पास करें
C ++ में, हम पॉइंटर वैरिएबल्स का उपयोग करके फ़ंक्शन को भी पास कर सकते हैं। पॉइंटर तकनीक द्वारा पास वही परिणाम उत्पन्न करता है जो संदर्भ द्वारा पास होता है। इसका मतलब यह है कि औपचारिक और वास्तविक दोनों पैरामीटर समान मेमोरी स्थानों को साझा करते हैं और फ़ंक्शन में किए गए परिवर्तन कॉलिंग फ़ंक्शन में परिलक्षित होते हैं।
एकमात्र अंतर जो संदर्भ के पास से होता है, हम संदर्भ या मापदंडों के उपनाम से निपटते हैं जबकि सूचक तकनीक द्वारा पास में हम मापदंडों को पारित करने के लिए सूचक चर का उपयोग करते हैं।
mysql साक्षात्कार और अनुभवी के लिए जवाब
पॉइंटर चर उन संदर्भों के साथ भिन्न होते हैं जिनमें पॉइंटर चर किसी विशेष चर को इंगित करते हैं और संदर्भों के विपरीत, हम उस चर को बदल सकते हैं जो उन्हें इंगित करता है। हम अपने बाद के ट्यूटोरियल में पॉइंटर के विवरण का पता लगाएंगे।
हम पॉइंटर तकनीक द्वारा दर्रा प्रदर्शित करने के लिए दो पूर्णांकों की अदला-बदली प्रस्तुत करते हैं।
#include #include using namespace std; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< डिफ़ॉल्ट पैरामीटर C ++ में, हम फंक्शन पैरामीटर के लिए डिफ़ॉल्ट मान प्रदान कर सकते हैं। इस मामले में, जब हम फ़ंक्शन को लागू करते हैं, तो हम मापदंडों को निर्दिष्ट नहीं करते हैं। इसके बजाय, फ़ंक्शन डिफ़ॉल्ट पैरामीटर लेता है जो प्रोटोटाइप में प्रदान किए जाते हैं।
निम्न उदाहरण डिफ़ॉल्ट पैरामीटर के उपयोग को दर्शाता है।
#include #include using namespace std; int mathoperation(int a, int b = 3, int c = 2){ return ((a*b)/c); } int main() { int a,b,c; cout<>a>>b>>c; cout< आउटपुट:
A, b और c: 10 4 6 के लिए मान दर्ज करें
1 arg: 15 के साथ गणित के लिए कॉल करें
2 arg: 20 के साथ गणित के लिए कॉल करें
3 आरजी के साथ गणित के लिए कॉल करें: 6
जैसा कि कोड उदाहरण में दिखाया गया है, हमारे पास एक फ़ंक्शन eration मैथोपेरेशन ’है जो तीन पैरामीटर लेता है जिसमें से हमने दो मापदंडों के लिए डिफ़ॉल्ट मान प्रदान किए हैं। फिर मुख्य फ़ंक्शन में, हम इस फ़ंक्शन को तीन बार एक अलग तर्क सूची के साथ कहते हैं।
पहला कॉल केवल एक तर्क के साथ है। इस स्थिति में, अन्य दो तर्कों में डिफ़ॉल्ट मान होंगे। अगली कॉल दो तर्कों के साथ है। इस स्थिति में, तीसरे तर्क का डिफ़ॉल्ट मान होगा। तीसरी कॉल तीन तर्कों के साथ है। इस मामले में, जैसा कि हमने सभी तीन तर्क दिए हैं, डिफ़ॉल्ट मानों की अनदेखी की जाएगी।
ध्यान दें कि डिफ़ॉल्ट पैरामीटर प्रदान करते समय, हम हमेशा सही-सबसे पैरामीटर से शुरू करते हैं। इसके अलावा, हम बीच में एक पैरामीटर को छोड़ नहीं सकते हैं और अगले पैरामीटर के लिए एक डिफ़ॉल्ट मान प्रदान कर सकते हैं।
अब हम कुछ विशेष फ़ंक्शन से संबंधित अवधारणाओं पर चलते हैं जो प्रोग्रामर के दृष्टिकोण से महत्वपूर्ण हैं।
कास्ट पैरामीटर्स
हम keyword const ’कीवर्ड का उपयोग करके फ़ंक्शंस में निरंतर पैरामीटर भी पास कर सकते हैं। जब कोई पैरामीटर या संदर्भ कॉस्ट होता है, तो इसे फ़ंक्शन के अंदर नहीं बदला जा सकता है।
ध्यान दें कि हम एक कांस्टेबल पैरामीटर को नॉन-कास्ट फॉर्मल पैरामीटर में पास नहीं कर सकते हैं। लेकिन हम कांस्टेबल औपचारिक पैरामीटर के लिए कॉन्स्ट और नॉन-कास्ट पैरामीटर पारित कर सकते हैं।
इसी तरह, हम कॉन्स्टेंट रिटर्न-टाइप भी कर सकते हैं। इस स्थिति में भी, वापसी प्रकार को संशोधित नहीं किया जा सकता है।
आइए एक कोड उदाहरण देखते हैं जिसमें कॉन्स्ट रेफरेंस का उपयोग किया जाता है।
#include #include using namespace std; int addition(const int &a, const int &b){ return (a+b); } int main() { int a,b; cout<>a>>b; cout<<'a = '< आउटपुट:
स्वैप किए जाने वाले दो नंबर दर्ज करें: 22 33
a = 2 बी = 33
परिणाम का जोड़: 55
उपर्युक्त कार्यक्रम में, हमारे पास औपचारिक औपचारिक पैरामीटर हैं। ध्यान दें कि वास्तविक पैरामीटर सामान्य गैर-कॉन्स्टेबल चर हैं जो हमने सफलतापूर्वक पारित कर दिए हैं। चूंकि औपचारिक पैरामीटर कास्ट हैं, हम उन्हें फ़ंक्शन के अंदर संशोधित नहीं कर सकते। इसलिए हम केवल अतिरिक्त ऑपरेशन करते हैं और मूल्य वापस करते हैं।
यदि हम फ़ंक्शन के अंदर या बी के मूल्यों को संशोधित करने का प्रयास करते हैं, तो कंपाइलर एक त्रुटि जारी करेगा।
इनलाइन कार्य
हम जानते हैं कि फ़ंक्शन कॉल करने के लिए, आंतरिक रूप से इसमें फ़ंक्शन को नियंत्रण देने से पहले स्टैक पर प्रोग्राम की स्थिति को संकलित करना एक संकलक शामिल होता है।
जब फ़ंक्शन वापस आता है, तो कंपाइलर को प्रोग्राम की स्थिति को वापस प्राप्त करना होता है और जहां इसे छोड़ा जाता है, वहां से जारी रहता है। इससे एक ओवरहेड बन जाता है। इसलिए, C ++ में जब भी हमारे पास कोई फ़ंक्शन होता है जिसमें कुछ कथन होते हैं, तो एक सुविधा होती है जो इसे इनलाइन का विस्तार करने की अनुमति देती है। यह एक फ़ंक्शन इनलाइन बनाकर किया जाता है।
तो इनलाइन फ़ंक्शन फ़ंक्शन हैं जो रनटाइम में विस्तारित होते हैं, फ़ंक्शन को कॉल करने के प्रयासों को सहेजते हैं और स्टैक संशोधन करते हैं। लेकिन भले ही हम एक फ़ंक्शन को इनलाइन के रूप में बनाते हैं, लेकिन कंपाइलर गारंटी नहीं देता है कि इसे रनटाइम में विस्तारित किया जाएगा। दूसरे शब्दों में, यह फ़ंक्शन को इनलाइन बनाने या न करने के लिए कंपाइलर पर पूरी तरह से निर्भर है।
कुछ संकलक छोटे कार्यों का पता लगाते हैं और उन्हें इनलाइन का विस्तार करते हैं भले ही उन्हें इनलाइन घोषित न किया गया हो।
निम्नलिखित इनलाइन फ़ंक्शन का एक उदाहरण है।
inline int addition(const int &a,const int &b){ return (a+b); }
जैसा कि ऊपर दिखाया गया है, हम फ़ंक्शन इनलाइन बनाने के लिए एक कीवर्ड 'इनलाइन' के साथ फ़ंक्शन की परिभाषा से पहले हैं।
कार्यों में संरचनाओं का उपयोग करना
हम संरचना चर को पैरामीटर के रूप में उसी तरह से कार्य करने के लिए पारित कर सकते हैं जिसमें हम साधारण चर को पैरामीटर के रूप में पास करते हैं।
यह निम्नलिखित उदाहरण में दिखाया गया है।
#include #include using namespace std; struct PersonInfo { int age; char name[50]; double salary; }; void printStructInfo(PersonInfo p) { cout<<'PersonInfo Structure:'; cout<<'
Age:'< p.age; cout <> p.salary; printStructInfo(p); }
आउटपुट:
नाम दर्ज करें: वेदांग
आयु दर्ज करें: 22
वेतन दर्ज करें: 45000.00
व्यक्ति संरचना:
आयु: २२
नाम: वेदांग
वेतन: 45000 रुपये
जैसा कि उपरोक्त कार्यक्रम में दिखाया गया है, हम अन्य चर के समान कार्य करने के लिए एक संरचना पास करते हैं। हम मानक इनपुट से संरचना के सदस्यों के लिए मान पढ़ते हैं और फिर संरचना को प्रदर्शित करने वाले फ़ंक्शन को एक संरचना देते हैं।
निष्कर्ष
यह सब सी ++ में कार्यों की मूल बातें के बारे में था।
हम अपने आगामी ट्यूटोरियल में C ++ में स्थिर कार्यों के बारे में अधिक जानकारी प्राप्त करेंगे।
=> पूर्ण C ++ मुफ़्त प्रशिक्षण श्रृंखला यहां देखें।
अनुशंसित पाठ
- पायथन कार्य
- C ++ में दिनांक और समय कार्य उदाहरण के साथ
- पैरामीटर और रिटर्न के साथ यूनिक्स शैल स्क्रिप्ट कार्य
- उदाहरणों के साथ पायथन डेटटाइम ट्यूटोरियल
- महत्वपूर्ण लोडरनर फ़ंक्शंस जिसका उपयोग उदाहरणों के साथ वुगेन लिपियों में किया जाता है
- पायथन स्ट्रिंग फ़ंक्शंस
- हाथों पर उदाहरण के साथ अजगर मुख्य समारोह ट्यूटोरियल
- मित्र कार्य C ++ में