Lecture Notes: Functions in C++

Introduction to Modular Programming

• Modular Programming: Concept of functions in C++.
  • Traditionally, programs are written as a long series of statements.
  • Modular programming introduces breaking down programs into smaller functions for clarity and organization.
• Functions: Called in int main to perform tasks and improve readability.
  • Functions do specific tasks and can optionally return results.
  • Functions are called methods in languages like Java and C#.

Types of Functions

• No Parameters & No Return Value: Function performs a task without returning a value.
• With Parameters: Performs tasks based on parameter values.
• With Return Type: Returns a value, similar to mathematical functions.

Defining and Calling Functions

• Function Definition: Statement that defines the function's action, occurs once.
• Function Call: Statement that executes the function, can occur multiple times.
• Function Components:
  • Function Header: Specifies return type, name, and parameters.
  • Function Body: Contains the statements executed by the function.

Function Execution Flow

• After a function call, execution resumes immediately after the call.
• Functions can call other functions.

Function Prototypes

• Used to inform the compiler of a function before it is defined.
• Allows defining functions in any order after the prototype.
• Prototype Style: Define prototypes at the top, then implement functions.

Passing Data to Functions

• Passing by Value: Copies argument value to function parameter.
• Formal vs Actual Parameters:
  • Formal: Defined in function header.
  • Actual: Value passed during the call.
• Arguments are promoted/demoted to match parameter data types.
• Multiple Arguments: Must match order and number in the function definition.

Function Return Values

• Return Statement: Ends function execution and returns a value.
  • Used for early exits in error conditions.
• Returning Values:
  • Prototype and definition must indicate the return type.
  • Returned value can be used in expressions or stored in variables.

Local and Global Variables

• Local Variables: Exist only during function execution, are hidden from other functions, and are default initialized to zero.
• Global Variables: Defined outside all functions, accessible throughout the program but risky for debugging.

Static Local Variables

• Retain values between function calls.
• Useful for maintaining state within a function across calls.

Default Arguments

• Allow some parameters to have default values.
• Must start from a certain point and continue for the rest of the parameters.

Reference Variables

• Passing by Reference: Allows function to modify arguments using references.
• Useful for functions needing to return multiple values.

Function Overloading

• Multiple functions with the same name but different parameter lists.
• Allows different operations based on the number and types of arguments.

Exit Function

• Exit Function: Immediately terminates the program, passing status to the OS.

Testing with Stubs and Drivers

• Stubs: Dummy functions for incomplete code.
• Drivers: Test functions by calling them to ensure correctness.

---

• Next Topic: Arrays and Vectors in C++.