सी प्रोग्रामिंग में फ़ंक्शन पॉइंटर्स उदाहरणों के साथ

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

चरों के वास्तविक मानों को संशोधित करने के लिए, कॉलिंग स्टेटमेंट फ़ंक्शन में पॉइंटर पैरामीटर्स को पते भेजता है।

फ़ंक्शन पॉइंटर्स उदाहरण

उदाहरण के लिए, अगला प्रोग्राम दो के दो मानों को बदलता है:

void swap (int *a, int *b);
int main() {
  int m = 25;
  int n = 100;
  printf("m is %d, n is %d\n", m, n);
  swap(&m, &n);
  printf("m is %d, n is %d\n", m, n);
  return 0;}
void swap (int *a, int *b) {
  int temp;
  temp = *a;
  *a = *b;
  *b = temp;}
}

आउटपुट:

m is 25, n is 100
m is 100, n is 25

प्रोग्राम वास्तविक चरों के मानों को स्वैप करता है क्योंकि फ़ंक्शन उन्हें पते का उपयोग करके एक्सेस करता है सूचकयहां हम कार्यक्रम प्रक्रिया पर चर्चा करेंगे:

1. हम स्वैप के लिए जिम्मेदार फ़ंक्शन की घोषणा करते हैं।ping दो चर मान, जो दो पूर्णांक पॉइंटर को पैरामीटर के रूप में लेता है और कॉल किए जाने पर कोई भी मान लौटाता है।
2. मुख्य फ़ंक्शन में, हम दो पूर्णांक चर ('m' और 'n') घोषित और आरंभ करते हैं, फिर हम क्रमशः उनके मान प्रिंट करते हैं।
3. हम एम्परसेंड सिंबल का उपयोग करके दो वेरिएबल्स के एड्रेस को तर्क के रूप में पास करके स्वैप() फ़ंक्शन को कॉल करते हैं। उसके बाद, हम वेरिएबल्स के नए स्वैप किए गए मानों को प्रिंट करते हैं।
4. यहां हम स्वैप() फ़ंक्शन की सामग्री को परिभाषित करते हैं जो दो पूर्णांक चर पतों को पैरामीटर के रूप में लेता है और एक अस्थायी पूर्णांक चर घोषित करता है जिसका उपयोग तीसरे भंडारण बॉक्स के रूप में किया जाता है ताकि उन मान चरों में से एक को बचाया जा सके जिसे दूसरे चर में रखा जाएगा।
5. 'a' द्वारा इंगित प्रथम चर की सामग्री को अस्थायी चर में सहेजें।
6. b द्वारा इंगित दूसरे चर को a द्वारा इंगित पहले चर में संग्रहित करें।
7. अस्थायी चर में सहेजे गए पहले चर के मान से दूसरे चर (b द्वारा इंगित) को अद्यतन करें।

ऐरे पैरामीटर्स वाले फ़ंक्शन

C में, हम फ़ंक्शन को मान द्वारा सरणी पास नहीं कर सकते। जबकि, सरणी नाम एक पॉइंटर (पता) है, इसलिए हम फ़ंक्शन को सरणी नाम पास करते हैं जिसका अर्थ है सरणी को पॉइंटर पास करना।

उदाहरण के लिए, हम निम्नलिखित कार्यक्रम पर विचार करते हैं:

int add_array (int *a, int num_elements);
int main() {
  int Tab[5] = {100, 220, 37, 16, 98};
  printf("Total summation is %d\n", add_array(Tab, 5)); 
  return 0;}
int add_array (int *p, int size) {
  int total = 0;
  int k;
  for (k = 0; k < size; k++) {
    total += p[k];  /* it is equivalent to total +=*p ;p++; */}
 return (total);}

आउटपुट:

 Total summation is 471

यहां, हम प्रोग्राम कोड को उसके विवरण के साथ समझाएंगे

1. हम add_array() फ़ंक्शन घोषित और परिभाषित करते हैं जो एक सरणी पता (पॉइंटर) लेता है जिसमें उसके तत्वों की संख्या पैरामीटर के रूप में होती है और इन तत्वों का कुल संचित योग लौटाता है। पॉइंटर का उपयोग सरणी तत्वों को पुनरावृत्त करने के लिए किया जाता है (p[k] संकेतन का उपयोग करके), और हम योग को एक स्थानीय चर में संचित करते हैं जो संपूर्ण तत्व सरणी को पुनरावृत्त करने के बाद लौटाया जाएगा।
2. हम पाँच पूर्णांक तत्वों के साथ एक पूर्णांक सरणी घोषित और आरंभ करते हैं। हम सरणी नाम (जो पते के रूप में कार्य करता है) और सरणी आकार को पास करके कुल योग को प्रिंट करते हैं add_array()फ़ंक्शन को तर्क के रूप में बुलाया गया.

