Functions, Headers, and Scope

Functions let a C program name one responsibility, receive the information it needs, and return a result without exposing every implementation detail. Learn how calls move through declarations, definitions, parameters, local scope, headers, and return paths.

Build a contract, then hide the work behind it

A function gives one responsibility a stable name

Without functions, main eventually becomes a long sequence of unrelated details. A function creates a boundary around one job: calculate a value, validate a rule, print a report, or coordinate another small action. The caller supplies only the required arguments and relies on the function's contract.

A useful function is smaller than the feature around it. Its name describes an outcome, its parameters represent the information that can vary, and its return type says what comes back. If you cannot describe the job in one sentence without using “and then,” the function may be carrying more than one responsibility.

Read a function definition as a typed contract plus an implementation

In int lessons_left(int completed, int total), the first int is the return type. lessons_left is the function name. The two declarations inside parentheses are parameters. The braces contain the implementation, and return total - completed; supplies the promised result.

#include <stdio.h>

int lessons_left(int completed, int total) {
  return total - completed;
}

int main(void) {
  int remaining = lessons_left(3, 8);

  printf("%d lessons remain.\n", remaining);
  return 0;
}

Edit the program, predict its output, then run it.

Parameters describe inputs; arguments supply values

A parameter belongs to a function declaration or definition, such as int completed. An argument is the expression used at a call site, such as lessons_left(3, 8). C evaluates each argument and initializes the corresponding parameter by position.

Parameter order should communicate the rule. For lessons_left(completed, total), a call reads naturally and the subtraction direction is predictable. Reversing the arguments still satisfies the types because both are int, but it changes the meaning.

C passes these scalar arguments by value

For the int and double parameters in this lesson, a function receives its own parameter value. Assigning a new value to that parameter changes the function's local copy, not the caller's variable. The function below doubles value, yet original in main remains 7.

#include <stdio.h>

int double_value(int value);

int main(void) {
  int original = 7;
  int doubled = double_value(original);

  printf("Original: %d\n", original);
  printf("Doubled: %d\n", doubled);
  return 0;
}

int double_value(int value) {
  value = value * 2;
  return value;
}

Edit the program, predict its output, then run it.

1. 01
   Evaluate the argument

   original currently holds 7, so the call supplies the value 7.

2. 02
   Initialize the parameter

   The function's local parameter named value begins with its own copy of 7.

3. 03
   Change only the local copy

   The assignment stores 14 in value. It does not assign to original.

4. 04
   Return a separate result

   The function returns 14, and the caller stores that value in doubled.

Use void when the function performs an action without producing a value

A void return type means that the call does not produce a value for an expression. The function can still perform useful work: it can print output, update data through an explicit shared boundary, or coordinate other functions. In this lesson, print_progress owns formatting and output while the caller owns the values.

Call a void function as a statement: print_progress(4, 6);. Do not assign its result, because there is no result value. A bare return; may end a void function early, but reaching the closing brace also completes it.

#include <stdio.h>

void print_progress(int completed, int total) {
  printf("Progress: %d of %d\n", completed, total);
}

int main(void) {
  print_progress(4, 6);
  return 0;
}

Edit the program, predict its output, then run it.

A non-void function sends one typed value back to its caller

The return type is a promise. An int function returns a whole-number value; a double function returns a floating-point value. The caller decides what to do with that result—store it, compare it, pass it to another function, or ignore it. Returning a value is different from printing it: a returned value remains available to the program.

#include <stdio.h>

double weekly_hours(double session_hours, int sessions) {
  return session_hours * sessions;
}

int main(void) {
  double total = weekly_hours(1.5, 4);

  printf("Weekly study: %f hours\n", total);
  return 0;
}

Edit the program, predict its output, then run it.

A prototype makes a function contract visible before the call

C processes declarations in source order. When a call appears before the function definition, the compiler needs an earlier declaration. A function prototype supplies the return type, function name, and parameter types, followed by a semicolon: int square(int value);.

