Whenever a function is called, the program flow is redirected into that function, running from top-to-bottom as normal (with branching and loops changing that flow). Once the function has completed, it can return some data, which is received by the call location.

From a design standpoint, this means we can break out different parts of programs into their own sections. Each function has a name, which should be used to label what the purpose of its code is.

In algebra, you've seen functions like this:

\[ f(x) = 2x + 3 \]

If you were like me in algebra, you might have thought to yourself, "That's the same as \(y = 2x + 3\), why did we replace \(y\) with \(f(x)\)?" The reason is that we want to write a function in terms of its input, \(x\), and its output \(f(x)\). The equation \(2x + 3\) is the function body, which specifies how we get some output given some input.

We can use functions in programming like with math as well - defining formulas that we might need a lot - but there's more to functions than just making computations.

Let's say we want to make our "GetArea" function in math. We would need two inputs: Width and Length, and the output would end up being the area, so maybe we would name the function \(A\). It might look like this:

\[ A( w, l ) = w \cdot l \]

In C++, it would look like this:

Example:

float Area( float width, float length ) {
  return width * length;
}

(Luckily we don't have to restrict ourselves to single-letter variable and function names in C++ :)

Functions can also be handy in validating data and user input, putting the validation in one place instead of having to re-implement the same checks over and over. Let's say we want to keep some variable percentage in our program between 0% and 100% - no negative values, nothing over 100%. We could implement a function that takes the percentage as an input, and either returns the same percentage, or 0%, or 100% as output…

Function definition:

int BoundPercent( int originalPercent ) {
  if ( originalPercent < 0 ) {
    return 0;
  }
  else if ( originalPercent > 100 ) {
    return 100;
  }
  else {
    return originalPercent;
  }
}

Then, anywhere in the program, we could use this function to make sure our percentages are in the right range…

Within main()…

hungerPercent       = BoundPercent( hungerPercent );
healthPercent       = BoundPercent( healthPercent );
happinessPercent    = BoundPercent( happinessPercent );

Getting user input is a common part of writing software, and we will usually need to validate what the user is entering prior to doing any operations on it. Let's say your program is full of numbered menus and you want to validate the user's menu choices easily. You can use a function with a while loop in it:

int GetUserInput( int min, int max )
{
  int choice;
  cout << "Choice: ";
  cin >> choice;

  while ( choice < min || choice > max )
  {
    cout << "Invalid choice, try again: ";
    cin >> choice;
  }

  return choice;
}

You write this function once and then you can reuse it in your entire program for all menus…

cout << "1. Deposit money" << endl
     << "2. Withdraw money" << endl
     << "3. View balance" << endl;

choice = GetUserInput( 1, 3 ); // 1, 2, or 3

if ( choice == 1 )
{
  cout << "1. Checking account" << endl
       << "2. Savings account" << endl;
  choice = GetUserInput( 1, 2 ); // 1 or 2
}

Functions aren't required to return data. Sometimes, you just want a function that is responsible for formatting output or displaying a menu. In this case, a function's return type can be void.

void DisplayStudentInfo( string name, float gpa )
{
  cout << "Name:   " << name
       << "GPA:    " << gpa << endl;
}

You also aren't required to pass input to functions. In this case, the parameter list between ( ) remains empty, but the () is always required for functions:

void DisplayMainMenu()
{
  cout << "1. Deposit" << endl;
  cout << "2. Withdraw" << endl;
  cout << "3. View Balance" << endl;
  cout << "4. Log Out" << endl;
}

These are just some examples of why you might use functions in your programs. Anything you write in main() can go inside of a different function as well - it's just another tool for designing clean, maintanable, and readable code.

A function signature in C++ is required as part of both the function declaration and the definition. The signature is how you tell functions apart - what makes them unique… their signature.

The function signature takes this form:

RETURN_TYPE FUNCTION_NAME( PARAM1TYPE PARAM1NAME, PARAM2TYPE PARAM2NAME, ... )

So for instance, a GetArea function signature could look like this:

float GetArea( float width, float length )

When we want to create a function we need to write a function declaration and a function definition.

The function declaration is the function signature and a ; at the end. Declarations should go in header (.h) files.

int Func( int a, int b );

The definition includes the function signature but also a code block - denoted by opening and closing curly braces { }. Within this code block is where we define what the function does.

int Func( int a, int b )
{
  return a * b + 1;
}

When we have our functions declared in a file separate from where we have our main(), in order for our main file to "see" the new function, we have to include the file. Any other files in our program will also need to include the header if it is using functions within that file.

#include "MYFILE.h"

Note: DO NOT use include for cpp files! This will cause build errors!

The third piece is the function call, when we are actually putting it into use in our code. The function call occurs from outside of the function, such as within main() (or, one function can call another function!)

The function call is of this form:

FunctionName( arg1, arg2, arg3 );

Or, if the function returns data, we need to make sure to put the result somewhere. The data type of the variable you use to store the result should match the function's return type:

float result = Sum( 2, 4 );

We can pass hard-coded literals in as the input, or we can pass in existing variables as the inputs.

float num1 = 3;
float num2 = 5;
float result = Sum( num1, num2 ); // Two variables
float result2 = Sum( 1, 3 );      // Two int literals
float result3 = Sum( num1, 3 );   // A variable and a literal

float PricePlusTax( float price, float tax );

Another key piece of terminology is parameters versus arguments.

When we're declaring or defining a function and we have input variables in the signature, like this:

float Sum( float a, float b );

Those two input variables a and b are known as parameters. When we're creating the function, we define the input parameters.

When we're calling the function and passing in data - whether as a literal or a variable's data, like this:

float result = Sum( 1, 2 );
float result = Sum( myNum1, myNum2 );

The data being passed as input are called arguments.

Variables have different life times. Where they exist in the program is known as its scope. A variable lives within the code block { } it is declared within, and does not exist outside of it.

For example, this variable totalCats will exist all throughout main():

int main()
{
  int totalCats = 10;
  // ...
}

And the variable quotient only exists within this if statement:

int main()
{
  float num = 3, denom = 4;

  if ( denom != 0 )
  {
    float quotient = num / denom;
  }

  // ...
  return 0;
}

Variables can be used within code blocks that are inside their own code block and beneath where the variable is declared. Here, a can be used anywhere in main(), including in the if statement. b, however, can only be used within main() anywhere after its declaration. c can only be used inside the if statement it was declared within:

int main()
{
  int a = 1;

  if ( a < 0 )
  {
    int c = -a;
  }

  int b = 2;
  cout << b << endl;

  // ...
  return 0;
}

Just like how a variable declared at the top of main() will exist throughout main(), the same is true for functions. If we declare a variable at the top, we can use it throughout the entire function - and, we can use the function's parameters anywhere within the function.

But variables don't exist between functions. Something declared in one function cannot be used in another function. Variable names can, however, be reused in different scopes.

float SandPerGuest( float sand, float guest ) { return sand/guest; }

int main()
{
  float totalSandwiches = 10;
  float totalGuests = 5;

  if ( totalGuests != 0 )
  {
    float sandwichesPerGuest = SandPerGuest( totalSandwiches, totalGuests );
    cout << "Sandwiches per guest: " << sandwichesPerGuest << endl;
  }


  return 0;
}

float Sum( float a, float b )
{
  return a + b;
}

float Diff( float a, float b )
{
  return a - b;
}

When declaring a function, you can also set default parameters. These are the default values assigned to the parameters if the user doesn't pass anything in. The default parameters are only specified in a function declaration - NOT the definition!

In this example, it could be a function that displays ingredients for a recipe, and by default the batch is set to 1.0 (one batch).

void OutputIngredients( float eggs, float sugar, float flour, float batch = 1.0 );

The function could be called without passing in a batch:

cout << "Ingredients:" << endl;
OutputIngredients( 1, 2.0, 3.5 );

Or they could pass a batch amount explicitly:

cout << "Ingredients:" << endl;
OutputIngredients( 1, 2.0, 3.5, 0.5 );  // half batch

You can have multiple default parameters specified in your function declaration - but all variables with default values must go after any variables without default values.

In C++, you can also write multiple functions that have the same name, but a different parameter list. This is known as function overloading.

Let's say you want to be able to sum numbers, and you make a version for floats and a version for integers:

int Sum( int a, int b )
{
  return a + b;
}

float Sum( float a, float b )
{
  return a + b;
}

You can write as many versions of the function as you like, so long as the function headers are uniquely identifiable to the compiler, which means:

• The functions have a different amount of parameters, or
• The data types of the parameters are different, or
• The parameters are in a different order (when mixing data types).

These will become much more useful once we cover classes and objects.