C++ Functions

• Functions are a collection of statements performing a specific task.
• Functions are commonly used to break a problem down into manageable pieces.
• There are 2 types of functions in C++: library functions and user-defined functions.

Benefits of Using Functions

• A program divided into smaller problems, each handled by a separate function, is more organized.
• A program with one long, complex function has all the necessary statements to solve a problem.

Library Functions

• Library functions are built-in functions that come with the compiler.
• The source code for library functions does not appear.
• To use a library function, the proper header file is included, and the function name must be known.
• Use the #include compiler directive.

Common Library Functions

• Character classification and conversions use the <cctype> compiler directive.
• Math functions use the <cmath> compiler directive.
• Data conversions use the <cstdlib> compiler directive.
• Time functions use the <ctime> compiler directive.

Math Functions

• You must include <cmath> to use math functions.
• abs(x) returns the absolute value of an integer.
• pow(x,y) calculates x to the power of y; if x is negative, y must be an integer; if x is zero, y must be a positive integer.
• pow10(x) calculates 10 to the power of x.
• sqrt(x) calculates the positive square root of x, where x is >=0.

Character Manipulation

• The C++ library provides functions for testing characters.
• To use these functions, include the cctype header file.
• isalpha will return true if the argument is a letter; otherwise, it returns false.
• isalnum will return true if the argument is a letter or a digit; otherwise, false.
• isdigit returns true if the argument is a digit 0-9; otherwise, false.
• islower returns true if the argument is a lowercase letter; otherwise, false.
• isprint returns true if the argument is a printable character; otherwise, false.
• ispunct returns true if the argument is a punctuation character; otherwise, false.
• isupper returns true if the argument is an uppercase letter; otherwise, false.
• isspace returns true if the argument is a whitespace character; otherwise, false.

Character Case Conversion

• toupper converts a char argument; if it's a lowercase letter, it returns the uppercase equivalent; otherwise, the input is returned unchanged.
• tolower converts a char argument; if it's an uppercase letter, it returns the lowercase equivalent; otherwise, the input is returned unchanged.
• The cctype header file is required for case conversion functions.

User-Defined Functions

• User-defined functions are created by the programmer.
• User-defined functions are commonly used to break a problem down into small, manageable pieces.
• int main() is a function every C++ program possesses.
• Ideally, the main() function should be short and consist primarily of function calls.

Defining and Calling Functions

• Every function has a function call.
• A function call is a statement that causes a function to execute.
• Every function has a function definition.
• A function definition is the statements that make up a function

Function Definition

• A function definition includes the return type which is the data type of the value that function returns to the part of the program that calls it.
• It includes the name, which is the function name that follows the same rules as variables.
• It includes the parameter list. The parameter list consists of variables containing values passed to the function.
• The body consists of statements that perform the function's task, enclosed in {}.
• function-returntype function-name( parameter-list) is the general form of a function definition in C++.
• int main() is the function header.

Function Return Types

• If a function returns a value, the type of the value must be indicated; for example, int main().
• If a function does not return a value, its return type is void; for example, void printHeading().

Calling a Function

• To call a function, the function name followed by () and ; is be used; for example, printHeading();
• When called, the program executes the body of the called function.
• After the function terminates, execution resumes in the calling function at the point of call.

User-Defined Functions - Example

• Main can call any number of functions.
• Functions can call other functions.
• The compiler must know name, return type, number of parameters, and data type of each parameter before a function is called.

Function Prototypes

• A function prototype is a way to notify the compiler about a function before a call to the function.
• Place the function definition before calling the function's definition, or use a function prototype (function declaration).
• A function prototype looks like a function definition without the body.
• Place prototypes near the top of the program.
• If using prototypes, function definitions can be placed in any order in the source file.

Pass By Value

• Passing values into a function occurs at the time of call.
• For example, c = pow(a, b); passes a and b as function arguments.
• Values passed to a function are arguments.
• Variables in a function that hold the values passed as arguments are parameters.
• With pass by value, when an argument os passed to a function its valued is copied into the parameter..
• Changes to the parameter in the function do not affect the value of the argument

Reference Variables as Parameters

• A reference occurs when a function works with the original argument from the function call, not a copy of the argument.
• A reference allows the function to modify values stored in the calling environment.
• A reference provides a way for the function to return more than one value.
• A reference variable is an alias for another variable.
• Reference Variables are defined with an ampersand (&); for example, void getDimensions (int&, int&);
• Changes to a reference variable are made to the variable it refers to.
• Reference variables implement passing parameters by reference.

Reference Variables Notes

• Each reference parameter must contain &.
• There is no significance of the space between type and &.
• & must be used in both the prototype and header.
• The argument passed to a reference parameter must be a variable, not an expression or constant.
• Use when appropriate; do not use when the argument should not be changed by the function or if the function needs to return only one (1) value.