सी भाषा में, फंक्शन (Function) एक समूह कोड लाइन होता है जो कुछ विशिष्ट कार्यों को करने के लिए उपलब्ध होता है। यह कार्यों को बार-बार लिखने से बचाता है जो प्रोग्रामिंग में एक महत्वपूर्ण सिद्धांत है। प्रत्येक सी प्रोग्राम में कम से कम एक फ़ंक्शन होता है, जो कि main () है।
फंक्शन को एक नाम दिया जाता है जो पहले से ही परिभाषित होता है। जब फंक्शन को कॉल किया जाता है, तो इसे एक या एक से अधिक आर्ग्यूमेंट दिए जाते हैं, और फंक्शन उन आर्ग्यूमेंट के साथ कार्य करना शुरू करता है। फंक्शन की गणना के बाद, इसे फिर से कॉल कर सकते हैं जिससे यह कार्यों को बार-बार दोहराने से बचाता है।
Function को Defining करना
सी भाषा में फंक्शन को निर्धारित करने के लिए निम्नलिखित विधि का पालन करें:
return_type function_name(parameter1, parameter2, ..., parameterN) {
// Function body
return expression;
}
यहां,
- return_type एक डेटा टाइप होता है जो फंक्शन द्वारा रिटर्न किए जाने वाले मान का टाइप निर्दिष्ट करता है। यदि फंक्शन कुछ भी रिटर्न नहीं करता है, तो इसके लिए void टाइप का उपयोग किया जाता है।
- function_name फंक्शन का नाम होता है।
- parameter1, parameter2, ..., parameterN फंक्शन के आर्ग्युमेंट होते हैं। आर्ग्युमेंट फंक्शन में पास किए जाने वाले मान होते हैं। यदि फंक्शन को कोई आर्ग्युमेंट पास नहीं किया जाता है, तो void या () का उपयोग किया जाता है।
- // Function body फंक्शन का बॉडी होता है, जो फंक्शन का लॉजिक निर्दिष्ट करता है। फंक्शन बॉडी में एकाधिक स्टेटमेंट हो सकते हैं।
- return स्टेटमेंट द्वारा फंक्शन द्वारा रिटर्न किया जाने वाला मान निर्दिष्ट किया जाता है। इसके बिना, फंक्शन द्वारा कोई भी मान रिटर्न नहीं होता है।
इसके लिए एक उदाहरण के लिए, यदि हम दो संख्याओं का योग करने के लिए एक फंक्शन बनाना चाहते हैं तो हम इस प्रकार कोड लिख सकते हैं:
int addNumbers(int a, int b) {
int sum = a + b;
return sum;
}
इस उदाहरण में,
- int फंक्शन द्वारा रिटर्न किए जाने वाले मान का टाइप है,
- addNumbers फंक्शन का नाम है,
- a और b फंक्शन के आर्ग्युमेंट हैं और
- sum फंक्शन का बॉडी है। फंक्शन बॉडी में हमने दो संख्याओं का योग करने के लिए + ऑपरेटर का उपयोग किया और उसे sum में संग्रहित किया। फंक्शन बॉडी के
- अंत में, हमने return स्टेटमेंट द्वारा फंक्शन द्वारा रिटर्न किए जाने वाले मान को निर्दिष्ट किया है।
एक बार जब आप फंक्शन को निर्धारित कर लेते हैं, आप उसे अन्य स्थानों पर भी इस्तेमाल कर सकते हैं, जिससे आपको कोड को दोहराने की जरूरत नहीं होती है।
एक सरल उदाहरण के रूप में, निम्नलिखित फंक्शन दो संख्याओं का योग करता है और उनका योग वापस लौटाता है:
int sum(int a, int b) {
int result = a + b;
return result;
}
इस उदाहरण में, sum नाम के फंक्शन निर्दिष्ट किया गया है जो दो इंटीजर आर्ग्यूमेंट लेता है। इसके बाद, इसे आर्ग्यूमेंट के योग से परिणत रिजल्ट में संचित करता है, और फिर इसे return स्टेटमेंट के माध्यम से उस रिजल्ट को वापस लौटाता है।
जब इस फंक्शन को कॉल किया जाता है, उसे दो इंटीजर आर्ग्यूमेंट दिए जाते हैं। फंक्शन फिर उन आर्ग्यूमेंट के योग करता है, जिससे रिजल्ट का मान उस फंक्शन के कॉलर में वापस लौट जाता है।
उदाहरण के लिए, निम्न विभिन्न फंक्शन कॉल किए जा सकते हैं:
int main() {
int x = 5, y = 10;
int z = sum(x, y); // Call the sum() function
printf("%d", z); // Output the result of the function call
return 0;
}
इस उदाहरण में, main फंक्शन दो इंटीजर वेरिएबल x और y के साथ शुरू होता है। फिर sum फंक्शन को x और y के साथ कॉल कर उसका रिजल्ट z में संचित किया जाता है। अंत में, printf स्टेटमेंट के माध्यम से z का मान आउटपुट किया जाता है।
Function का Declarations करना
C भाषा में, फंक्शन के डिक्लेअरेशन को function prototype कहा जाता है। फंक्शन के prototype में, हम फंक्शन के नाम, फंक्शन के आर्ग्युमेंट के टाइप और फंक्शन के रिटर्न टाइप को निर्दिष्ट करते हैं।
फंक्शन के prototype को निर्दिष्ट करने का मुख्य उद्देश्य फंक्शन के उपयोग को सुगम बनाना होता है। जब आप फंक्शन को prototype के साथ डिक्लेअर करते हैं, तो आपको बाद में उसे कहीं भी इस्तेमाल करने की आवश्यकता नहीं होती है।
फंक्शन के prototype को निर्दिष्ट करने के लिए, आप फंक्शन के नाम, फंक्शन के आर्ग्युमेंट के टाइप और फंक्शन के रिटर्न टाइप को निर्दिष्ट करते हैं।
यहां एक उदाहरण है:
// Function prototype or declaration
int addNumbers(int, int);
int main() {
int result = addNumbers(3, 4);
return 0;
}
// Function definition
int addNumbers(int a, int b) {
int sum = a + b;
return sum;
}
इस उदाहरण में, हमने addNumbers फंक्शन के prototype को int addNumbers(int, int); रूप में निर्दिष्ट किया है। main फंक्शन में, हम addNumbers फंक्शन को इस्तेमाल करते हुए दो संख्याओं का योग करते हुए result में संग्रहित करते हैं। फंक्शन का definition हमने prototype के बाद दिया है।
Function को Call करना
C भाषा में, फंक्शन को कॉल करने के लिए हम फंक्शन के नाम का उपयोग करते हैं जिसे हमने फंक्शन के prototype या डिक्लेरेशन में निर्दिष्ट किया होता है।
फंक्शन को कॉल करने के लिए, हम फंक्शन के नाम के बाद ब्रैकेट लगाकर फंक्शन के आर्ग्युमेंट यदि होते हैं तो उन्हें भेजते हैं। आर्ग्युमेंट इसलिए भेजे जाते हैं क्योंकि फंक्शन के भीतर उनका उपयोग करते हुए कार्य किया जाता है।
यहां एक उदाहरण है:
#include <stdio.h>
// Function prototype
int addNumbers(int, int);
int main() {
int result = addNumbers(3, 4);
printf("The sum of 3 and 4 is %d\n", result);
return 0;
}
// Function definition
int addNumbers(int a, int b) {
int sum = a + b;
return sum;
}
इस उदाहरण में, हम addNumbers फंक्शन को int result = addNumbers(3, 4); रूप में कॉल कर रहे हैं। इसके बाद, हम result को printf का उपयोग करके प्रिंट करते हैं। addNumbers फंक्शन को int addNumbers(int, int); रूप में डिक्लेर किया गया था।
Function Arguments
C भाषा में, फंक्शन arguments उन वेरिएबल्स को कहते हैं जो फंक्शन के अंदर भेजे जाते हैं जिनका फंक्शन के भीतर उपयोग करके काम किया जाता है।
फंक्शन को डिफाइन करते समय, हम फंक्शन के प्रत्येक आर्ग्युमेंट के लिए उनके डेटा टाइप और उनके नाम का निर्दिष्ट करते हैं। ये arguments फंक्शन को कॉल करते समय, फंक्शन के नाम के बाद कुंजी विशिष्ट फंक्शन के लिए निर्दिष्ट होते हैं।
एक उदाहरण के रूप में, यदि हम एक फंक्शन addNumbers डिफाइन करना चाहते हैं जो दो संख्याओं को जोड़ता है, तो हम इसे इस तरह से लिख सकते हैं:
int addNumbers(int a, int b) {
int sum = a + b;
return sum;
}
यहां, int a और int b दो arguments हैं जो addNumbers फंक्शन के अंदर भेजे जा सकते हैं। फिर इस फंक्शन में हम इन arguments का उपयोग करते हुए a और b को जोड़ते हैं और इसका परिणाम sum में स्थानित करते हैं, जो फिर लौटाया जाता है।
function को call करना
C भाषा में, function को कई तरीकों से call किया जा सकता है, निम्नलिखित हैं:
Call by Value: इस method में, function को value के रूप में argument pass किया जाता है। function के अंदर argument के value की copy बनाई जाती है, जिसके बाद function के अंदर value को मॉडिफाई करने की कोई संभावना नहीं होती है।
Call by Pointer: इस method में, function को argument के address के रूप में pass किया जाता है। function के अंदर argument के address से value को access किया जा सकता है और फिर value को मॉडिफाई कर सकते हैं।
Call by Reference: इस method में, function को argument को उसके reference के रूप में pass किया जाता है। इसमें, function के अंदर argument का address पास किया जाता है जिसके बाद function के अंदर argument को मॉडिफाई करने की संभावना होती है।
एक उदाहरण के रूप में, यदि हम एक function swap बनाना चाहते हैं जो दो variables को swap करता है, तो हम इसे इस तरह से लिख सकते हैं:
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
इसमें, swap function को Call by Pointer का use करते हुए लिखा गया है, जिससे यह function दो variables को swap करने में सक्षम होता है।
Function call by value
C programming में, function को Call by Value का use करके argument को pass किया जाता है। Call by Value में, function के parameter में एक value की copy बनाई जाती है और फिर function में इस copy के साथ काम किया जाता है। इस process में, original argument की copy बनाई जाती है और function में original argument को modify करने के लिए कोई संभावना नहीं होती है।
एक उदाहरण के रूप में, यदि हम एक function square बनाना चाहते हैं जो एक number का square करता है, तो हम इसे इस तरह से लिख सकते हैं:
int square(int num) {
int result = num * num;
return result;
}
इस function में, num एक parameter है जिसे Call by Value के रूप में pass किया जाता है। इस parameter की copy बनाई जाती है और function के अंदर copy के साथ काम किया जाता है। यदि हम इस function को main function से call करते हैं, तो हम इसे इस तरह से लिख सकते हैं:
int main() {
int num = 5;
int result = square(num);
printf("Square of %d is %d", num, result);
return 0;
}
इसमें, num एक variable है जिसमें 5 की value होती है। result variable में square function का output store किया जाता है। printf function के माध्यम से, num की value और square function का output print किया जाता है।
इस method का use करने के फायदे में से एक है कि यह बहुत सरल होता है और इसका overhead कम होता है। इस method के नुकसान में से एक है कि यह अस्पष्ट हो सकता है जब हम function के अंदर original argument को modify करने की कोशिश करते हैं, लेकिन केवल copy को modify किया जा सकता है जो function में local होता है।
इसलिए, Call by Value का use करते समय, हम ध्यान रखने की आवश्यकता होती है कि हम original argument को modify नहीं कर सकते हैं, बल्कि केवल copy के साथ काम कर सकते हैं।
C भाषा में Function call by value का उदहारण
यदि हमें किसी Function में एक या एक से अधिक arguments को पास करना होता है, तो उन्हें Function में call by value या call by reference के अनुसार pass किया जा सकता है।
जब हम Function को call by value के रूप में call करते हैं, तो उस argument की value की कॉपी Function के parameter के रूप में पास की जाती है। यदि Function में उस parameter की value को modify किया जाता है, तो यह सिर्फ उस local parameter को modify करेगा, न कि वास्तविक argument को।
इसके एक उदाहरण के रूप में, यदि हमें दो integers को add करना होता है, तो हम Function को call by value के रूप में call कर सकते हैं।
#include <stdio.h>
int add(int a, int b) {
int sum = a + b;
return sum;
}
int main() {
int num1 = 10, num2 = 20, result;
result = add(num1, num2);
printf("The sum is %d\n", result);
return 0;
}
इस उदाहरण में, add() Function को call by value के रूप में call किया गया है, जहाँ num1 और num2 की values add() Function में parameter के रूप में copy की गई हैं। Function में, sum की value बनाई गई है और फिर वह फिरसे main() Function में return की जाती है, जहाँ result variable में store की जाती है।
function Call by Reference
जब हम Function को call by reference के रूप में call करते हैं, तो उस argument का address Function के parameter के रूप में पास किया जाता है। इससे, Function में उस address के द्वारा argument की value को modify किया जा सकता है, जो वास्तविक argument को modify कर देता है।
इसके एक उदाहरण के रूप में, यदि हमें Function में दो integers को swap करना होता है, तो हम Function को call by reference के रूप में call कर सकते हैं।
#include <stdio.h>
void swap(int *a, int *b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
}
int main() {
int num1 = 10, num2 = 20;
printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2);
swap(&num1, &num2);
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}
इस उदाहरण में, swap() Function को call by reference के रूप में call किया गया है, जहाँ num1 और num2 के addresses swap() Function में parameter के रूप में pass किए गए हैं। Function में, temp वेरिएबल का use करके num1 और num2 की values को swap किया जाता है। फिर main() Function में printf() के द्वारा स्वचालित रूप से बदली हुई values देखी जाती हैं।
function Call by Reference का उदाहरण
एक उदाहरण के रूप में, देखें कि कैसे Function को call by reference के रूप में call किया जाता है और कैसे Function में argument को modify किया जाता है।
#include <stdio.h>
void increment(int *x) {
*x = *x + 1;
}
int main() {
int num = 5;
printf("Before function call, num = %d\n", num);
increment(&num);
printf("After function call, num = %d\n", num);
return 0;
}
इस उदाहरण में, increment() Function को call by reference के रूप में call किया गया है, जहाँ num के address increment() Function में parameter के रूप में pass किए गए हैं। Function में, *x के value को 1 बढ़ाया जाता है। फिर main() Function में printf() के द्वारा स्वचालित रूप से modify हुआ num वेरिएबल देखा जाता है।
function Call by Pointer
C भाषा में Function Call by Pointer का उपयोग करने से, Function में argument की value को modify किया जा सकता है और इससे एक pointer की मदद से किया जाता है। Pointer एक variable होता है जो memory address को store करता है।
Function Call by Pointer के लिए, Function में pointer variable को argument के रूप में pass किया जाता है। फिर Function में, pointer के द्वारा memory address के value को modify किया जाता है। जब Function समाप्त होता है, तो pointer variable के value द्वारा modify किया गया memory address का value original calling function में भी modify होता है।
इसका एक उदाहरण निम्नलिखित है:
#include <stdio.h>
void increment(int *x) {
(*x)++;
}
int main() {
int num = 5;
printf("Before function call, num = %d\n", num);
increment(&num);
printf("After function call, num = %d\n", num);
return 0;
}
इस उदाहरण में, increment() Function को pointer के रूप में pass किया गया है, जिससे Function में pointer के द्वारा memory address का value modify किया जाता है। इसके बाद main() Function में, printf() के द्वारा modify हुआ num variable देखा जा सकता है।
function Call by Pointer का उदाहरण
एक उदाहरण के रूप में, यदि हम दो नंबरों के योग की मानदंड बदलना चाहते हैं, तो हम फ़ंक्शन को Call by Pointer के द्वारा पास कर सकते हैं। निम्नलिखित कोड उदाहरण को देखें:
#include <stdio.h>
void add(int* x, int* y, int* result) {
*result = *x + *y;
}
int main() {
int a = 10;
int b = 20;
int c;
add(&a, &b, &c);
printf("a + b = %d\n", c);
return 0;
}
इस कोड में, add() फ़ंक्शन को 3 arguments पास किए जाते हैं, int* x, int* y, और int* result। इनमें से हर एक pointer int प्रकार की मानदंड को दर्शाता है।
add() फ़ंक्शन में, x और y pointers के द्वारा मानदंड के value को access किया जाता है, और इनके योग का परिणाम result pointer के value में सेट किया जाता है।
main() Function में, a और b variables के memory address को & ऑपरेटर के साथ pointer variables int* x और int* y को pass किया जाता है। इसके बाद, c variable के memory address को int* result pointer variable के साथ pass किया जाता है। जब add() Function call होता है, तो उसमें x, y, और result pointers को access करके मानदंडों के योग का परिणाम result pointer के value में सेट कर दिया जाता है।
main() Function में, printf() के द्वारा modify हुई c variable की value देखी जा सकती है।
function को call करने के तरीको में अंतर
C भाषा में function को call करने के तीन तरीके होते हैं:
Call by Value: इसमें function को केवल arguments की value पास की जाती है और कोई reference नहीं होती है। function के arguments की value को copy किया जाता है और function में उस copy के साथ काम किया जाता है। इसमें original arguments के value में कोई बदलाव नहीं होता है।
Call by Reference: इसमें function को arguments की reference (या address) पास की जाती है जिससे function में जाकर arguments के value में changes कर सकते हैं। इसमें function में किसी variable की value को modify किया जा सकता है और वह change calling function में भी reflect होगा।
Call by Pointer: इसमें function को arguments की pointer पास की जाती है। Pointer एक variable होता है जो किसी variable की address को store करता है। इसमें भी function को arguments के address पास किए जाते हैं जिससे function में जाकर arguments के value में changes कर सकते हैं। Pointer के जरिए भी arguments की value में changes करने के लिए किसी variable की address को modify किया जाता है।
इन तीनों तरीकों में call by reference और call by pointer को value की तुलना में ज्यादा powerful माना जाता है क्योंकि इनमें function में किसी variable की value को modify करने का समर्थन होता है।
सभी तीन तरीकों में function को call करने के लिए हम एक function का prototype लिखते हैं और उसके बाद function को कॉल करते हैं।
यहाँ हम तीन तरीकों को निम्नलिखित उदाहरण के माध्यम से समझाएंगे:
1. Call by Value:
इसमें, argument की copy function में pass की जाती है। function की body में उस copy को modify करने से original value में कोई बदलाव नहीं होता है।
उदाहरण:
#include <stdio.h>
void square(int x) {
x = x * x;
printf("Square inside function: %d\n", x);
}
int main() {
int num = 4;
printf("Original number: %d\n", num);
square(num);
printf("Number after function call: %d\n", num);
return 0;
}
Output:
Original number: 4
Square inside function: 16
Number after function call: 4
2. Call by Reference:
इसमें, argument का address function में pass किया जाता है। function की body में उस address के through original value को modify किया जा सकता है।
उदाहरण:
#include <stdio.h>
void square(int *x) {
*x = (*x) * (*x);
printf("Square inside function: %d\n", *x);
}
int main() {
int num = 4;
printf("Original number: %d\n", num);
square(&num);
printf("Number after function call: %d\n", num);
return 0;
}
Output:
Original number: 4
Square inside function: 16
Number after function call: 16
3. Call by Pointer:
इसमें, pointer variable का address function में pass किया जाता है और function की body में pointer के through original value को modify किया जा सकता है।
उदाहरण:
#include <stdio.h>
void square(int *x) {
*x = (*x) * (*x);
printf("Square inside function: %d\n", *x);
}
int main() {
int num = 4;
int *ptr = #
printf("Original number: %d\n", num);
square(ptr);
printf("Number after function call: %d\n", num);
return 0;
}
Output:
Original number: 4
Square inside function: 16
Number after function call: 16