Subroutines/Functions

Subroutines/Functions in C/C++
- Subroutine/Function is a programming construct that allows a programmer to associate a given set of instructions with a specific name.
  A subroutine/function consist of a (unique) name and a (subroutine/function) body
  The subroutine/function can optionally have one or more parameters that can affect the behavior of the subroutine/function
- Subroutine/Function is defined once
- After its definition, the subroutine/function can be used (called or invoked) many times as is desired.
Defining and Declaring Functions
- Function definition is the creation (space reservation) of a function based on its description (name, parameters, return value, variables defined inside the function and statements that comprise the body of the function)
  The function definition contain all the information on a function:
  - Its name (how it identify the function)
  - The number and type of parameters (what it needs to work)
  - The type of output value produced
  - What does it do (the programming of the function)
- Function declaration is the description of a function to an extend that the compiler know what to do with the parameters passed to the function and the return value received from the function.
  The function declaration contain enough information to use the function:
  - Its name (you need to find the function)
  - The number and type of parameters (you need to know how many value and what kind to give the function)
  - The type of output value produced (you need to know what to do with the output - e.g., possible conversion)
  NOTE: a function definition encompasses (includes) all information in a function declaration
- Prime Directive of Programming:
We will now examine how C/C++ define and declare functions.
I will separate the discssion into 2 parts:
- Functions that do NOT have other functions as parameters
- Functions that do have other functions as parameters

DEFINING functions that ONLY have VARIABLES as parameters (no function parameters)

Syntax to DEFINE function with variables as parameters

ReturnType MySubrName(type1 Var1, type1 Var2, ...) { *** LOCAL Variable definitions *** Subroutine Body (statements) }

Illustrative Example:

float Square(float x) // Function definition { // float y; // Has all the information // on the function: y = x * x; // return(y); // name, parameters, output } // what to do (body) int a; short b; b = Square(a); // Conversion !!

Since the Square function is called with a int type variable, compiler will convert the type to float before passing it to the function (type conversion = use different encoding)
The return(...) statement causes the function to return to the caller (location where the function was called) and the returned value is equal to the expression (...)
Note that if the type of the expression (...) if different from float (which is the type of value that the function WILL return), the type of expression (...) will first be converted to float before the value is returned !
Since the output of the Square function is assigned to a short type variable, compiler will convert the float return type to short before assigning it to b

Example Program: (Demo above code) --- click here

The MAIN function
- The main program in C/C++ is also a function
- This MAIN function must be called "main" and it must have 2 parameter (one integer and one array of strings) and it must return an integer:
  int main(int param1, char *param2[]) { MAIN PROGRAM }
  - Param1 is an integer
  - Param2 is an array of character strings (just believe it...)
  - The main() function returns an error code that indicate to the "SHELL" (your console window) whether the program ended succesfully
- Example Program: (Demo main function) ---
  - Here is a MAIN function that prints all its arguments and returns an error code: click here
  - Here is a SHELL SCRIPT that runs "a.out" and depending on the error code, will print "OK" (when error code = 0) or the value of the error code: click here

DECLARING functions that ONLY have VARIABLES as parameters (no function parameters)

Subroutine Declaration Syntax

extern RetType MySubrName(type1 [Variable1], type1 [Variable2], ...); Things in [ ] brackets are OPTIONAL items Thus: the name of the variables are optional in the function declaration

Note

the keyword extern is required in the ANSI C/C++ standard, but many C/C++ compiler will accept a syntax where the keyword extern is omitted
To make certain that your program will compile on as many platforms as possible, stick to ANSI C/C++ standard.
The above definition is kinda verbose; but it only declares ONE single symbolic name which is MySubrName

Illustrative Example:

extern float Square(float x); // Function declaration OR: extern float Square(float); // Function declaration int a; short b; b = Square(a); // Conversion !!

Through the function declaration:
the C++ compiler now knows that the symbolic name Square is a function that must be called with an float type variable (the name of the variable is no important at all, the type of value (and the value itself) is all what is needed).
The compiler also knows that the function will return a float type output value.
Hence, because the function is given an int type value, the compiler knows that it must first convert the int type to float before passing it to the function
And similarly, the float output of the Square function that is assigned to a short type variable, will be converted to short before assigning it to b