#include <stdio.h>

int main(void) {
  int result = square(4);

  printf("Square: %d\n", result);
  return 0;
}

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

Edit the program, predict its output, then run it.

A header shares declarations across source files

A header file is a public contract for code that other source files may use. Standard header <stdio.h> declares facilities such as printf. Your own header might declare int lessons_left(int completed, int total);, while a matching .c file contains the definition.

Include guards prevent the same header contents from being processed more than once in one translation unit. A beginner header normally contains declarations, named constants, and shared type definitions—not ordinary function bodies or unrelated private variables.

Scope answers: where can this name be used?

A parameter or variable declared inside a function body has block scope. It can be named from its declaration to the end of the enclosing block, including appropriate nested blocks. It does not become visible inside other functions. This boundary prevents implementation details from leaking into callers.

A declaration outside every function has file scope. Such names can be useful for shared constants and carefully designed module state, but broad mutable state creates hidden dependencies. Prefer parameters and returned values until the program truly needs longer-lived shared state.

#include <stdio.h>

int make_total(int base) {
  int local_bonus = 2;
  return base + local_bonus;
}

int main(void) {
  int total = make_total(5);

  printf("Total: %d\n", total);
  printf("Bonus: %d\n", local_bonus);
  return 0;
}

Edit the program, predict its output, then run it.

Every reachable path in a non-void function must return a value

A conditional return does not complete the contract unless every possible execution path returns. In the example below, valid progress returns a count, but completed > total reaches the closing brace without an int result. That is a defect, not an automatic zero.

Choose an explicit policy for invalid input: return a documented sentinel such as -1, validate before the call, or redesign the interface to report success separately. The important part is that the caller can distinguish a valid result from an invalid case.

#include <stdio.h>

int lessons_left(int completed, int total) {
  if (completed <= total) {
    return total - completed;
  }
}

int main(void) {
  int remaining = lessons_left(7, 5);

  printf("Remaining: %d\n", remaining);
  return 0;
}

Edit the program, predict its output, then run it.

Split the contract, implementation, and caller into separate files

A multi-file program compiles each .c source file as a translation unit and links the resulting object code into one executable. Put shared declarations in progress.h, definitions in progress.c, and feature coordination in main.c. Both source files include the header so the compiler checks them against the same contract.

Independent lab: build a small progress-reporting module

Use the starter to practice three contracts: one integer calculation, one floating-point calculation, and one output action. First run it unchanged. Then complete the milestones without merging all work back into main.

#include <stdio.h>

int lessons_left(int completed, int total);
double weekly_hours(double session_hours, int sessions);
void print_summary(int remaining, double hours);

int main(void) {
  int completed = 3;
  int total = 8;
  int sessions = 4;
  double session_hours = 1.5;
  int remaining = lessons_left(completed, total);
  double hours = weekly_hours(session_hours, sessions);

  print_summary(remaining, hours);
  return 0;
}

int lessons_left(int completed, int total) {
  return total - completed;
}

double weekly_hours(double session_hours, int sessions) {
  return session_hours * sessions;
}

void print_summary(int remaining, double hours) {
  printf("Lessons remaining: %d\n", remaining);
  printf("Weekly study: %f hours\n", hours);
}

Edit the program, predict its output, then run it.

Lesson review

• A function should express one focused responsibility through a clear name.
• Parameters declare local inputs; arguments are the expressions supplied by the caller.
• Scalar arguments in these examples are copied into parameters, so parameter assignment does not modify the caller's variable.
• void describes a function that returns no result value.
• A prototype declares a function contract before a call that cannot yet see the definition.
• A header publishes shared declarations; a source file normally owns their definitions.
• Parameters and local variables stay inside their blocks; file-scope names have broader visibility.
• Every reachable path through a non-void function must return a value compatible with its return type.