Chapter 13: Functions

📚 C Programming – पूरा Course सीखने का Roadmap

⬅ पिछला Chapter | Current Chapter: Functions | अगला Chapter ➜

Author: Er. Mujtaba Ansari

C Programs को simple, organized, reusable और easy to understand बनाते हैं Functions। इससे Program को पढ़ना, समझना और बाद में उसमें changes करना भी आसान हो जाता है।

Real-Life Uses of Functions: Functions का इस्तेमाल Games, Operating Systems, Mobile Applications,Banking Software, Calculators, Automation और Embedded Systems में अलग-अलग tasks को आसानी से और efficiently करने के लिए किया जाता है।

C Programming में Functions क्या होते हैं? पूरी जानकारी अब एक ही जगह पर

Introduction

C Programming में Functions एक बहुत important concept है। Function की मदद से हम किसी बड़े Program को छोटे-छोटे parts में divide कर सकते हैं।

इससे Program को लिखना, समझना, check करना और बाद में उसमें बदलाव करना आसान हो जाता है।

अगर किसी काम के लिए हमें बार-बार same code लिखना पड़ रहा है, तो उस code को एक Function में रखा जा सकता है और जरूरत पड़ने पर उस Function को दोबारा use किया जा सकता है।

C Programming में Function क्या है?

Function statements का एक ऐसा group होता है जो किसी particular task को perform करने के लिए बनाया जाता है।

आसान भाषा में कहें तो Function एक छोटा code block है जो किसी specific काम को करता है।

उदाहरण के लिए, अगर हमें दो numbers का sum निकालना है, तो हम इसके लिए एक Function बना सकते हैं।

int sum(int a, int b)
{
    return a + b;
}

अब जब भी हमें दो numbers का sum निकालना हो, हम sum() Function को call कर सकते हैं।

Functions के फायदे

Functions की मदद से हमारा Program:

• Simple और organized बनता है
• समझने में आसान होता है
• बार-बार use किया जा सकता है
• Debug करना आसान होता है
• Maintain करना आसान होता है
• Repeated code कम होता है

C में Functions के Types

C Programming में Functions को मुख्य रूप से दो categories में समझा जाता है:

1. Library Functions

Library Functions वे Functions होते हैं जो C की libraries में पहले से available होते हैं।

हमें इन्हें खुद बनाने की जरूरत नहीं होती। जरूरत के अनुसार हम इन्हें अपने Program में use कर सकते हैं।

कुछ common examples हैं:

printf()
scanf()
strlen()
strcpy()
sqrt()

उदाहरण:

printf("Hello World");

यहाँ printf() एक Library Function है।

2. User-Defined Functions

जब Programmer अपनी जरूरत के अनुसार खुद कोई Function बनाता है, तो उसे User-Defined Function कहते हैं।

उदाहरण:

int sum(int a, int b)
{
    return a + b;
}

यहाँ sum() एक User-Defined Function है।

User-Defined Function के 3 Important Steps

आमतौर पर एक User-Defined Function के साथ तीन important steps होते हैं:

1. Function Declaration या Prototype
2. Function Definition
3. Function Call

1. Function Declaration / Prototype

Function Declaration compiler को पहले से बताता है कि Program में कौन-सा Function use होने वाला है।

Function Prototype में आमतौर पर ये जानकारी दी जाती है:

• Function का नाम
• Return Type
• Parameters की संख्या
• Parameters के Data Types

Syntax

return_type function_name(parameter_list);

Example

int sum(int x, int y);

इसका मतलब है:

• Function का नाम sum है।
• Function int value return करेगा।
• Function दो parameters लेगा।
• दोनों parameters का type int है।

2. Function Definition

Function Definition में वह actual code लिखा जाता है जो Function का काम perform करता है।

यानी Function के अंदर जो statements लिखे जाते हैं, वही actual task perform करते हैं।

Syntax