फ़ंक्शन जो एक सरणी लौटाते हैं

C में, हम किसी सारणी के लिए पॉइंटर लौटा सकते हैं, जैसा कि निम्नलिखित प्रोग्राम में है:

#include <stdio.h>
int * build_array();
int main() {
  int *a;
  a = build_array(); /* get first 5 even numbers */
  for (k = 0; k < 5; k++)
    printf("%d\n", a[k]);
  return 0;}
int * build_array() {
  static int Tab[5]={1,2,3,4,5};
   return (Tab);}

आउटपुट:

1
2
3
4
5

और यहाँ, हम कार्यक्रम के विवरण पर चर्चा करेंगे

1. हम एक फ़ंक्शन को परिभाषित और घोषित करते हैं जो एक पूर्णांक मान युक्त एक सरणी पता लौटाता है और कोई तर्क नहीं लेता है।
2. हम एक पूर्णांक सूचक घोषित करते हैं जो फ़ंक्शन के कॉल होने के बाद निर्मित सम्पूर्ण सारणी को प्राप्त करता है, तथा सम्पूर्ण पांच तत्व सारणी को पुनरावृत्त करके इसकी सामग्री को प्रिंट करता है।

ध्यान दें कि फ़ंक्शन द्वारा लौटाए गए ऐरे पते को संग्रहीत करने के लिए एक पॉइंटर परिभाषित किया गया है, न कि एक ऐरे। यह भी ध्यान दें कि जब फ़ंक्शन से कोई स्थानीय चर लौटाया जा रहा है, तो हमें इसे फ़ंक्शन में स्थिर घोषित करना होगा।

फ़ंक्शन पॉइंटर्स

जैसा कि हम परिभाषा से जानते हैं कि पॉइंटर्स किसी भी मेमोरी स्थान में किसी पते की ओर संकेत करते हैं, वे मेमोरी में फ़ंक्शन के रूप में निष्पादन योग्य कोड के आरंभ की ओर भी संकेत कर सकते हैं।
फ़ंक्शन के लिए पॉइंटर को * के साथ घोषित किया जाता है, इसकी घोषणा का सामान्य कथन है:

return_type (*function_name)(arguments)

आपको याद रखना होगा कि (*function_name) के चारों ओर कोष्ठक महत्वपूर्ण हैं क्योंकि उनके बिना, संकलक सोचेगा कि function_name return_type का सूचक लौटा रहा है।
फ़ंक्शन पॉइंटर को परिभाषित करने के बाद, हमें इसे फ़ंक्शन को असाइन करना होगा। उदाहरण के लिए, अगला प्रोग्राम एक साधारण फ़ंक्शन घोषित करता है, फ़ंक्शन पॉइंटर को परिभाषित करता है, फ़ंक्शन पॉइंटर को साधारण फ़ंक्शन को असाइन करता है और उसके बाद पॉइंटर के माध्यम से फ़ंक्शन को कॉल करता है:

#include <stdio.h>
void Hi_function (int times); /* function */
int main() {
  void (*function_ptr)(int);  /* function pointer Declaration */
  function_ptr = Hi_function;  /* pointer assignment */
  function_ptr (3);  /* function call */
 return 0;}
void Hi_function (int times) {
  int k;
  for (k = 0; k < times; k++) printf("Hi\n");}

आउटपुट:

Hi
Hi
Hi

1. हम एक मानक फ़ंक्शन को परिभाषित और घोषित करते हैं जो फ़ंक्शन को कॉल किए जाने पर पैरामीटर times द्वारा इंगित k बार Hi टेक्स्ट प्रिंट करता है
2. हम एक पॉइंटर फ़ंक्शन (इसकी विशेष घोषणा के साथ) परिभाषित करते हैं जो एक पूर्णांक पैरामीटर लेता है और कुछ भी वापस नहीं करता है।
3. हम अपने पॉइंटर फ़ंक्शन को Hi_function के साथ आरंभ करते हैं, जिसका अर्थ है कि पॉइंटर Hi_function() की ओर इंगित करता है।
4. मानक फ़ंक्शन कॉलिंग के बजायping आर्गुमेंट्स के साथ फंक्शन का नाम, हम केवल पॉइंटर फंक्शन को आर्गुमेंट के रूप में संख्या 3 पास करके कॉल करते हैं, और बस!

ध्यान रखें कि फ़ंक्शन नाम निष्पादन योग्य कोड के आरंभिक पते की ओर इंगित करता है, जैसे कि सरणी नाम अपने पहले तत्व की ओर इंगित करता है। इसलिए, function_ptr = &Hi_function और (*funptr)(3) जैसे निर्देश सही हैं।
नोट: फ़ंक्शन असाइनमेंट और फ़ंक्शन कॉल के दौरान एड्रेस ऑपरेटर & और इनडायरेक्शन ऑपरेटर * को सम्मिलित करना महत्वपूर्ण नहीं है।

