उदाहरणों के साथ सी प्रोग्रामिंग में कार्य संकेत

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

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

इस ट्यूटोरियल में, आप सीखेंगे-

कार्य संकेत उदाहरण
ऐरे पैरामीटर के साथ कार्य
कार्य जो एक ऐरे को लौटाता है
कार्य बिंदु
समारोह बिंदुओं की सरणी
शून्य सूचक का उपयोग कर कार्य
कार्य के रूप में कार्य संकेत

कार्य संकेत उदाहरण

उदाहरण के लिए, अगला कार्यक्रम दो के दो मूल्यों को स्वैप करता है:

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 100m is 100, n is 25

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

हम दो चर मानों की अदला-बदली के लिए फ़ंक्शन को जिम्मेदार घोषित करते हैं, जो दो पूर्णांक बिंदुओं को पैरामीटर के रूप में लेता है और जब इसे कहा जाता है तो कोई भी मूल्य वापस करता है।
मुख्य फ़ंक्शन में, हम दो पूर्णांक चर ('एम' और 'एन') घोषित करते हैं और फिर हम क्रमशः उनके मूल्यों को प्रिंट करते हैं।
हम दो वेरिएबल्स के पते को एम्परसेंड सिंबल का उपयोग करके स्वैप () फ़ंक्शन को कॉल करते हैं। उसके बाद, हम चर के नए स्वैप किए गए मानों को प्रिंट करते हैं।
यहां हम स्वैप () फ़ंक्शन सामग्री को परिभाषित करते हैं जो दो पूर्णांक चर पते को पैरामीटर के रूप में लेता है और एक अस्थायी भंडारण पूर्णांक चर घोषित करता है जो कि मूल्य चर में से एक को बचाने के लिए तीसरे भंडारण बॉक्स के रूप में उपयोग किया जाता है जिसे दूसरे चर में डाल दिया जाएगा।
अस्थायी चर में 'a' द्वारा बताए गए पहले चर की सामग्री को सहेजें।
एक द्वारा बताए गए पहले चर में 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

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

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

कार्य जो एक ऐरे को लौटाता है

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

#include 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);}

आउटपुट:

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

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

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

कार्य बिंदु

जैसा कि हम जानते हैं कि संकेत किसी भी स्मृति स्थान में एक पते की ओर संकेत करते हैं, वे निष्पादन योग्य कोड की शुरुआत में भी स्मृति में फ़ंक्शन के रूप में इंगित कर सकते हैं।

कार्य करने के लिए एक सूचक * के साथ घोषित किया जाता है, इसकी घोषणा का सामान्य कथन है:

return_type (*function_name)(arguments)

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

फ़ंक्शन पॉइंटर को परिभाषित करने के बाद, हमें इसे एक फ़ंक्शन पर असाइन करना होगा। उदाहरण के लिए, अगला प्रोग्राम एक साधारण फ़ंक्शन घोषित करता है, एक फ़ंक्शन पॉइंटर को परिभाषित करता है, फ़ंक्शन पॉइंटर को साधारण फ़ंक्शन को असाइन करता है और उसके बाद पॉइंटर के माध्यम से फ़ंक्शन को कॉल करता है:

#include 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");}

आउटपुट:

HiHiHi

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

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

नोट: फ़ंक्शन असाइनमेंट और फ़ंक्शन कॉल के दौरान पता ऑपरेटर और अप्रत्यक्ष ऑपरेटर * सम्मिलित करना महत्वपूर्ण नहीं है।

समारोह बिंदुओं की सरणी

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

#include 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 48Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: 2624

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

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

निर्देश int (* ope [4]) (int, int); फ़ंक्शन पॉइंटर्स की सरणी को परिभाषित करता है। प्रत्येक सरणी तत्व में एक ही पैरामीटर और वापसी प्रकार होना चाहिए।

कथन परिणाम = ope [पसंद] (x, y); उपयोगकर्ता द्वारा किए गए चुनाव के अनुसार उपयुक्त फ़ंक्शन को चलाता है। दो दर्ज किए गए पूर्णांक फ़ंक्शन के लिए दिए गए तर्क हैं।

शून्य सूचक का उपयोग कर कार्य

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

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

 void * cube (const void *);

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

#include 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

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

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

कार्य के रूप में कार्य संकेत

एक फ़ंक्शन पॉइंटर का शोषण करने का दूसरा तरीका, इसे किसी अन्य फ़ंक्शन के तर्क के रूप में कभी-कभी "कॉलबैक फ़ंक्शन" कहा जाता है क्योंकि प्राप्त फ़ंक्शन "इसे वापस कॉल करता है।"

Stdlib.h शीर्ष लेख फ़ाइल में, क्विकसॉर्ट "qsort ()" फ़ंक्शन इस तकनीक का उपयोग करता है जो एक सरणी को सॉर्ट करने के लिए समर्पित एक एल्गोरिथ्म है।

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

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

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

#include #include 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

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

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