return_type function_name(parameter_list)
{
    // Function body

    return value;
}

Example

int sum(int x, int y)
{
    int result;

    result = x + y;

    return result;
}

यहाँ sum() Function दो numbers को add करता है और result return करता है।

3. Function Call

Function को execute करने के लिए उसे call करना पड़ता है।

उदाहरण:

result = sum(10, 20);

यहाँ sum() Function को call किया गया है और 10 तथा 20 values pass की गई हैं।

Function का Complete Example

#include <stdio.h>

int sum(int x, int y);

int main(void)
{
    int result;

    result = sum(10, 20);

    printf("Sum = %d\n", result);

    return 0;
}

int sum(int x, int y)
{
    return x + y;
}

Output

Sum = 30

इस Program में:

• int sum(int x, int y); → Function Declaration
• int sum(int x, int y) → Function Definition
• sum(10, 20) → Function Call

Parameters और Arguments क्या होते हैं?

Function को जो values दी जाती हैं, उन्हें Arguments कहा जाता है।

Function के अंदर उन values को receive करने वाले variables को Parameters कहते हैं।

उदाहरण:

sum(10, 20);

यहाँ 10 और 20 Arguments हैं।

और:

int sum(int x, int y)

यहाँ x और y Parameters हैं।

आसान तरीके से:

Arguments → Function को दी जाने वाली values

Parameters → उन values को receive करने वाले variables

Function की मदद से Factorial निकालना

किसी positive integer N का factorial इस तरह निकाला जाता है:

N! = N × (N-1) × (N-2) × ... × 1

उदाहरण:

3! = 3 × 2 × 1
   = 6

👉 C Program: Function की मदद से Factorial

#include <stdio.h>

unsigned long long factorial(int n);

int main(void)
{
    int n;
    unsigned long long result;

    printf("Enter a number: ");
    scanf("%d", &n);

    if (n < 0)
    {
        printf("Factorial is not defined for negative numbers.\n");
        return 0;
    }

    result = factorial(n);

    printf("Factorial = %llu\n", result);

    return 0;
}

unsigned long long factorial(int n)
{
    unsigned long long fact = 1;
    int i;

    for (i = 1; i <= n; i++)
    {
        fact = fact * i;
    }

    return fact;
}

Example

अगर:

N = 3

तो calculation होगी:

1 × 2 × 3 = 6

Output:

Factorial = 6

Function से Series का Sum निकालना

Function का use mathematical series का sum निकालने के लिए भी किया जा सकता है।

उदाहरण:

1 + X + X² + X³ + ... + Xᴺ

👉 C Program: Function की मदद से Series का Sum निकालना

#include <stdio.h>

long long seriesSum(int n, int x);

int main(void)
{
    int n, x;
    long long result;

    printf("Enter N: ");
    scanf("%d", &n);

    printf("Enter X: ");
    scanf("%d", &x);

    result = seriesSum(n, x);

    printf("Series Sum = %lld\n", result);

    return 0;
}

long long seriesSum(int n, int x)
{
    long long sum = 0;
    long long term = 1;
    int i;

    for (i = 0; i <= n; i++)
    {
        sum += term;
        term *= x;
    }

    return sum;
}

अगर:

N = 3
X = 4

तो series होगी:

1 + 4 + 16 + 64 = 85

इसलिए:

Series Sum = 85

Note: अगर आपको X + X² + ... + Xᴺ वाली series चाहिए, तो Program में starting term को उसके अनुसार बदलना होगा।

Array को Function में Pass करना

C में हम Array को भी Function के पास भेज सकते हैं।

यह तब useful होता है जब हमें Array में मौजूद कई values पर कोई particular operation करना हो।

उदाहरण के लिए, हम एक Function बनाकर Array में सबसे बड़ी value यानी Largest Element find कर सकते हैं।

👉 C Program: Function की मदद से Array में सबसे बड़ी संख्या (Largest Element) निकालना