फ़ंक्शन पॉइंटर्स की सरणी

फ़ंक्शन पॉइंटर्स की एक सरणी निर्णय लेने के लिए स्विच या if स्टेटमेंट की भूमिका निभा सकती है, जैसा कि अगले प्रोग्राम में है:

#include <stdio.h>
int sum(int num1, int num2);
int sub(int num1, int num2);
int mult(int num1, int num2);
int div(int num1, int num2);

int main() 
{  int x, y, choice, result;
  int (*ope[4])(int, int);
  ope[0] = sum;
  ope[1] = sub;
  ope[2] = mult;
  ope[3] = div;
  printf("Enter two integer numbers: ");
  scanf("%d%d", &x, &y);
  printf("Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: ");
  scanf("%d", &choice);
  result = ope[choice](x, y);
  printf("%d", result);
return 0;}

int sum(int x, int y) {return(x + y);}
int sub(int x, int y) {return(x - y);}
int mult(int x, int y) {return(x * y);}
int div(int x, int y) {if (y != 0) return (x / y); else  return 0;}

Enter two integer numbers: 13 48
Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: 2
624

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

1. हम चार घोषणाएं और परिभाषित करते हैं कार्यों ये फ़ंक्शन दो पूर्णांक आर्गुमेंट लेते हैं और एक पूर्णांक मान लौटाते हैं।tract, उपयोगकर्ता द्वारा कॉल किए जा रहे फ़ंक्शन के संबंध में दो तर्कों को गुणा और भाग करता है।
2. हम ऑपरेंड, ऑपरेशन प्रकार और परिणाम को संभालने के लिए क्रमशः 4 पूर्णांक घोषित करते हैं। साथ ही, हम चार फ़ंक्शन पॉइंटर की एक सरणी घोषित करते हैं। सरणी तत्व का प्रत्येक फ़ंक्शन पॉइंटर दो पूर्णांक पैरामीटर लेता है और एक पूर्णांक मान लौटाता है।
3. हम प्रत्येक ऐरे तत्व को पहले से घोषित फ़ंक्शन के साथ असाइन और आरंभ करते हैं। उदाहरण के लिए, तीसरा तत्व जो तीसरा फ़ंक्शन पॉइंटर है, वह गुणन ऑपरेशन फ़ंक्शन को इंगित करेगा।
4. हम उपयोगकर्ता से कीबोर्ड से टाइप किए गए ऑपरेंड और ऑपरेशन के प्रकार की जानकारी लेते हैं।
5. हमने तर्कों के साथ उपयुक्त सारणी तत्व (फ़ंक्शन पॉइंटर) को कॉल किया, और हम उपयुक्त फ़ंक्शन द्वारा उत्पन्न परिणाम को संग्रहीत करते हैं।

निर्देश int (*ope[4])(int, int); फ़ंक्शन पॉइंटर्स की सरणी को परिभाषित करता है। प्रत्येक सरणी तत्व में समान पैरामीटर और रिटर्न प्रकार होना चाहिए।
कथन result = ope[choice](x, y); उपयोगकर्ता द्वारा किए गए विकल्प के अनुसार उपयुक्त फ़ंक्शन चलाता है। दर्ज किए गए दो पूर्णांक फ़ंक्शन को दिए गए तर्क हैं।

शून्य पॉइंटर्स का उपयोग करने वाले फ़ंक्शन

शून्य पॉइंटर्स का उपयोग फ़ंक्शन घोषणाओं के दौरान किया जाता है। हम void * रिटर्न टाइप का उपयोग करते हैं जो किसी भी प्रकार को वापस करने की अनुमति देता है। यदि हम मानते हैं कि फ़ंक्शन में पास करते समय हमारे पैरामीटर नहीं बदलते हैं, तो हम इसे const के रूप में घोषित करते हैं।
उदाहरण के लिए:

 void * cube (const void *);

निम्नलिखित कार्यक्रम पर विचार करें:

#include <stdio.h>
void* cube (const void* num);
int main() {
  int x, cube_int;
  x = 4;
  cube_int = cube (&x);
  printf("%d cubed is %d\n", x, cube_int);
  return 0;}

void* cube (const void *num) {
  int result;
  result = (*(int *)num) * (*(int *)num) * (*(int *)num);
  return result;}

रिजल्ट:

 4 cubed is 64

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

