For instance, if there were twelve different places in a program where you needed to compute square roots, it would be extremely inconvenient to have to rewrite essentially the same code sequence in all twelve places. Furthermore, if you needed to alter your square root computations, it might require alterations in all twelve locations - leading to an increased chance of confusion and errors.

A function takes a block of code and gives it a name, as well as giving names to the different kinds of data (parameters) it needs to process. When you want to use a function in a program you simply specify the name of the function and the data you want to supply to it:

// Here we assume there is a function named SquareRoot, that takes
// a floating point value as a parameter and returns a floating
// point value (the square root of the parameter it was given)
x = SquareRoot(36.0);  

• There are many libraries, containing many pre-written functions you can use
• two you have already used are setw and setprecision
• functions sometimes expect you to supply some information when you call them (e.g. the 7 in setw(7))
• some functions just perform a task, others might calculate and explicitly return a value to your program
  e.g. the math library's sqrt function

  #include <cstdio>
  #include <cmath>
  
  int main()
  {
      double Original, RootOfOriginal;
  
      printf( "Please enter any positive real number\n");
      printf("%lf", &Original);
     
      RootOfOriginal = sqrt(Original);
  
      printf( "The square root of %lf", Original);
      printf( " is %lf\n", RootOfOriginal);
  }
  

• the math library can be used by including <cmath>
• available routines include:

  fmod(x, y); // returns floating point remainder of x / y
  log(x);     // returns the natural logarithm of x
  pow(x, y);  // returns x raised to the power of y
  sqrt(x);    // returns the square root of x
  cos(x);     // returns the cosine of x
  

  all data is of type double
• if a function returns a value it can be used inside an expression, e.g.

      x = sqrt(3.0 / y) - z * cos(r);
  

• if a function returns a value you do need to do something with that value (e.g. store it in a variable, or print it out)

     sqrt(3.9);         // makes no sense
     printf("%lf", sqrt(3.9)); // prints out calculated value
     x = sqrt(3.9);     // stores calculated value
  

• A longer list of available math, character, and string functions available is given in appendix 2 (pp 881-882)

• the parameters to a function are simply the data items you must give the function, e.g.

       printf( "The fifth root of 3 is ");
          // the parameter to printf is "The fifth root of 3 is "
       printf("%lf\n", pow(3, 0.2));
          // the parameters to printf are "%lf\n" and pow(3, 0.2)
          // the parameters to pow are 3 and 0.2
  

• each function expects a certain number of parameters, each of the correct data type, and in the correct order
• suppose there was a function available called printbox, it expects three parameters:
  1. an integer, how many characters wide the box is
  2. an integer, how many characters tall the box is
  3. a character, what the box is to be filled with.
  e.g. printbox(4, 2, 'X'); would tell the routine to print two rows of four X's each:
• calling the routine with printbox(2, 4, 'X') would have completely different results

• we often use a function header to describe the parameters a function expects and the values returned
  • double fabs(double x)
    fabs expects one parameter, of type double, and returns a value of type double
    (returns the absolute value of the parameter)
  • double floor(double x)
    floor expects one parameter, of type double, and returns a value of type double
    (returns the value of the parameter but truncated to a whole number)
  • double fmod(double x, double y)
    fmod expects two parameters, each of type double, and returns one of type double
  • int isspace(char c)
    isspace expects one parameter, of type character, and returns an integer value (actually either 0 or 1)
    (returns 1 if the character is a kind of whitespace, 0 otherwise)
• Note that int main() is like a function that takes no parameters and returns no data (i.e. a return data type of void)