#include <stdio.h>

int largest(int arr[], int n);

int main(void)
{
    int arr[20];
    int n, i, result;

    printf("Enter number of elements: ");
    scanf("%d", &n);

    if (n <= 0 || n > 20)
    {
        printf("Invalid number of elements.\n");
        return 0;
    }

    printf("Enter %d elements:\n", n);

    for (i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }

    result = largest(arr, n);

    printf("Largest element = %d\n", result);

    return 0;
}

int largest(int arr[], int n)
{
    int i;
    int max = arr[0];

    for (i = 1; i < n; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }

    return max;
}

Important Point for YOU

C में Array का index 0 से शुरू होता है।

अगर Array में n elements हैं, तो valid indexes होंगे:

0 से n-1 तक

इसलिए loop में:

i < n

use करना चाहिए।

यह नहीं:

i <= n

2D Array को Function में Pass करना

C में Two-Dimensional Array यानी 2D Array को भी Function में pass किया जा सकता है।

उदाहरण के लिए, हम 3 × 3 Matrix का lower triangular part display करने के लिए Function बना सकते हैं।

👉 C Program: Function की मदद से Lower Triangular Matrix प्रिंट करना

#include <stdio.h>

void lower(int arr[][3]);

int main(void)
{
    int arr[3][3];
    int i, j;

    printf("Enter 9 elements of the matrix:\n");

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }

    printf("\nLower triangular matrix:\n");

    lower(arr);

    return 0;
}

void lower(int arr[][3])
{
    int i, j;

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            if (j <= i)
            {
                printf("%d ", arr[i][j]);
            }
            else
            {
                printf("  ");
            }
        }

        printf("\n");
    }
}

Example

अगर Matrix है:

1 2 3
4 5 6
7 8 9

तो Lower Triangular Matrix होगी:

1
4 5
7 8 9

Function की मदद से दो Strings को Concatenate करना

String Concatenation का मतलब है दो Strings को जोड़कर एक String बनाना।

उदाहरण:

Hello + World

बन जाएगा:

HelloWorld

👉 C Program: Function की मदद से दो Strings को Concatenate करना

#include <stdio.h>
#include <string.h>

void concat(char x[], const char y[]);

int main(void)
{
    char a[50];
    char b[25];

    printf("Enter first string: ");
    fgets(a, sizeof(a), stdin);

    printf("Enter second string: ");
    fgets(b, sizeof(b), stdin);

    a[strcspn(a, "\n")] = '\0';
    b[strcspn(b, "\n")] = '\0';

    concat(a, b);

    printf("Concatenated string = %s\n", a);

    return 0;
}

void concat(char x[], const char y[])
{
    int i = 0;
    int j = 0;

    while (x[i] != '\0')
    {
        i++;
    }

    while (y[j] != '\0')
    {
        x[i] = y[j];
        i++;
        j++;
    }

    x[i] = '\0';
}

Important Note for YOU

जिस Array में दोनों Strings को जोड़ना है, उसमें दोनों Strings को रखने के लिए पर्याप्त space होना चाहिए।

👉 C Program: Function की मदद से एक String को दूसरी String में Copy करना

User-Defined Function की मदद से एक String को दूसरी String में copy भी किया जा सकता है।

#include <stdio.h>
#include <string.h>

void copyString(char destination[], const char source[]);

int main(void)
{
    char source[50];
    char destination[50];

    printf("Enter a string: ");
    fgets(source, sizeof(source), stdin);

    source[strcspn(source, "\n")] = '\0';

    copyString(destination, source);

    printf("Copied string = %s\n", destination);

    return 0;
}

void copyString(char destination[], const char source[])
{
    int i = 0;

    while (source[i] != '\0')
    {
        destination[i] = source[i];
        i++;
    }

    destination[i] = '\0';
}

Copy और Concatenation में Difference

Copy:

Source → Destination

इसमें एक String को दूसरी जगह copy किया जाता है।