1. हम एक ऐसा फ़ंक्शन परिभाषित और घोषित करते हैं जो एक पूर्णांक मान लौटाता है और बिना किसी विशिष्ट डेटा प्रकार के अपरिवर्तनीय चर का पता लेता है। हम num पॉइंटर द्वारा इंगित किए गए कंटेंट वैरिएबल (x) के क्यूब मान की गणना करते हैं, और चूंकि यह एक शून्य पॉइंटर है, इसलिए हमें इसे एक विशिष्ट नोटेशन (* डेटाटाइप) पॉइंटर का उपयोग करके एक पूर्णांक डेटा प्रकार में टाइप करना होगा, और हम क्यूब मान लौटाते हैं।
2. हम ऑपरेंड और परिणाम चर घोषित करते हैं। साथ ही, हम अपने ऑपरेंड को "4" मान के साथ आरंभ करते हैं।
3. हम ऑपरेंड एड्रेस पास करके क्यूब फ़ंक्शन को कॉल करते हैं, और हम परिणाम चर में लौटाए गए मान को संभालते हैं

तर्क के रूप में फ़ंक्शन पॉइंटर्स

फ़ंक्शन पॉइंटर का दोहन करने का एक और तरीका है इसे किसी अन्य फ़ंक्शन के लिए एक तर्क के रूप में पास करना, जिसे कभी-कभी "कॉलबैक फ़ंक्शन" कहा जाता है क्योंकि प्राप्त करने वाला फ़ंक्शन "इसे वापस कॉल करता है।"
stdlib.h हेडर फ़ाइल में, क्विकसॉर्ट “qsort()” फ़ंक्शन इस तकनीक का उपयोग करता है जो एक सारणी को सॉर्ट करने के लिए समर्पित एक एल्गोरिथ्म है।

void qsort(void *base, size_t num, size_t width, int (*compare)(const void *, const void *))

• void *base : सरणी के लिए void सूचक.
• size_t num : सरणी तत्व संख्या.
• size_t चौड़ाई तत्व का आकार.
• int (*compare (const void *, const void *) : दो तर्कों से बना फ़ंक्शन पॉइंटर और जब तर्कों का मान समान होता है तो 0 लौटाता है, <0 जब arg1 arg2 से पहले आता है, और >0 जब arg1 arg2 के बाद आता है।

निम्नलिखित प्रोग्राम qsort() फ़ंक्शन का उपयोग करके पूर्णांक सरणी को छोटी से बड़ी संख्या में क्रमबद्ध करता है:

#include <stdio.h>
#include <stdlib.h>
int compare (const void *, const void *); 
int main() {
  int arr[5] = {52, 14, 50, 48, 13};
  int num, width, i;
  num = sizeof(arr)/sizeof(arr[0]);
  width = sizeof(arr[0]);
  qsort((void *)arr, num, width, compare);
  for (i = 0; i < 5; i++)
    printf("%d ", arr[ i ]);
  return 0;}
int compare (const void *elem1, const void *elem2) {
  if ((*(int *)elem1) == (*(int *)elem2))  return 0;
  else if ((*(int *)elem1) < (*(int *)elem2)) return -1;
  else return 1;}

रिजल्ट:

 13 14 48 50 52

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

1. हम दो तर्कों से मिलकर बना तुलना फ़ंक्शन परिभाषित करते हैं और जब तर्कों का मान समान होता है तो 0 लौटाता है, <0 जब arg1 arg2 से पहले आता है, और >0 जब arg1 arg2 के बाद आता है। पैरामीटर एक शून्य पॉइंटर्स प्रकार है जो उपयुक्त सरणी डेटा प्रकार (पूर्णांक) में डाला जाता है।
2. हम एक पूर्णांक सरणी को परिभाषित और आरंभ करते हैं सरणी का आकार इसमें संग्रहीत होता है संख्या चर और प्रत्येक सरणी तत्व का आकार पूर्वनिर्धारित sizeof() का उपयोग करके चौड़ाई चर में संग्रहीत किया जाता है सी ऑपरेटर.
3. हम कहते हैं क्यूसोर्ट फ़ंक्शन और उपयोगकर्ता द्वारा पहले से परिभाषित सरणी नाम, आकार, चौड़ाई और तुलना फ़ंक्शन को पास करें ताकि हमारे सरणी को आरोही क्रम में सॉर्ट किया जा सके। तुलना प्रत्येक पुनरावृत्ति में दो सरणी तत्वों को लेकर की जाएगी जब तक कि संपूर्ण सरणी सॉर्ट नहीं हो जाती।
4. हम सरणी तत्वों को प्रिंट करते हैं ताकि यह सुनिश्चित हो सके कि हमारी सरणी पूरी सरणी को पुनरावृत्त करके अच्छी तरह से क्रमबद्ध है पाश के लिए.