Creating User-Defined Functions in C With Practical Examples

The Three-Question Design Method

Before writing any function, answer these on paper (or in a comment):

1. What is its ONE job? (in a single sentence) 2. What does it need to receive? (→ parameters) 3. What does it give back? (→ return type, or void)

Example — a function that checks whether a number is even:

1. Job: "Decide if a number is even"
2. Needs: one integer → int n
3. Gives back: a yes/no answer → int (1 = yes, 0 = no — C's classic convention)

The answers literally become the header:

int isEven(int n) {
    return(n % 2 == 0);
    // comparison gives 1 (true) or 0 (false)
}

Job, inputs, output. Answer three questions, get a function. Let's prove it works on bigger problems.

Example 1: Prime Number Checker

Design:

1. Job: "Report whether a number is prime"
2. Needs: the number → int n
3. Gives back: yes/no → int (1 or 0)

#include <stdio.h>
int isPrime(int n);
// declaration
int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    if (isPrime(num)) {
        printf("%d is prime.\n", num);
    } else {
        printf("%d is not prime.\n", num);
    }
    return 0;
}
int isPrime(int n) {
    if (n < 2) {
        return 0;
        // 0 and 1 are not prime — done, exit early    }
        for (int i = 2; i <= n / 2; i++) {
            if (n % i == 0) {
                return 0;
                // found a divisor — not prime, exit now        }    }
                return 1;
                // survived all checks — prime}

Sample Runs:

Enter a number: 2929 is prime.

Enter a number: 5151 is not prime.

Notice the design elegance: isPrime knows nothing about keyboards or screens. It takes a number, answers a question. All the printf/scanf lives in main. That separation — logic in functions, I/O at the edges — is the single most professional habit on this page.

Also notice the readability win: if (isPrime(num)) reads like English. The function name is the documentation.

Example 2: Power Function (No math.h Needed)

Design:

1. Job: "Calculate base raised to an exponent"
2. Needs: two integers → int base, int exp
3. Gives back: the result → long (powers get big fast!)

#include <stdio.h>
long power(int base, int exp);
int main() {
    printf("2^10 = %ld\n", power(2, 10));
    printf("5^3  = %ld\n", power(5, 3));
    printf("7^0  = %ld\n", power(7, 0));
    return 0;
}
long power(int base, int exp) {
    long result = 1;
    for (int i = 1; i <= exp; i++) {
        result *= base;
    }
    return result;
}

Output:

2^10 = 10245^3 = 1257^0 = 1

Two lessons hiding in here: the result starts at 1, not 0 (multiply by zero and everything dies — accumulator initialization matters!), and the return type is long because 2^31 doesn't fit in an int. Choosing types is part of designing functions.

Example 3: Palindrome Number Checker

Design:

1. Job: "Check if a number reads the same backward"
2. Needs: the number → int n
3. Gives back: yes/no → int

Here we reuse the digit-reversal trick from our while-loop tutorial — as a helper function:

#include <stdio.h>
int reverseNumber(int n);
// helperint isPalindrome(int n);
int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    if (isPalindrome(num)) {
        printf("%d is a palindrome.\n", num);
    } else {
        printf("%d is not a palindrome.\n", num);
    }
    return 0;
}
int reverseNumber(int n) {
    int reversed = 0;
    while (n != 0) {
        reversed = reversed * 10 +(n % 10);
        n /= 10;
    }
    return reversed;
}
int isPalindrome(int n) {
    return(n == reverseNumber(n));
    // palindrome = number equals its reverse}

Sample Run:

Enter a number: 12211221 is a palindrome.

This is the big moment in this tutorial: isPalindrome doesn't reverse anything itself — it calls another user-defined function. Functions building on functions. That's not a trick; that's how all real software is assembled, from calculators to operating systems.

Example 4: A void Function — Printing a Report Header

Not every function computes. Some just do — and those return void:

Design:

1. Job: "Print a formatted report header"
2. Needs: the title text → char title[]
3. Gives back: nothing → void

#include <stdio.h>
void printHeader(char title[]);
void printLine(int length);
int main() {
    printHeader("SALES REPORT");
    puts("Item 1 ....... 450.00");
    puts("Item 2 ....... 299.99");
    printLine(30);
    return 0;
}
void printHeader(char title[]) {
    printLine(30);
    printf("    %s\n", title);
    printLine(30);
}
void printLine(int length) {
    for (int i = 0; i < length; i++) {
        putchar('-');
    }
    putchar('\n');
}

Output:

------------------------------ SALES REPORT------------------------------Item 1 ....... 450.00Item 2 ....... 299.99------------------------------

void functions are the workhorses of menus, banners, and display code. And look — printHeader calls printLine. Even trivial functions compose.

Example 5: Functions Calling Functions — Grade Calculator

#include <stdio.h>
float calculateAverage(int total, int subjects);
char assignGrade(float average);
void printReport(int total, float average, char grade);
int main() {
    int m1, m2, m3;
    printf("Enter marks for 3 subjects: ");
    scanf("%d %d %d", &m1, &m2, &m3);
    int total = m1 + m2 + m3;
    float avg = calculateAverage(total, 3);
    char grade = assignGrade(avg);
    printReport(total, avg, grade);
    return 0;
}
float calculateAverage(int total, int subjects) {
    return(float)total / subjects;
    // cast to float — no integer division!}
    char assignGrade(float average) {
        if (average >= 90) return 'A';
        if (average >= 75) return 'B';
        if (average >= 60) return 'C';
        if (average >= 40) return 'D';
        return 'F';
    }
    void printReport(int total, float average, char grade) {
        puts("\n===== REPORT CARD =====");
        printf("Total   : %d / 300\n", total);
        printf("Average : %.2f\n", average);
        printf("Grade   : %c\n", grade);
    }

Sample Run:

Enter marks for 3 subjects: 78 85 92
===== REPORT CARD =====
Total : 255 / 300
Average : 85.00
Grade : B

Three functions, one job each, chained like an assembly line: total → average → grade → report. If the grading policy changes next semester, you touch exactly one function. That's maintainability, and it's the whole point.

(Suggested image: the assembly-line diagram — total → calculateAverage → assignGrade → printReport as connected stations)

Naming and Design Conventions Professionals Use

Naming:

• Use verbs or verb phrases — functions do things: calculateTotal, isPrime, printReport ✓ ... number, stuff, myFunc ✗
• camelCase is the common C convention for functions: getUserInput, findMaximum
• Predicates (yes/no functions) read best as questions: isEven(), hasVowel(), canVote() — so if (isEven(n)) reads like prose

Design rules worth their weight in gold:

1. One function, one job. If you need "and" to describe what it does ("validates input and saves the file and prints a receipt"), it's three functions wearing a trench coat.
2. Logic in, I/O out. Calculation functions return values; let the caller decide whether to print them. A function that both computes and prints can never be reused somewhere that doesn't want printing.
3. Keep them short. A function longer than a screen is a candidate for splitting.
4. Name honestly. A function called getValue that also deletes files is a bug magnet.

The Six Common Mistakes When Writing Your Own Functions

1. Forgetting the prototype when the definition sits below main — the compiler meets the call before the function and complains. Prototype up top, always.
2. Semicolon after the definition header — int add(int a, int b); { ... } → error. Semicolon belongs to prototypes only.
3. Missing return on some path —
   main.c

   Copy Code Run Online

   int check(int n) {
       if (n > 0) return 1;
       // what if n <= 0?? No return — undefined garbage
   }

   Every path through a non-void function must hit a return.
4. Parameter/type mismatches at the call — passing float where int is expected; the compiler warns if it saw a prototype (reason #2 to always prototype).
5. Expecting the argument to change — pass by value, always a copy. tryToChange(x) can't touch main's x. (Pointers — the fix — get their own cluster.)
6. The God function — one 300-line function doing everything. If scrolling is required, splitting is required.

(Suggested image: "6 Mistakes" checklist graphic — consistent with the series)

Final Thoughts

Here's what changed today: you stopped being a user of functions and became an author of them. The skill isn't memorizing syntax — you already had that — it's the design habit: one job, clear inputs, clear output, honest name. Answer the three questions and the code follows.

And notice what your programs have become: main() is now a conductor, not the whole orchestra. Small functions, each testable, each reusable, composing into larger behavior. From this point in the series onward, that structure is simply how we write programs.