Concatenation:

String 1 + String 2 → Combined String

इसमें दो Strings को जोड़कर एक String बनाई जाती है।

Nested Function Calls

जब एक Function के अंदर से दूसरा Function call किया जाता है, तो इसे commonly Nested Function Call कहा जाता है।

उदाहरण:

main()
   ↓
sum()
   ↓
square()

या:

main()
   ↓
sum()
   ↓
cube()

Important Technical Point for YOU

Standard C में एक Function को दूसरे Function के अंदर define नहीं किया जा सकता।

लेकिन एक Function दूसरे Function को call कर सकता है।

👉 C Program: Functions की मदद से Square और Cube का Sum निकालना

#include <stdio.h>

int square(int n);
int cube(int n);
int sum(int n);

int main(void)
{
    int n;
    int result;

    printf("Enter a number: ");
    scanf("%d", &n);

    result = sum(n);

    printf("Sum of square and cube = %d\n", result);

    return 0;
}

int square(int n)
{
    return n * n;
}

int cube(int n)
{
    return n * n * n;
}

int sum(int n)
{
    return square(n) + cube(n);
}

अगर:

N = 3

तो:

Square = 3² = 9
Cube = 3³ = 27

Sum = 9 + 27
    = 36

C में Recursion क्या है?

Recursion एक ऐसी programming technique है जिसमें कोई Function खुद को ही call करता है।

Recursive Function में एक ऐसी condition होना बहुत जरूरी है जो Function की calling को stop कर सके।

Recursion में मुख्य रूप से दो important parts होते हैं:

1. Base Case

यह वह condition है जहाँ recursion रुक जाता है।

2. Recursive Case

इस part में Function खुद को फिर से call करता है।

General Structure

return_type function()
{
    if (base_condition)
    {
        return value;
    }

    return function();
}

Recursion से Factorial निकालना

Factorial के लिए formula है:

N! = N × (N-1)!

और इसका base case है:

0! = 1

👉 C Program: Function की मदद से Recursion द्वारा Factorial निकालना

#include <stdio.h>

unsigned long long factorial(int n);

int main(void)
{
    int n;

    printf("Enter a number: ");
    scanf("%d", &n);

    if (n < 0)
    {
        printf("Factorial is not defined for negative numbers.\n");
        return 0;
    }

    printf("Factorial = %llu\n", factorial(n));

    return 0;
}

unsigned long long factorial(int n)
{
    if (n == 0 || n == 1)
    {
        return 1;
    }

    return (unsigned long long)n * factorial(n - 1);
}

Program की Working

अगर:

factorial(3)

call किया जाए, तो calls कुछ इस तरह आगे बढ़ेंगी:

3 × factorial(2)
        ↓
      2 × factorial(1)
              ↓
                1

इसलिए:

3 × 2 × 1 = 6

Recursion से GCD / HCF और LCM

GCD या HCF वह सबसे बड़ी संख्या होती है जो दो numbers को बिना remainder के divide कर सकती है।

Euclidean Algorithm में:

GCD(a, b) = GCD(b, a % b)

का use किया जाता है।

यह process तब तक चलता है जब तक remainder 0 न हो जाए।

👉 C Program: Function की मदद से GCD (HCF) और LCM निकालना

#include <stdio.h>
#include <stdlib.h>

long long gcd(long long a, long long b);

int main(void)
{
    long long x, y;
    long long g, lcm;

    printf("Enter two numbers: ");
    scanf("%lld %lld", &x, &y);

    if (x == 0 && y == 0)
    {
        printf("GCD and LCM are undefined for 0 and 0.\n");
        return 0;
    }

    g = gcd(llabs(x), llabs(y));

    if (x == 0 || y == 0)
    {
        lcm = 0;
    }
    else
    {
        lcm = llabs((x / g) * y);
    }

    printf("GCD/HCF = %lld\n", g);
    printf("LCM = %lld\n", lcm);

    return 0;
}