Example Program: (Demo function declaration) ---
- This is the C++ Square function definition: click here
- This is the C++ MAIN function definition: click here
- Compile with: CC C-subroutine2a.C C-subroutine2b.C
- Experiment: try "lying" to the compiler: change the declaration of "Square"
  C++ will catch your lie and prevent a successful compilation
Example Program: (Demo problems in function declaration in C) ---
- This is the C Square function definition: click here
- This is the C MAIN function definition: click here
- Compile with: cc C-subroutine2a.c C-subroutine2b.c
- Notice the function declaration is a "lie"
  The C compiler is not as careful as the C++ (better type check) and does NOT catch your lie...
  Try running the problem and see the problem...

DEFINING a function that has a FUNCTION as PARAMETER...
- Suppose we want to define a function RectangleRule_Prec(f, a, b, EPS) that find an approximation for the definite integral of a function f between the interval (a, b) with accuracy EPS:
  The type of the input parameters are:
  - f: a function: the function to be integrated
  - a: variable: start of integration interval
  - b: variable: end of integration interval
  - EPS: variable: accuracy
- To DEFINE the function parameter f, we must specify:
  - a name of the function (this is a "formal" parameter)
  - the type of its return value and
  - the number and the type of each of its parameters
  Example:
  float RectangleRule_Prec(float h(float), float a, float b, float EPS) { ... }
  - h = name of the function parameter. This is need NOT be the name of the actual function that you will use. It is just a name that the program uses to refer to the FIRST parameter that WILL be given to the function RectangleRule_Prec
  - float (before h) tells the compiler that the type of the return value of h is float
  - float (between ()) tells the compiler that h has one single float type value as parameter
- PROGRAMMING NOTE:
  You may (for your own record) specify names for the parameters of the function parameter; but they will be ignored by the C/C++ compiler
  Example: for clarity, you can define RectangleRule_Prec as:
  float RectangleRule_Prec(float f(float x), float a, float b, float EPS) { ... }
DECLARING a function that has a function as parameter...
- If we want to use the function RectangleRule_Prec(f, a, b, EPS) we may need to declare it first.
- To DECLARE a function that has another function as parameter we must specify
  1. the type of its return value and
  2. the type of each of its parameters between brackets (separated by commas)
  Example:
  extern float RectangleRule_Prec(float (float), float, float, float);
  - OK, please don't laugh at the funny looking "float (float)" thing... :-)
    This is NO need mention the name of the actual function that you will use...
    All the compiler need to know is (1) how many parameters the function takes, (2) the type of each parameter and (3) the type of value returned
  - float(float) tells the compiler that the first parameter is a function that takes ONE float value as parameter and returns a float value as result.
  - The other 3 values tells the compiler that the function RectangleRule has 3 other parameters: paramaters 2 and 3 are float values and parameter 4 is an integer value.
- PROGRAMMING NOTE:
  Notice that a Function DECLARATION does NOT have curly braces "{" and "}" and MUST be terminated by a semi-colon (;)
- PROGRAMMING NOTE:
  Here also (as in the Function DEFINITION (See: click here )), you may (for your own record) specify the name of the function and names for the parameters; but they will be IGNORED by the C/C++ compiler:
  extern float RectangleRule_Pred(float h(float y), float a, float b, float EPS);
- PROGRAMMING NOTE:
  The ANSI C/C++ standard requires the use of the keyword extern.
  But some C/C++ compilers do not need this keyword.
  Again, I recomment that you use it....

Passing a subsroutine/function to another subroutine/function

After you have defined a function (RectangleRule_Prec) that has a function as parameter, you can pass a function to this function (RectangleRule_Prec) by givin the name of the function (without any parameters !)

Example:

int main(int argc, char *argv[]) { extern float RectangleRule_Pred(float (float), float, float, float); extern float f(float); extern float g(float); float result1, result2; .... result1 = RectangleRule_Pred(f, 1.0, 2.0, 0.0001); result2 = RectangleRule_Pred(g, 7.0, 9.0, 0.0001);

For real examples, you will have to wait a while when we discuss "re-using old functions to write new functions".... ( click here )