Collapse Content


Function declaration syntax:
<return type> <function name>(<args>)

int add_two_ints(int x1, int x2)
  return x1 + x2; // Use return to return a value

Functions are call by value. When a function is called, the arguments passed to ≈the function are copies of the original arguments (except arrays). Anything you do to the arguments in the function do not change the value of the original argument where the function was called.

Use pointers if you need to edit the original argument values.
Example - in-place string reversal:

// A void function returns no value
void str_reverse(char *str_in)
  char tmp;
  int ii = 0;
  size_t len = strlen(str_in); // `strlen()` is part of the c standard library
  for (ii = 0; ii < len / 2; ii++) {
    tmp = str_in[ii];
    str_in[ii] = str_in[len - ii - 1]; // ii-th char from end
    str_in[len - ii - 1] = tmp;

char c[] = "This is a test.";
printf("%s\n", c); // => ".tset a si sihT"

if referring to external variables outside function, must use extern keyword.

int i = 0;
void testFunc() {
  extern int i; //i here is now using external variable i

make external variables private to source file with static:

static int j = 0; //other files using testFunc() cannot access variable i
void testFunc2() {
  extern int j;
//**You may also declare functions as static to make them private**

Function pointers

At run time, functions are located at known memory addresses. Function pointers are much like any other pointer (they just store a memory address), but can be used to invoke functions directly, and to pass handlers (or callback functions) around. However, definition syntax may be initially confusing.

Example: use str_reverse from a pointer

void str_reverse_through_pointer(char *str_in) {
  // Define a function pointer variable, named f.
  void (*f)(char *); // Signature should exactly match the target function.
  f = &str_reverse; // Assign the address for the actual function (determined at run time)
  // f = str_reverse; would work as well - functions decay into pointers, similar to arrays
  (*f)(str_in); // Just calling the function through the pointer
  // f(str_in); // That's an alternative but equally valid syntax for calling it.

As long as function signatures match, you can assign any function to the same pointer. Function pointers are usually typedef'd for simplicity and readability, as follows:

typedef void (*my_fnp_type)(char *);

// Then used when declaring the actual pointer variable:
// ...
// my_fnp_type f;
Contact Us