long long gcd(long long a, long long b)
{
    if (b == 0)
    {
        return a;
    }

    return gcd(b, a % b);
}

Example

अगर:

X = 12
Y = 18

तो:

GCD(12,18)
→ GCD(18,12)
→ GCD(12,6)
→ GCD(6,0)
→ 6

इसलिए:

GCD = 6
LCM = 36

Recursion से First N Natural Numbers के Squares का Sum

Squares का sum इस तरह लिखा जाता है:

1² + 2² + 3² + ... + N²

👉 C Program: Function और Recursion की मदद से N तक Squares का Sum निकालना

#include <stdio.h>

long long sumSquares(int n);

int main(void)
{
    int n;

    printf("Enter N: ");
    scanf("%d", &n);

    if (n < 0)
    {
        printf("Please enter a non-negative number.\n");
        return 0;
    }

    printf("Sum of squares = %lld\n", sumSquares(n));

    return 0;
}

long long sumSquares(int n)
{
    if (n == 0)
    {
        return 0;
    }

    return (long long)n * n + sumSquares(n - 1);
}

अगर:

N = 3

तो:

1² + 2² + 3²
= 1 + 4 + 9
= 14

Recursion से Fibonacci Series

Fibonacci Series में हर अगली value पिछली दो values को जोड़कर मिलती है।

Common Fibonacci sequence:

0 1 1 2 3 5 8 13 ...

इसका formula है:

F(n) = F(n-1) + F(n-2)

जहाँ:

F(0) = 0
F(1) = 1

👉 C Program: Function और Recursion की मदद से Fibonacci Series प्रिंट करना

#include <stdio.h>

int fibonacci(int n);

int main(void)
{
    int n, i;

    printf("Enter number of terms: ");
    scanf("%d", &n);

    if (n <= 0)
    {
        printf("Please enter a positive number.\n");
        return 0;
    }

    printf("Fibonacci Series: ");

    for (i = 0; i < n; i++)
    {
        printf("%d ", fibonacci(i));
    }

    printf("\n");

    return 0;
}

int fibonacci(int n)
{
    if (n == 0)
    {
        return 0;
    }

    if (n == 1)
    {
        return 1;
    }

    return fibonacci(n - 1) + fibonacci(n - 2);
}

Example

अगर 7 terms चाहिए, तो output होगा:

0 1 1 2 3 5 8

Note: कुछ books Fibonacci Series को 1 1 2 3 5... से भी शुरू करती हैं। लेकिन ऊपर के Program में 0, 1 वाली standard programming definition use की गई है।

Function को Values Pass करने के तरीके

Function को Arguments देने के अलग-अलग तरीके हो सकते हैं।

इस Chapter में दो common methods important हैं:

1. Call by Value
2. Call by Address using Pointers

1. Call by Value क्या है?

Call by Value में Function को original variable की value की एक copy दी जाती है।

इसलिए Function के अंदर parameter की value बदलने पर original variable की value change नहीं होती।

उदाहरण:

void change(int x)
{
    x = 100;
}

अगर:

int a = 10;

change(a);

तो a की value बाद में भी:

10

ही रहेगी।

क्योंकि Function को a की original variable नहीं, बल्कि उसकी value की copy मिली थी।

👉 C Program: Function में Call by Value से Two Numbers को Swap करना

#include <stdio.h>

void swap(int p, int q);

int main(void)
{
    int a = 10;
    int b = 20;

    printf("Before function call:\n");
    printf("A = %d, B = %d\n", a, b);

    swap(a, b);

    printf("\nAfter function call:\n");
    printf("A = %d, B = %d\n", a, b);

    return 0;
}

void swap(int p, int q)
{
    int temp;

    temp = p;
    p = q;
    q = temp;

    printf("\nInside function:\n");
    printf("P = %d, Q = %d\n", p, q);
}

समझिए

