Function Declarasion and Implementation

Function calls can be nested within other functions, enabling modular program design.

Primary Program Entry Point

// main.c
#include "utilities.h"

int main() {
    int value = 10;
    value = display_pattern(value);
    show_greeting();
    display_pattern(5);
    return 0;
}

Expected output:

************
display_pattern 10
Welcome message
************
display_pattern 6
************
display_pattern 5

Supporting Functions Implementation

// utilities.c
#include "utilities.h"

int display_pattern(int count) {
    printf("************\n");
    printf("display_pattern %d\n", count);
    return count + 3;
}

void show_greeting() {
    printf("Welcome message\n");
    display_pattern(6);
}

Header File Definition

// utilities.h
#ifndef PROGRAM_UTILITIES_H
#define PROGRAM_UTILITIES_H

#include <stdio.h>

void show_greeting();
int display_pattern(int parameter);

#endif

C Language Compilation Characteristics

1. A C program consists of one or more source files, allowing separate development and compilation for improved debugging efficiency.
2. Each source file serves as a compilation unit containing functions and related declarations.
3. Program execution begins with the main function, which controls overal program flow.
4. Functions exist independently and cannot be defined within other functions.

Implicit declaration: Functions without explicit return type specifications default to returning integer values.

Function Categories and Invocation Patterns

User Perspective Classification

1. Standard library functions: printf, scanf, etc.
2. Custom-defined functions: Created to address specific application requirements.

Implementation Perspective Classification

1. Parameterless functions: Execute predefined operations without data input.
2. Parameterized functions: Accept input values for processing.

Recursive Function Implementation

Recursive functions call themselves to solve complex problems through repetitive self-reference.

Factorial Calculation Example

Computing factorial using mathematical relationship f(n) = n × f(n-1)

#include <stdio.h>

int calculate_factorial(int number) {
    if (number == 1) {
        return 1;
    }
    return number * calculate_factorial(number - 1);
}

int main() {
    int input_value;
    scanf("%d", &input_value);
    printf("factorial(%d) = %d\n", input_value, calculate_factorial(input_value));
    return 0;
}

Staircase Climbing Problem

Determining number of ways to climb n steps when moving 1 or 2 steps at a time.

Logic: Reaching step n requires coming from either step n-1 or n-2, therefore steps(n) = steps(n-1) + steps(n-2)

int count_ways(int steps) {
    if (steps == 1 || steps == 2) {
        return steps;
    }
    return count_ways(steps - 1) + count_ways(steps - 2);
}

int main() {
    int total_steps;
    scanf("%d", &total_steps);
    printf("ways(%d) = %d\n", total_steps, count_ways(total_steps));
    return 0;
}

Variable Scope Management

Global Variables and Parameter Passing

Three methods exist for data exchange between functions:

1. Parameters: Formal and actual parameter mechanism
2. Return values: Using return statements
3. Global variables: External variable access

#include <stdio.h>

int global_counter = 10;

void display_value(int param) {
    printf("Function scope global_counter = %d\n", global_counter);
}

int main() {
    printf("Main scope global_counter = %d\n", global_counter);
    global_counter = 5;
    display_value(5);
    return 0;
}

When local variables share names with global variables, local scope takes precedence during access and modification.

Parameter Relationship Guidelines

1. Function parameters exist only during active function calls and are deallocated upon completion.
2. Actual parameters may be variables, constants, or expressions with definite values.
3. Formal parameters require explicit type declarations with matching quantity and sequential correspondence.
4. Type compatibility must exist between corresponding actual and formal parameters.
5. Data transfer occurs unidirectionally from actual to formal parameters.
6. Formal parameters behave as local variables, preventing duplicate local variable declarasions.

Global variables maintain memory allocation throughout entire program execution rather than dynamic allocation.

C programming promotes encapsulated function design where functions primarily interact with external environment through parameter passing mechanisms.