# Functions

## What are functions?

C and nearly all languages developed since allow us to write functions, sometimes also known as procedures, methods, or subroutines.

A function is a black box with a set of 0+ inputs and 1 output.

For example:

add(a, b, c)
// or
mult(a, b)

The add function takes the input from a, b, c and will have a single output.
The mult function takes the input from a, b and will have a single output.

Why call it a black box?
If we aren't writing the functions ourselves, we don't need to know the underlying implementation.

mult(a, b): can be implemented in many different ways, including:

• output a * b

Or

• set counter to 0
• repeat b times (ex. 3)
• add a to counter (ex. 5)
• output counter (counter will add 3 five times with the same output as a * b)

That's part of the contract of using functions. The behavior is typically predictable based on the name. That's why most functions have clear, obvious(ish) names, and are well-documented.

## Why us functions?

Organization

• Functions help break up a complicated problem into more manageable subparts.

Simplification

• Smaller components tend to be easier to design, implement, and debug.

Reusability

• Functions can be recycled; you only need to write them once, but can use them as often as you need!

## Function Declarations

The first step to creating a function is to declare it. This gives the compiler a heads-up that a user-written function appears in the code.

Function declarations should always go atop your code, before you begin writing the main().

There is a standard form that every function declaration follows:

return-type name(argument-list);

The return-type is what kind of variable the function will output.
The name is what you want to call your function.
The argument-list is the comma-separated set of inputs to your function, each of which has a type and a name.

Here is an example of a function declaration for a function that would add two integers together:

int add_two_ints(int a, int b);

The sum of the two integers is going to be an integer as well.
Given what this function does, make sure to give it an appropriate name (like add_two_ints).
There are two inputs to this function (each of which is an integer), and we need to give a name to each of them for purposes of the function. There's nothing important about these inputs as far as we know, so giving them a simple name is okay (a and b).

Another example for floating point numbers could be:

float mult_two_floats(float x, float y);

The product of two floating point numbers is also a floating point number.

## Function Definitions

The second step to creating a function is to define it. This allows for predictable behavior when the function is called with inputs.

Let's try to define the mult_two_floats from above.

float mult_two_floats(float x, float y);

float mult_two_floats(float x, float y)
{
float product = x * y;
return product;
}

Or more simply:

float mult_two_floats(float x, float y);

float mult_two_floats(float x, float y)
{
return x * y;
}


Now lets define add_two_ints() from earlier:

int add_two_ints(int a, int b);

{
int sum;        //declare variable
sum = a + b;    //calculate the sume
retruen sum;    //give result back
}


## Function Calls

To call a function, simply pass it appropriate arguments and assign its return value to something of the correct type.

Here is an example with a file called adder.c:

// includes
#include <cs50.h>
#include <stdio.h>

// declare function prototype

int main(void)
{
int x = get_int("Give me an integer: ");
int y = get_int("Give me another integer: ");

// add the two numbers together via a function call

// output the result
printf("The sum of %i and %i is %i!\n", x, y, z);

}

{
int sum = a + b;
return sum;
}


## Function Miscellany

Recall from our discussion of data types that functions can sometimes take no inputs. In that case, we declare the function as having a void argument list. An example of this would be int main(void).

Recall also that functions sometimes do not have an output. In that case, we declare the function as having a void return type.

## Practice Problem

We will declare and write a function called valid_triangle that takes three real numbers representing the lengths of the three sides of a triangle as its arguments, and outputs either true or false, depending on whether those three lengths are capable of making a triangle.

Note the following rules about triangles:

• A triangle may only have sides with positive length.

• The sum of the lengths of any two sides of the triangle must be greater than the length of the third side.

bool valid_triangle(float x, float y, float z);

bool valid_triangle(float x, float y, float z)
{
//check for all positive sizes
if (x <= 0 || y <= 0 || z <= 0)
{
return false;
}

//check that the sum of any two sides is greater than the third
if ((x + y <= z) || (x + z <= y) || (y + z <= x))
{
return false;
}

//if both checks pass, we output true!
return true;
}


Now lets make one that takes in user input for fun!

#include <cs50.h>
#include <stdio.h>

int main(void)
{
bool valid_triangle();
float x = get_float("Give me the size of the first side of the triangle: ");
float y = get_float("Give me the size of the second size of the triangle: ");
float z = get_float("Give me the size of the third side of the triange: ");

//check that all floats are positive
if (x <= 0 || y <= 0 || z <= 0)
{
printf("Not a valid triangle.\n");
return false;
}

//check that the sum of any two sides is greater than the third
if ((x + y <= z) || (x + z <= y) || (y + z <= x))
{
printf("Not a valid triangle.\n");
return false;
}

//if both checks pass, we output true!
printf("That is a valid triangle!\n");
return true;
}