• There are three parts to creating your own function
  1. Declaring the function (not unlike declaring a variable) - describing its name and data types to the compiler
  2. Implementing the function (writing down the series of executable statements the function will run)
  3. Calling the function (e.g. actually using the function from the main routine)

  #include <cstdio>
  
  const float Pi = 3.14;
  
  // here is a declaration, summarizing a function
  // in terms of 
  //    the type of data it returns when it is completed (float)
  //    the name for the function (Calc_Circumference)
  //    the list of parameters the function needs to work on
  //        (a floating point number that it will use as a radius)
  float Calc_Circumference(float radius);
  
  int main()
  {
     printf( "Please enter the circle radius\n");
     float circ_radius;
     scanf("%f", &circ_radius);
     printf( "The circle circumference is ");
  
     // Call the function using its name and a value,
     // and use the return value as data for the printf statement
     printf("%f\n", Calc_Circumference(circ_radius));
  }
  
  // the actual implementation details of the function
  // first, repeating the header/declaration information,
  // then describing the sequence of actions used to 
  //      compute the function's result
  // then a return statement is used to send the calculated
  //      result back to whichever routine called the function
  float Calc_Circumference(float radius)
  {  // calculate and return circumference
     return(radius * Pi * 2.0);
  }
  

• We described top-down design as dividing a large problem into smaller and smaller subproblems, until we reached individual problems which were easy to solve
• The notion of functions interacts with this perfectly:
  • our main routine can call several high level functions to carry out the major tasks
  • each of these functions might carry out its task by calling several other functions
  • these may in turn call other functions, etc.
• this also allows us to test individual routines for correctness rather than having to implement and test the whole program at once

• the return type (i.e. kind of data the function will return): e.g. int, float, double, long, char, or void if the function does not return any data
• the name of the function: any valid identifier can be used, but the goal is to pick a meaningful name for your function
• the list of parameters expected by the function: this is zero or more pairs of data-types and variable names, with pairs separated by commas

// printdata prints out the passed parameters
// it does not return any value
void  printdata(int x, char y);

// getcommand needs no parameters, 
// it gets a single character command from the user 
// and returns this to the calling routine
char  getcommand();

// calculate area calculates and returns a rectangle's area 
// given the height and width parameters
float calculate_area(float width, float height);

<return type> <function name> ( <list of formal parameters> )
{
    // local variables,
    // executable statements,
    // return statement if return type not void
}

void printdata(int x, char y)
{
   printf( "The integer field has value %d", x);
   printf( ", while the character field is %c\n", y);
}

char getcommand()
{
   char cmd;
   printf( "Please enter a single letter command\n");
   scanf("%c", &cmd);
   return(cmd);
}

float calculate_area(float width, float height)
{
   return(width * height);
}

• the user (say the sales clerk in a paint shop) will enter the height and width of the wall
• the user will also enter, for the kind of paint desired, how many square metres of wall can be covered per litre of paint
• the user will also enter the cost of the paint per litre
• we must calculate how many litres are needed (paint is only sold in litres, so fractions must be rounded up), and how much that will cost
• finally summarise the information for the user

1. Get wall area from user
   1. Prompt user for wall dimensions (height, width in metres)
   2. Read in wall dimensions
   3. Return area = height * width
2. Get cost of paint (per litre) from user
   1. Prompt user, read in and return result
3. Get area of paint coverage (sq. metres per litre) from user
   1. Prompt user, read in and return result
4. Calculate amount of paint needed
   1. Exact amount of paint needed = area / coverage per litre
   2. Round up exact amount to nearest whole number
5. Calculate cost of paint
   1. Cost = number of litres needed * cost per litre
6. Display information
   1. Print the room area, coverage of paint, and cost of paint per litre
   2. Print number of litres needed, and corresponding cost

#include <cstdio>
#include <cmath>

float Get_wall_area();

float Get_paint_cost();

float Get_paint_coverage();

int Calculate_paint(float area, float coverage);

float Calculate_cost(int litres_paint, float unit_cost);

void Display_results(float area, float coverage, 
      float unit_cost, int litres_paint, float total_cost);

int main()
{
   float area, coverage, unit_cost, total_cost;
   int litres_paint;

   area = Get_wall_area();
   unit_cost = Get_paint_cost();
   coverage = Get_paint_coverage();
   litres_paint = Calculate_paint(area, coverage);
   total_cost = Calculate_cost(litres_paint, unit_cost);
   Display_results(area, coverage, unit_cost, 
                                litres_paint, total_cost);
}