Function के अंदर values swap हो जाएंगी, लेकिन main() के original variables में कोई change नहीं होगा।

ऐसा इसलिए होता है क्योंकि C में Arguments by value pass होते हैं।

2. Call by Address Using Pointers

C में दूसरे programming languages की तरह true Call by Reference parameters नहीं होते।

C में arguments हमेशा value के रूप में pass होते हैं। लेकिन हम किसी variable का address Pointer के द्वारा Function को दे सकते हैं।

इससे Function original variable की value को change कर सकता है।

इसे commonly इन नामों से भी समझा जाता है:

• Call by Address
• Passing by Address
• Pointer-based Parameter Passing

👉 C Program: Function और Pointers की मदद से Two Numbers को Swap करना

#include <stdio.h>

void swap(int *p, int *q);

int main(void)
{
    int a = 10;
    int b = 20;

    printf("Before swapping:\n");
    printf("A = %d, B = %d\n", a, b);

    swap(&a, &b);

    printf("\nAfter swapping:\n");
    printf("A = %d, B = %d\n", a, b);

    return 0;
}

void swap(int *p, int *q)
{
    int temp;

    temp = *p;
    *p = *q;
    *q = temp;
}

Output

Before swapping:
A = 10, B = 20

After swapping:
A = 20, B = 10

यहाँ:

&a

का मतलब है a का address।

और:

*p

का मतलब है उस address पर मौजूद value।

C में Functions के 4 Common Forms

Arguments और Return Value के आधार पर Functions को चार common forms में समझा जा सकता है।

1. No Arguments और No Return Value

इस Function में कोई Argument नहीं लिया जाता और कोई value return नहीं की जाती।

void display(void)
{
    printf("Hello");
}

2. Arguments लेकिन No Return Value

इसमें Function arguments लेता है लेकिन कोई value return नहीं करता।

void display(int n)
{
    printf("%d", n);
}

3. No Arguments लेकिन Return Value

इसमें Function कोई Argument नहीं लेता, लेकिन एक value return करता है।

int getNumber(void)
{
    return 10;
}

4. Arguments और Return Value

इसमें Function Arguments भी लेता है और result भी return करता है।

int sum(int a, int b)
{
    return a + b;
}

यह Function form real-world Programs में बहुत commonly use किया जाता है।

Local Variable और Global Variable

Local Variable

जो Variable किसी Function या Block के अंदर declare किया जाता है, उसे Local Variable कहते हैं।

उदाहरण:

void test(void)
{
    int x = 10;
}

यहाँ x का scope उसी जगह तक सीमित रहता है जहाँ वह declare किया गया है।

Global Variable

जो Variable सभी Functions के बाहर declare किया जाता है, उसे Global Variable कहते हैं।

उदाहरण:

int count = 0;

int main(void)
{
    printf("%d", count);
    return 0;
}

Global Variable को उसके scope के अनुसार एक से अधिक Functions में access किया जा सकता है।

Best Practice

जहाँ possible हो, Local Variables को prefer करना बेहतर होता है, क्योंकि इससे Program को समझना और maintain करना आसान रहता है।

Recursion और Iteration में Difference

Recursion	Iteration
Function खुद को call करता है	Loop statements को repeat करता है
Function Call Stack का use होता है	आमतौर पर कम memory की जरूरत होती है
कुछ problems को समझना आसान बना सकता है	Repetitive calculations में अक्सर efficient होता है
Base Case की जरूरत होती है	Loop Condition की जरूरत होती है
Tree और Divide-and-Conquer problems में useful	Repeated calculations में useful

Iteration Example

for (i = 1; i <= n; i++)
{
    printf("%d ", i);
}

Recursion Example

void print(int n)
{
    if (n == 0)
        return;

    print(n - 1);
}

Functions Use करते समय होने वाली Common Mistakes

Mistake 1: Function Prototype भूल जाना

