Introduction to Functions
CS-2301, System Programming
for Non-Majors
(Slides include materials from The C Programming Language, 2nd edition, by Kernighan and Ritchie and
from C: How to Program, 5th and 6th editions, by Deitel and Deitel)
CS-2301, B-Term 2009 Introduction to Functions 1
Definition – Function
• A fragment of code that accepts zero or
more argument values, produces a result
value, and has zero or more side effects.
• A method of encapsulating a subset of a
program or a system
• To hide details
• To be invoked from multiple places
• To share with others
CS-2301, B-Term 2009 Introduction to Functions 2
Functions – a big Topic
• Examples
• Function definition
• Function prototypes & Header files
• Pre- and post-conditions
• Scope and storage class
• Implementation of functions
• Recursive functions
CS-2301, B-Term 2009 Introduction to Functions 3
Common Functions
#include <math.h> #include <stdio.h>
– sin(x) // radians – printf()
– cos(x) // radians – fprintf()
– tan(x) // radians – scanf()
– atan(x) – sscanf()
– atan2(y,x) – ...
– exp(x) // ex #include <string.h>
– log(x) // loge x – strcpy()
– log10(x) // log10 x – strcat()
– sqrt(x) // x 0 – strcmp()
– pow(x, y) // xy – strlen()
– ... – ...
CS-2301, B-Term 2009 Introduction to Functions 4
Common Functions (continued)
• In Kernighan & Ritchie
– <assert.h> // for diagnostics, loop invariants, etc.
– <stdarg.h> // for parsing arguments
– <time.h> // time of day and elapsed time
– <limits.h> // implementation dependent numbers
– <float.h> // implementation dependent numbers.
– <setjmp.h> // beyond scope of this course
– <signal.h> // beyond scope of this course
CS-2301, B-Term 2009 Introduction to Functions 5
Common Functions (continued)
• See also the man pages of your system for
things like
• <pthread.h> // concurrent execution
• <socket.h> // network communications
• ... // many, many other facilities
• Fundamental Rule: if there is a chance that
someone else had same problem as you, …
• … there is probably a package of functions
to solve it!
CS-2301, B-Term 2009 Introduction to Functions 6
Functions in C
resultType functionName(type1 param1, type2
param2, …) {
…
body
…
}
• If no result, resultType should be void
• Warning if not!
• If no parameters, use void between ()
CS-2301, B-Term 2009 Introduction to Functions 7
Functions in C
resultType functionName(type1 param1, type2
param2, …) {
… a ys
to a l w
body s t yl e
i s g ood i tha
I t c tio n w ame
fu n i t s n
… en d a ts h o w in g
m e n
} // functionName com
• If no result, resultType should be void
• Warning if not!
• If no parameters, use void between ()
CS-2301, B-Term 2009 Introduction to Functions 8
Using Functions
• Let int f(double x, int a) be (the
beginning of) a declaration of a function.
• Then f(expr1, expr2) can be used in any
expression where a value of type int can
be used – e.g.,
N = f(pi*pow(r,2), b+c) + d;
CS-2301, B-Term 2009 Introduction to Functions 9
Using Functions (continued)
This is a parameter
• Let int f(double x, int a) be (the
beginning of) a declaration of a function.
• Then f(expr1, expr2) can be used in any
expression where a value of type int can
be used – e.g.,
N = f(pi*pow(r,2), b+c) + d;
This is also an
This is an argument
argument
CS-2301, B-Term 2009 Introduction to Functions 10
Definitions
• Parameter:– a declaration of an identifier
within the '()' of a function declaration
• Used within the body of the function as a variable
of that function
• Initialized to the value of the corresponding
argument.
• Argument:– an expression passed when a
function is called; becomes the initial value
of the corresponding parameter
CS-2301, B-Term 2009 Introduction to Functions 11
Using Functions (continued)
• LetTint f(double x, int a) be (the
The he
t
is e secof)
ev firsbeginning
v on
a declaration of a function.
a lu a d
and ated anrgdumaluate argu
ass , co asseingt d, co men
ign nve neexp nv t ex
• Then
ed d
ted troess 1e,rtedexpr
to p rf(expr pre 2) can be used in any
s
ara to dopairoanmis to in sion
expressionme where a value of type int can
ter ble, eter a t,
u
be used – e.g., x
N = f(pi*pow(r,2), b+c) + d;
CS-2301, B-Term 2009 Introduction to Functions 12
Using Functions (continued)
• Let int f(double x, int a) be (the
beginning of) a declaration of a function.
• Then f(expr1, expr2) can be used in any
expression where a value of type int can
be used – e.g.,
N = f(pi*pow(r,2), b+c) + d;
Function f is executed and
Sum is assigned to N Result of f is added to d
returns a value of type int
CS-2301, B-Term 2009 Introduction to Functions 13
Questions?
CS-2301, B-Term 2009 Introduction to Functions 14
Function Definition
• Every function definition has the form
return-type function-name (parameter declarations) {
definitions and statements
}
• See top of page 70 in Kernighan & Ritchie
• For practical purposes, code between {}
(inclusive) is a compound statement
CS-2301, B-Term 2009 Introduction to Functions 15
Note
• Functions in C do not allow other functions
to be declared within them
• Like C++, Java
• Unlike Algol, Pascal
• All functions defined at “top level” of C
programs
• (Usually) visible to linker
• Can be linked by any other program that knows the
function prototype
CS-2301, B-Term 2009 Introduction to Functions 16
Examples
• double sin(double radians) {
…
} // sin
• unsigned int strlen (char *s) {
…
} // strlen
CS-2301, B-Term 2009 Introduction to Functions 17
Note on printf, etc.
• int printf(char *s, ...) {
body
} // printf
• In this function header, “…” is not a professor’s
place-holder
• (as often used in these slides)
• …but an actual sequence of three dots (no spaces
between)
• Meaning:– the number and types of arguments is
indeterminate
• Use <stdarg.h> to extract the arguments
CS-2301, B-Term 2009 Introduction to Functions 18
Questions?
CS-2301, B-Term 2009 Introduction to Functions 19
Function Prototypes
• There are many, many situations in which a
function must be used separate from where
it is defined –
• before its definition in the same C program
• In one or more completely separate C programs
• This is actually the normal case!
• Therefore, we need some way to declare a
function separate from defining its body.
• Called a Function Prototype
CS-2301, B-Term 2009 Introduction to Functions 20
Function Prototypes (continued)
• Definition:– a Function Prototype in C is a
language construct of the form:–
return-type function-name (parameter declarations) ;
• I.e., exactly like a function definition, except with a
';' instead of a body in curly brackets
CS-2301, B-Term 2009 Introduction to Functions 21
Purposes of Function Prototype
• So compiler knows how to compile calls to that
function, i.e.,
– number and types of arguments
– type of result
• As part of a “contract” between developer and
programmer who uses the function
• As part of hiding details of how it works and
exposing what it does.
• A function serves as a “black box.”
CS-2301, B-Term 2009 Introduction to Functions 22
Header files
• In applications with multiple C programs,
function prototypes are typically provided
in header files
• I.e., the ‘.h’ files that programmers include in their
code
• Grouped by related functions and features
• To make it easier for developers to understand
• To make it easier for team development
• To make a package that can be used by someone
else
CS-2301, B-Term 2009 Introduction to Functions 23
#include
• #include <foo.h>
• Search the system’s directories in order for a file of
the name foo.h
• Directories can be added with ‘-I’ switch to gcc
command
– E.g., gcc –I myProject/include foo.c
– Precedes system directories in search order
• #include "foo.h"
• Search the directory where the source program is
found first, before -I and system directories
CS-2301, B-Term 2009 Introduction to Functions 24
Typical C Programming Style
• A lot of small C programs, rather than a few
large ones
• Each .c file contains closely related functions
• Usually a small number of functions
• Header files to tie them together
• Makefiles to build or rebuild them in an
organized way
• Later in the term
CS-2301, B-Term 2009 Introduction to Functions 25
Definition – Stub
• A stub is a dummy implementation of a
function with an empty body
• A placeholder while building (other parts of)
a program
• So that it compiles correctly
• Fill in one-stub at a time
• Compile and test if possible
CS-2301, B-Term 2009 Introduction to Functions 26
Questions?
CS-2301, B-Term 2009 Introduction to Functions 27
“Contract” between Developer and User of a
Function
1. Function Prototype
2. The pre- and post-conditions
– I.e., assertions about what is true before the
function is called and what is true after it
returns.
– A logical way of explaining what the function
does
CS-2301, B-Term 2009 Introduction to Functions 28
Definitions
• Pre-condition:–a characterization or logical
statement about
• the values of the parameters, and
• values of relevant variables outside the function
prior to calling the function
• Post-condition:–a logical statement or
characterization about
• the result of the function in relation to the values of the
parameters and pre-conditions, and
• changes to values of variables outside the function
after the function returns
CS-2301, B-Term 2009 Introduction to Functions 29
Example 1
• double sin (double angle);
– Pre:– angle is expressed in radians
– Post:– result is the familiar sine of angle
– Note: this function does not use or change any
other variables
CS-2301, B-Term 2009 Introduction to Functions 30
Example 2
• int printf (string, arg1, arg2, …)
– Pre:– string terminated with '\0' and containing
conversion specifiers
– Pre:– a buffer maintained by the file system contains
zero or more unprinted characters from previous calls.
– Post:– args are substituted for conversion codes in
copy of string; resulting string is added to buffer
– Post:– if '\n' is anywhere in buffer, line is “printed”
up to '\n'; printed characters are cleared from buffer
– Post:– result is number of characters added to buffer by
printf
CS-2301, B-Term 2009 Introduction to Functions 31
Example 3
float total = 0;
int count = 0;
int GetNewItem(void) {
float input;
int rc;
printf("Enter next item:- ");
if ((rc = scanf("%f", &input)) != EOF
&& (rc > 0)) {
total += input;
count++;
}; // if
return rc;
} // GetNewItem
CS-2301, B-Term 2009 Introduction to Functions 32
Example 3
Pre:– total is sum of all
float total = 0;
previous inputs, or zero if none
int count = 0;
Pre:– count is number of
previous inputs, or zero if none
int GetItem(void) {
float input; Post:– if valid input is received
int rc; total = totalprev + input,
...; count = countprev + 1
if ((rc = scanf(“%f”, &input)) != EOF
&& (rc > 0)) {
total += input;
count++;
}; // if
return rc;
} // GetItem
CS-2301, B-Term 2009 Introduction to Functions 33
Important
• Pre- and post-conditions are analogous to
loop invariants
• I.e., they describe something about the data before
and after a function is called and the relationship
that the function preserves
• Often are used together with loop invariants
• … to show that loop invariant is preserved from one
iteration to the next
CS-2301, B-Term 2009 Introduction to Functions 34
Questions?
CS-2301, B-Term 2009 Introduction to Functions 35
