B

06.Functions

Computer Science I COSC 1020

  • Georgetown University

Functions Overview

Chapter 6: Functions

Key Topics

  • What’s a function?

    • Modular programming (6.1)

    • Defining and calling functions (6.2)

    • Function prototypes (6.3)

  • Function inputs and outputs

    • Sending data into functions (6.4)

    • Pass-by-value (6.5)

    • Reference variable params (6.13)

    • Arrays as function arguments (8.9)

    • Return statements (6.6-8)

  • Functions, scope, and lifetime

    • Local and global variables (6.10)

    • Static variables (6.11)

    • The exit() function

  • Designing with functions

    • Menu-driven programs (6.9)

    • Stubs and drivers (6.16)

    • Documenting functions

    • Default arguments (6.12)

    • Overloading functions (6.13)

What is a Function?

  • Functions encapsulate behavior and enhance modularity.

The UNIX Programming Philosophy

  • Emphasizes combining simple programs for complex functionality (Kernighan and Pike).

Divide and Conquer Approach

Modular Programming

  • Break problems into smaller pieces.

  • Solve and then combine these solutions.

Procedural Programming

  • Express sub-problems as procedures or functions.

Procedural Programming in C++

  • Functions are self-contained units with inputs and outputs.

Benefits of Procedural Programming

Source Code Quality

  • Simplifies debugging and enhances readability.

Reusability

  • Functions allow code repetition without redundancy (DRY principle).

Abstraction and Encapsulation

  • Separate what a function does from how it does it, promoting easier updates.

Defining a Function

  • Functions require declarations and definitions.

  • Essential components: identifier, parameter list, and return type.

The main() Function

  • Is a function itself with specific components including identifiers and a return type.

Calling a Function

  • Execution pauses on calling; control returns to the caller after the function completes.

Function Locations

  • Functions can be called in various contexts based on their return type and expected value.

Void-Returning Functions

  • Do not produce an output value.

Function Calls Producing Output

void print_message() {
    cout << "Hello from print_message";
}

Example Output:

  • "Hello from main"

  • "Hello from print_message"

  • "Back again in main"

Function Declarations

  • Must appear before use.

  • Verify proper identifier, argument types and numbers.

Function Prototypes

  • Declare function header without definition.

Inputs and Outputs in Functions

Function Inputs

  • Functions may require inputs, enhancing their versatility.

Parameter and Argument Terminology

  • Arguments: values passed during a function call.

  • Parameters: variables representing those arguments within the function.

Example of Arguments

double root2 = sqrt(2);
double rootn = sqrt(num);
double c = sqrt(a*a + b*b);

Pass-by-Value

  • Function copies the argument value; original variable remains unchanged.

Function Call Stack

  • Each function has its own stack frame for handling parameters and local variables.

Reference Variables

  • Allow sharing memory locations, modifying the original data in the calling context.

Using Reference Variables

Declaration Example

int& reference = number;

Benefits of Pass-by-Reference

  • Allows functions to modify original variables directly and efficiently share data.

Global Variables

Definition and Scope

  • Declared outside function, accessible anywhere in the code.

Downsides

  • Increase complexity and hinder readability.

Static Local Variables

  • Persist beyond function calls, allowing functions to maintain state without global variables.

Exiting a C++ Program

Normal Exit

  • Occurs when main() returns a value.

Abnormal Exit

  • Use of exit() function to terminate execution without returning control.

Designing with Functions

Menu-driven Programs

  • Functions enhance program organization, allowing for clearer interfaces.

Stubbing and Driver Functions

  • Useful in testing function behavior separately before full implementation.

Documenting Functions

Good Practices

  • Use descriptive function names and comments to clarify purpose and usage.

Default Arguments

  • Simplifies function calling by allowing omission of common arguments.

Example Declaration

void foo(int a, char b, string c = "", float d = 3.14);

Function Overloading

  • Different functions can share names so long as their parameter lists differ.

Why Overload?

  • To provide flexibility in handling different data types with the same operation.