अगर Function को उसकी Definition से पहले use किया जा रहा है, तो उसका Prototype पहले declare करना चाहिए।

int sum(int, int);

Mistake 2: गलत Return Type

Function जिस type की value return करता है, उसका Return Type उसी के अनुसार होना चाहिए।

उदाहरण:

int sum(int a, int b)
{
    return a + b;
}

यहाँ Function int value return कर रहा है, इसलिए Return Type int है।

Mistake 3: Array में <= का गलत use

गलत:

for (i = 0; i <= n; i++)

सही:

for (i = 0; i < n; i++)

क्योंकि n elements वाले Array का last valid index n-1 होता है।

Mistake 4: Recursion में Base Case भूल जाना

हर Recursive Function में ऐसी condition होनी चाहिए जो recursion को stop करे।

अगर Base Case सही नहीं है, तो Function बार-बार खुद को call कर सकता है और अंत में Program का stack भर सकता है।

Mistake 5: Copy और Concatenation को एक जैसा समझना

Copy में एक String का content दूसरी जगह copy किया जाता है।

Source → Destination

जबकि Concatenation में दो Strings को जोड़ दिया जाता है।

String 1 + String 2 → Combined String

Mistake 6: gets() का इस्तेमाल करना

पुराना gets() Function unsafe माना जाता है और इसका use नहीं करना चाहिए।

इसके बजाय:

fgets()

का use करें।

Old Turbo C Code और Modern C में Difference

पुराने C Programming examples में अक्सर इस तरह का code दिखाई देता है:

#include <conio.h>
clrscr();
getch();
void main()

ये पुराने Turbo C आधारित examples और textbooks में काफी common थे।

लेकिन Modern C Programming में standard approach को prefer करना चाहिए:

#include <stdio.h>

int main(void)
{
    return 0;
}

Input लेने के लिए भी unsafe पुराने Functions की जगह standard और safer approach जैसे:

fgets()

का use करना बेहतर है।

Functions के Real-Life Applications

Functions केवल छोटे Programming examples में ही नहीं, बल्कि real-world software में भी बहुत important होते हैं।

बड़े Software में अलग-अलग कामों के लिए अलग Functions बनाए जाते हैं। इससे पूरे Program को manage करना आसान हो जाता है।

Banking Software

Banking Applications में अलग-अलग कामों के लिए Functions हो सकते हैं:

deposit()
withdraw()
checkBalance()
transferMoney()

Calculator Applications

Calculator में अलग calculations के लिए Functions बनाए जा सकते हैं:

addition()
subtraction()
multiplication()
division()

Games

Games में अलग-अलग tasks के लिए Functions use किए जा सकते हैं:

movePlayer()
calculateScore()
checkCollision()
updateGame()

Operating Systems

Operating Systems में Functions जैसे कामों को manage करने में मदद करते हैं:

Memory Management
File Operations
Process Management
Device Handling

Embedded Systems

Embedded Systems में Functions का use कई तरह के tasks के लिए होता है:

Sensor Reading
Motor Control
Display Control
Communication

Functions के Advantages

Functions use करने से C Program में कई फायदे होते हैं।

1. Code Reusability

एक बार code लिखकर उसे कई जगह use किया जा सकता है।

2. Modularity

एक बड़े Program को छोटे-छोटे Functions में divide किया जा सकता है।

3. Easy Debugging

हर Function को अलग से test और debug करना आसान होता है।

4. Better Readability

Functions की वजह से Program का code समझना आसान हो जाता है।

5. Easy Maintenance

अगर किसी particular task में बदलाव करना हो, तो अक्सर उसी Function में बदलाव करना पड़ता है।

6. Less Code Duplication

एक ही logic को बार-बार लिखने की जरूरत नहीं होती। उसे एक Function में रखकर जरूरत के अनुसार call किया जा सकता है।

Quick Revision – Functions in C

Function क्या है?

