C प्रोग्रामिंग में फ़ंक्शन उदाहरण सहित: रिकर्सिव और इनलाइन

सी में फंक्शन क्या है?

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

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

लाइब्रेरी बनाम उपयोगकर्ता-परिभाषित फ़ंक्शन

हर 'C' प्रोग्राम में कम से कम एक फ़ंक्शन होता है जो मुख्य फ़ंक्शन होता है, लेकिन एक प्रोग्राम में कई फ़ंक्शन हो सकते हैं। C में main () फ़ंक्शन किसी प्रोग्राम का शुरुआती बिंदु होता है।

'सी' प्रोग्रामिंग में, फ़ंक्शन दो प्रकारों में विभाजित होते हैं:

पुस्तकालय कार्य
उपयोगकर्ता द्वारा परिभाषित कार्य

C में लाइब्रेरी और यूजर-डिफ़ाइंड फ़ंक्शन के बीच अंतर यह है कि हमें लाइब्रेरी फ़ंक्शन के लिए कोड लिखने की ज़रूरत नहीं है। यह पहले से ही हेडर फ़ाइल के अंदर मौजूद होता है जिसे हम हमेशा प्रोग्राम की शुरुआत में शामिल करते हैं। आपको बस फ़ंक्शन का नाम टाइप करना है और उचित सिंटैक्स के साथ उसका उपयोग करना है। Printf, scanf लाइब्रेरी फ़ंक्शन के उदाहरण हैं।

जबकि, उपयोगकर्ता-परिभाषित फ़ंक्शन एक प्रकार का फ़ंक्शन है जिसमें हमें फ़ंक्शन का मुख्य भाग लिखना होता है और जब भी हमें अपने प्रोग्राम में कुछ ऑपरेशन करने के लिए फ़ंक्शन की आवश्यकता होती है, तो हम फ़ंक्शन को कॉल करते हैं।

C में यूजर-डिफ़ाइंड फ़ंक्शन हमेशा यूजर द्वारा ही लिखा जाता है, लेकिन बाद में यह 'C' लाइब्रेरी का हिस्सा बन सकता है। यह 'C' प्रोग्रामिंग का एक बड़ा फ़ायदा है।

सी प्रोग्रामिंग फ़ंक्शन तीन गतिविधियों में विभाजित हैं जैसे,

समारोह घोषणा
कार्य की परिभाषा
फंक्शन कॉल

समारोह घोषणा

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

फ़ंक्शन घोषणाएँ (जिन्हें प्रोटोटाइप कहा जाता है) आमतौर पर main () फ़ंक्शन के ऊपर की जाती हैं और सामान्य रूप लेती हैं:

return_data_type function_name (data_type arguments);

RSI return_data_type: कॉलिंग स्टेटमेंट पर वापस लौटाए गए वैल्यू फ़ंक्शन का डेटा प्रकार है।
RSI function_name: के बाद कोष्ठक है
तर्क नामों को उनके डेटा प्रकार की घोषणाओं के साथ वैकल्पिक रूप से कोष्ठकों के अंदर रखा जाता है।

हम निम्नलिखित प्रोग्राम पर विचार करते हैं जो यह दिखाता है कि किसी पूर्णांक चर के घन मान की गणना करने के लिए घन फ़ंक्शन की घोषणा कैसे की जाती है

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

ध्यान रखें कि फ़ंक्शन ज़रूरी नहीं कि कोई मान लौटाए। इस मामले में, void कीवर्ड का इस्तेमाल किया जाता है।

उदाहरण के लिए, output_message फ़ंक्शन घोषणा यह इंगित करती है कि फ़ंक्शन कोई मान नहीं लौटाता है: void output_message();

फ़ंक्शन परिभाषा

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

int add(int a,int b)	//function body	
{
	int c;
	c=a+b;
	return c;
}

फंक्शन कॉल

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

  result = add(4,5);

यहाँ, पूरा कोड है:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

आउटपुट:

Addition:30

कार्य तर्क

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

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

हम निम्नलिखित प्रोग्राम पर विचार करते हैं जो मान द्वारा पारित पैरामीटर्स को प्रदर्शित करता है:

int add (int x, int y); 
int main() {
  int a, b, result;
  a = 5;
  b = 10;
  result = add(a, b);
  printf("%d + %d\ = %d\n", a, b, result);
return 0;}
int add (int x, int y) { 
x += y;
  return(x);}

कार्यक्रम का आउटपुट है:

5 + 10 = 15

ध्यान रखें कि add फ़ंक्शन में पास किए गए a और b के मान नहीं बदले गए क्योंकि केवल इसका मान ही पैरामीटर x में पास किया गया था।

परिवर्तनीय दायरा

चर क्षेत्र का अर्थ है प्रोग्राम के कोड के भीतर चरों की दृश्यता।

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

#include <stdio.h>
int global = 1348;
void test();
int main() {
  printf("from the main function : global =%d \n", global);
  test () ;
return 0;}

void test (){
printf("from user defined function : global =%d \n", global);}

