Modular Programming and Functions Quiz

Learning Outcomes

• Students should be able to explain modular programming benefits.
• Describe the concept of a function.
• Identify function types.
• Define, declare, and call functions.
• Use actual and formal parameters.
• Differentiate between value-returning and non-value-returning functions.
• Identify local and global variables and their scope.

Modular Programming

• Programs can be subdivided into manageable subtasks.
• Modular programming breaks down complex tasks into smaller functions.
• Advantages include:
  • Ease of implementation by multiple programmers.
  • Improved readability, testing, and maintenance.
  • Reduced code duplication through function reuse.

Function Concept

• Functions accept zero or more input data.
• Functions perform operations or produce side effects on the input data.
• Functions return, at most, a single value.
• A function definition outlines how a function performs its task.
• A function call initiates a function's execution.

Types of Functions

• Standard Library (Pre-defined) Functions:
  • Function definitions are stored in header files.
  • Programmers need to understand how to use them, and which header to import.
  • Examples: mathematical functions (pow, sqrt, log) in the <cmath> header.
• Programmer-Defined Functions:
  • Functions that are created by the programmer.
  • Perform specific tasks.
  • Can receive multiple data values or addresses (pass-by-value/reference).
  • Can return a single value or modify external data (pass-by-reference).
  • Must be declared and defined prior to use.

Functions in C++ Programs

• The main function is a programmer-defined function, unique to a program and essential.
• main often calls standard library functions.
• main can call other programmer-defined functions.
• Programmer-defined functions can also call each other.

Pre-defined Functions (Examples)

• log(x): Natural logarithm of x.
• log10(x): Logarithm base 10 of x.
• pow(x, y): x raised to the power of y.
• sin(x): Sine of x (in radians).
• sqrt(x): Square root of x.
• tan(x): Tangent of x (in radians).

Programmer-Defined Function

• Has three parts for use: Declaration, Call, and Definition.
• Function Definition (code):
  • Return type: The data type of the value returned.
  • Function name: A valid identifier.
  • Formal parameter list: Defines the variables to hold input data.
• Function Declaration (prototype):
  • States the function’s return type, name, and parameter types.
  • Placed in the global area, above the main or other functions.
  • Example: int multiply(int, int);
• Function Call (invocation):
  • Calls a defined function.
  • Example: product = multiply(multiplier, multiplicand);

Function Definition (Body)

• Contains local declarations (variable declarations).
• Statements performing the tasks of the function.
• A possible return statement.

Function Parameter

• Actual parameters: Expressions used within function calls.
• Formal parameters: Variables declared in the function definition.
• Matching types, order and number of parameters in call and definition are essential for function calls.

Function Call - Flow of Control

• Program execution transitions into the function body when a function is called.
• The calling function resumes at the point of the call after the called function completes.

Trace Function Invocation

• Step-by-step execution of function calls.
• Shows how data values are passed and returned.

Void Functions

• A function that does not return a value.
• Return type void.

Variable Scope

• Global Scope: Variables declared outside any function are accessible throughout the program from the declaration point and onwards.
• Local Scope: Variables declared within a function are only accessible within that function.
• Static Local Variables: Local variables that retain their values between function calls, maintaining their value until the entire program ends.

Local Variables

• Exist only during a function's execution.
• Values are lost between calls.

Global Variables

• Declared outside any function.
• Accessible from anywhere within the program after declaration.
• Generally discouraged due to increased complexity and debugging difficulty.