float Get_wall_area()
{
    float height, width;
    printf( "Please enter the room height and width ");
    printf( "in metres, then enter return\n"); 
    scanf("%f", &height);
    scanf("%f", &width);
    return(height * width);
}

float Get_paint_cost()
{
   float cost;
   printf( "Please enter the paint cost per litre");
   scanf("%f", &cost);
   return(cost);
}

float Get_paint_coverage()
{
   float coverage;
   printf( "Please enter the number of square metres");
   printf( " of wall space that can be covered with ");
   printf( "a single litre of paint\n");
   scanf("%f", &coverage);
   return(coverage);
}

int Calculate_paint(float area, float coverage)
{
    return( int( ceil(area / coverage)));
}

float Calculate_cost(int litres_paint, float unit_cost)
{
    return( litres_paint * unit_cost );
}

void Display_results(float area, float coverage, 
     float unit_cost, int litres_paint, float total_cost)
{
    printf( "For a wall with area %f", area);
    printf( " square metres, we require ");
    printf( "%f litres of paint\n", litres_paint);
    printf( "costing %.2f", unit_cost);
    printf( " dollars per litre,\n");
    printf( "gives a total cost of $%f\n", total_cost);
}

• Sometimes we want to discuss the actual values a function receives as parameters while running, while at other times we want to discuss the list of parameters it is expecting
• Formal parameters refers to the parameter list in the function declaration and implementation, e.g.

  double foo(int x, char ch)
  

• Actual parameters refers to the actual values passed to the function when the program is running, e.g.

  myvar = foo(37, 'Y');
  

• Functions that have no parameters perform a fixed function
• That is, they do exactly the same thing each time they are run
• (Of course if they perform scanf statements they can still return different results on different runs, simply because the users can type in different things)
• In practice, most functions have 1 to 6 parameters

• All the parameters we have considered so far have been pass by value
• This means a copy of the parameter value is given to the function, and guarantees that the original data cannot be destroyed

  #include <cstdio>
  
  void XPlus1(int x);
  
  int main()
  {
     int myvar = 0;
     XPlus1(myvar);
     printf("%d", myvar);
  }
  
  void XPlus1(int x)
  {
     x = x + 1;
  }
  

• because XPlus1 only gets a copy of myvar, the real value of myvar (back in main) is not corrupted
• the output from this program would be "0"

void swap(int &x, int &y);

int main()
{
   int var1 = 13;
   int var2 = -5;
   swap(var1, var2);
   print("%d %d\n", var1, var2);
}

void swap(int &x, int &y)
{
   int temp;
   temp = x;
   x = y;
   y = temp;
}

#include <cstdio>

double get_area_height_width(float &height, float &width);

int main()
{
   float wallheight, wallwidth, wallarea;
   wallarea = get_area_height_width(wallheight, wallwidth)
   printf( "area %f = ", wallarea);
   printf( "width %f * ", wallwidth);
   printf( "height %f\n", wallheight);
}

double get_area_height_width(float &height, float &width)
// set width and height to user input values
// and return area = height * width
{
    printf( "Please enter the wall height\n");
    scanf("%f", &height);
    printf( "Please enter the wall width\n");
    scanf("%f", &width);
    return(width * height);
}

double myfunction(int &refparam);

int main()
{
   double x;
   int y;

   x = myfunction(3);  // illegal, 3 is not an integer variable
   x = myfunction(y);  // is o.k.
}

   // could appear inside myfunction
   refparam = 17;

// get the user to enter an integer in the range min..max
int getInteger(int min=0, int max=100);

However, if the function is called without parameters then it uses the default values supplied in the prototype.

For example, x = getInteger(3,10); would use 3 for min and 10 for max, but x = getInteger(); would use 0 for min and 100 for max.

If the function is called with only some of the optional parameters then it assumes the parameters at the end of the list are the ones that use default values. For example, the call x = getInteger(5); would use 5 for min and 100 for max.

Note that the default values are only placed in the prototype - if you place them in both the prototype and the full function implementation you will get a compile-time error.