रिजल्ट:

from the main function : global =1348
from user defined function : global =1348

हम कार्यक्रम के विवरण पर चर्चा करते हैं:

हम 1348 को प्रारंभिक मान के साथ एक पूर्णांक वैश्विक चर घोषित करते हैं।
हम एक test() फ़ंक्शन घोषित और परिभाषित करते हैं जो न तो तर्क लेता है और न ही कोई मान लौटाता है। यह फ़ंक्शन केवल वैश्विक चर मान को प्रिंट करता है ताकि यह प्रदर्शित किया जा सके कि वैश्विक चर को प्रोग्राम में कहीं भी एक्सेस किया जा सकता है।
हम वैश्विक वेरिएबल को मुख्य फ़ंक्शन के भीतर प्रिंट करते हैं।
हम वैश्विक चर मान को प्रिंट करने के लिए टेस्ट फ़ंक्शन को कॉल करते हैं।

C में, जब फ़ंक्शन पैरामीटर्स को तर्क दिए जाते हैं, तो पैरामीटर्स स्थानीय चर के रूप में कार्य करते हैं, जो फ़ंक्शन से बाहर निकलने पर नष्ट हो जाते हैं।

जब आप उपयोग करते हैं सार्वत्रिक चरइनका उपयोग सावधानी से करें क्योंकि इनसे त्रुटियाँ हो सकती हैं और ये प्रोग्राम में कहीं भी बदल सकते हैं। इन्हें उपयोग करने से पहले इनिशियलाइज़ किया जाना चाहिए।

स्थिर चर

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

निम्नलिखित प्रोग्राम एक स्थिर चर का उपयोग करता है:

#include <stdio.h>
void say_hi();
int main() {    
  int i;
  for (i = 0; i < 5; i++) { say_hi();}
   return 0;}
void say_hi() {
  static int calls_number = 1;
  printf("Hi number %d\n", calls_number);
  calls_number ++; }

कार्यक्रम प्रदर्शित करता है:

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

पुनरावर्ती कार्य

एक संख्या के फैक्टोरियल पर विचार करें जिसकी गणना निम्न प्रकार से की जाती है 6! =6*5*4*3*2*1.

यह गणना तथ्य * (तथ्य -1) की बार-बार गणना करके तब तक की जाती है जब तक तथ्य 1 के बराबर न हो जाए।

रिकर्सिव फ़ंक्शन एक ऐसा फ़ंक्शन है जो खुद को कॉल करता है और रिकर्सिव कॉल को समाप्त करने के लिए एक एग्जिट कंडीशन शामिल करता है। फैक्टोरियल नंबर कैलकुलेशन के मामले में, एग्जिट कंडीशन वास्तव में 1 के बराबर होती है। रिकर्सन तब तक कॉल को “स्टैकिंग” करके काम करता है जब तक एग्जिट कंडीशन सही न हो जाए।

उदाहरण के लिए:

#include <stdio.h>
int factorial(int number);
int main() {    
  int x = 6;
  printf("The factorial of %d is %d\n", x, factorial(x)); 
  return 0;}
int factorial(int number) {
 if (number == 1)    return (1); /* exiting condition */
  else
    return (number * factorial(number - 1));
}

कार्यक्रम प्रदर्शित करता है:

 The factorial of 6 is 720

यहां हम कार्यक्रम के विवरण पर चर्चा करेंगे:

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

पुनरावर्ती तंत्र को और अधिक समझने के लिए निम्नलिखित चार्ट पर विचार करें, जिसमें फ़ंक्शन को तब तक स्वयं कॉल करना शामिल है जब तक कि आधार स्थिति या रोक की स्थिति नहीं आ जाती है, और उसके बाद, हम पिछले मानों को एकत्रित करते हैं:

इनलाइन फ़ंक्शन

C प्रोग्रामिंग में फ़ंक्शन का उपयोग सबसे अधिक बार उपयोग किए जाने वाले निर्देशों को संग्रहीत करने के लिए किया जाता है। इसका उपयोग प्रोग्राम को मॉड्यूलर बनाने के लिए किया जाता है।

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

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

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

इनलाइन फ़ंक्शन का उपयोग ज़्यादातर छोटे-छोटे कम्प्यूटेशन के लिए किया जाता है। जब बड़ी कम्प्यूटिंग की बात आती है तो ये उपयुक्त नहीं होते।

इनलाइन फ़ंक्शन सामान्य फ़ंक्शन के समान ही होता है, सिवाय इसके कि इनलाइन कीवर्ड फ़ंक्शन नाम से पहले रखा जाता है। इनलाइन फ़ंक्शन निम्नलिखित सिंटैक्स के साथ बनाए जाते हैं:

inline function_name ()
{
    //function definition
}

आइए एक इनलाइन फ़ंक्शन को कार्यान्वित करने के लिए एक प्रोग्राम लिखें।

inline int add(int a, int b)		//inline function declaration
{
	return(a+b);
}
int main()
{
	int c=add(10,20);
	printf("Addition:%d\n",c);
	getch();
}