Function code का एक reusable block है जो किसी specific task को perform करने के लिए बनाया जाता है।

Functions के मुख्य Types

1. Library Functions
2. User-Defined Functions

User-Defined Function के 3 Main Steps

1. Declaration
2. Definition
3. Function Call

Recursion

जब कोई Function खुद को call करता है, तो उसे Recursion कहते हैं।

Recursion के दो Important Parts

1. Base Case
2. Recursive Case

Arguments Pass करने के Common तरीके

1. Call by Value
2. Call by Address using Pointers

Functions के 4 Common Forms

1. No Arguments, No Return Value
2. Arguments, No Return Value
3. No Arguments, Return Value
4. Arguments, Return Value

---

Practice करने वाले Important Programs

Functions को अच्छी तरह समझने के लिए इन Programs की practice करें:

1. दो Numbers का Sum निकालना
2. तीन Numbers में सबसे बड़ा Number find करना
3. Array में सबसे छोटी value find करना
4. Function की मदद से Factorial निकालना
5. Recursion से Factorial निकालना
6. Number Prime है या नहीं check करना
7. किसी Range में Prime Numbers print करना
8. दो Numbers का GCD निकालना
9. दो Numbers का LCM निकालना
10. Fibonacci Series generate करना
11. First N Natural Numbers के Squares का Sum निकालना
12. Function की मदद से String Reverse करना
13. String Palindrome है या नहीं check करना
14. एक String को दूसरी String में Copy करना
15. दो Strings को Concatenate करना
16. strlen() के बिना String की Length find करना
17. Array का Largest Element find करना
18. Function की मदद से Array Sort करना
19. Function की मदद से दो Matrices Add करना
20. Pointers की मदद से दो Numbers Swap करना

अक्सर पूछे जाने वाले सवाल (FAQs)

C में Function क्या है?

Function statements का एक reusable block है जिसे किसी particular task को perform करने के लिए बनाया जाता है।

C में Functions का use क्यों किया जाता है?

Functions की मदद से Program को छोटे parts में divide करना आसान होता है। इससे code को समझना, reuse करना, test करना और maintain करना आसान हो जाता है।

User-Defined Function क्या है?

जो Function Programmer अपनी जरूरत के अनुसार खुद बनाता है, उसे User-Defined Function कहते हैं।

Function Prototype क्या है?

Function Prototype compiler को Function के बारे में पहले से जानकारी देता है, जैसे Function का नाम, Return Type और Parameters।

Recursion क्या है?

जब कोई Function खुद को ही call करता है, तो उसे Recursion कहते हैं।

Base Case क्या है?

Base Case वह condition है जो Recursive Function की calling को रोकती है।

क्या C में Call by Reference होता है?

C में दूसरे कुछ programming languages की तरह true Call by Reference parameters नहीं होते। C में values pass होती हैं। लेकिन Pointers की मदद से variable का address pass करके original value को modify किया जा सकता है।

क्या Array को Function में pass कर सकते हैं?

हाँ। C में Array को Function में pass किया जा सकता है। इससे Function Array के elements पर processing कर सकता है।

क्या String को Function में pass किया जा सकता है?

हाँ। C में String को Function में pass किया जा सकता है क्योंकि String को character Array के रूप में represent किया जाता है। इसके लिए Character Array या Pointer parameters का use किया जा सकता है।

Conclusion

C Programming में Functions Program को छोटे और manageable parts में divide करने का एक आसान तरीका हैं।

अगर आप Functions को अच्छी तरह समझ लेते हैं, तो बड़े Programs को लिखना और समझना काफी आसान हो जाता है।

Function के सबसे important concepts हैं:

Declaration → Definition → Function Call → Parameters & Arguments → Return Value → Recursion → Pointers

इन concepts की practice के साथ आप C Programming में आगे आने वाले Arrays, Strings, Pointers, Structures और File Handling जैसे topics को भी आसानी से समझ पाएंगे।