Programming Chapter 9: Subprograms

<p>User-defined conversions between types. (C)</p> Signup and view all the answers

<p>It formats any type for printing. (D)</p> Signup and view all the answers

<p>Through defining methods with specific names. (B)</p> Signup and view all the answers

<p>F# generic functions have less utility due to type inference restrictions. (D)</p> Signup and view all the answers

<p>They can work with any collection class. (C)</p> Signup and view all the answers

<p>They allow for the storage of local variables shared among several subprograms. (A), They have quicker allocation times compared to static variables. (C)</p> Signup and view all the answers

<p>In mode (D)</p> Signup and view all the answers

<p>C and C++ (A)</p> Signup and view all the answers

<p>It requires additional storage due to copies. (A)</p> Signup and view all the answers

<p>Support for closures depends on the language's implementation of nested subprograms. (D)</p> Signup and view all the answers

<p>A method that can operate on multiple data types. (B)</p> Signup and view all the answers

<p>C# supports type inference directly. (A)</p> Signup and view all the answers

<p>They maintain their values between invocations. (D)</p> Signup and view all the answers

<p>The formal parameter acts as a local variable and transmits the value back only at the end. (D)</p> Signup and view all the answers

<p>It can lead to unwanted side effects and aliasing. (D)</p> Signup and view all the answers

<p>Binding occurs at the time of reference or assignment, enabling late binding. (D)</p> Signup and view all the answers

<p>The previous value of the parameter may be lost if not handled correctly. (B)</p> Signup and view all the answers

<p>Pass-by-value-result involves returning the final value back to the caller. (C)</p> Signup and view all the answers

<p>An access path to the actual parameter is provided during the call. (D)</p> Signup and view all the answers

<p>Increased risk of unwanted side effects. (C)</p> Signup and view all the answers

<p>Elimination of copying values, leading to efficiency. (C)</p> Signup and view all the answers

<p>They enable multiple functionalities under the same function name. (A)</p> Signup and view all the answers

<p>Static variables retain their value between function calls, while dynamic variables do not. (A)</p> Signup and view all the answers

<p>When the subprogram is called frequently and needs to maintain state. (C)</p> Signup and view all the answers

<p>Closures capture their surrounding state, while regular functions do not. (C)</p> Signup and view all the answers

<p>They simplify the coding process by reducing the number of functions needed. (A)</p> Signup and view all the answers

<p>It is a function that can be interrupted and resumed at a later time. (A)</p> Signup and view all the answers

<p>They can retain access to variables that are out of scope. (A)</p> Signup and view all the answers

<p>Parameter ambiguity can arise when distinguishing between overloads. (A)</p> Signup and view all the answers

<p>They allow for non-blocking execution and can yield control efficiently. (C)</p> Signup and view all the answers

<p>Pass-by-value uses a copy of the data, while pass-by-reference uses the original data. (A)</p> Signup and view all the answers

<p>Static local variables (D)</p> Signup and view all the answers

<p>When the exact value passed needs to be evaluated multiple times within the function. (B)</p> Signup and view all the answers

<p>It can lead to unexpected side effects on the original data. (B)</p> Signup and view all the answers

<p>It returns a modified value of the formal parameter to the caller. (B)</p> Signup and view all the answers

<p>Pass-by-value-result (A)</p> Signup and view all the answers

<p>Inout mode (A)</p> Signup and view all the answers

<p>Whether the data needs to be modified within the function. (D)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>The original variable remains unchanged regardless of modifications. (B)</p> Signup and view all the answers

<p>Pass-by-reference (B)</p> Signup and view all the answers

<p>When the original data should remain unchanged. (C)</p> Signup and view all the answers

<p>Unintended side effects on the original variable can occur. (C)</p> Signup and view all the answers

<p>It evaluates the actual parameter each time it is accessed. (C)</p> Signup and view all the answers

<p>A new copy of the array is created and modifications don't affect the original. (B)</p> Signup and view all the answers

<p>The actual parameter is initialized with the results after execution. (A)</p> Signup and view all the answers

<p>Pass-by-value (B)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>True (A)</p> Signup and view all the answers

<p>False (B)</p> Signup and view all the answers

<p>They require runtime memory management leading to overhead. (C)</p> Signup and view all the answers

<p>When caching computed values across subprogram invocations. (D)</p> Signup and view all the answers

<p>Depth-first search in graph traversal. (D)</p> Signup and view all the answers

<p>They are suitable for recursive function implementations. (A)</p> Signup and view all the answers

<p>They automatically release memory upon function exit. (A)</p> Signup and view all the answers

<p>They enhance code readability and API design. (A)</p> Signup and view all the answers

<p>C++, Java, and C# (A)</p> Signup and view all the answers

<p>By enabling the same function name for different parameter types. (B)</p> Signup and view all the answers

<p>They can confuse programmers with similar function signatures. (C)</p> Signup and view all the answers

<p>They allow functions to handle various data types without rewriting code. (C)</p> Signup and view all the answers

<p>Coroutines can suspend and resume execution at specific points. (C)</p> Signup and view all the answers

<p>Lua, Python, and C# (C)</p> Signup and view all the answers

<p>Coroutines reduce overhead by allowing functions to pause and resume. (A)</p> Signup and view all the answers

<p>await (A)</p> Signup and view all the answers

<p>They can suspend operations while waiting for I/O without blocking. (D)</p> Signup and view all the answers

<p>Coroutines require preemptive multitasking to function. (B)</p> Signup and view all the answers

<p>Animating characters in game development. (D)</p> Signup and view all the answers

<p>Coroutines can't implement complex task parallelism as reliably as threads. (C)</p> Signup and view all the answers

<p>A combination of a function and its environment (A)</p> Signup and view all the answers

<p>They eliminate the need for additional objects to maintain state (D)</p> Signup and view all the answers

<p>In event handling to preserve state across calls (B)</p> Signup and view all the answers

<p>A function returning another function that can access its variables (A)</p> Signup and view all the answers

<p>They allow functions to keep unique references to creation parameters (A)</p> Signup and view all the answers

<p>Java 7 (D)</p> Signup and view all the answers

<p>They often lead to increased memory consumption due to retained variables (C)</p> Signup and view all the answers

<p>They preserve the original function's state while modifying behavior (D)</p> Signup and view all the answers

A generic type that can represent any type of collection; a wildcard type for collection classes. It allows a method to accept any collection, regardless of the specific type of elements it contains.

Methods that can work with various data types. Type parameters in function calls can be omitted if the compiler can determine the unspecified type.

F# automatically determines a generic type if it cannot determine the type of a parameter or return type.

The process in F# where generic types are automatically inferred if the type is unknown.

When function parameters are used with arithmetic operators, resulting in type constraints, even if they're generic.

Operators (like addition) can be customized to work with custom data types (such as in Python).

Python's add method is how you define the addition operation for a Complex data type.

F# generic functions, though useful, are less so than in other languages due to type inference and lack of type coercion.

Parameter passing where no initial value is transmitted. The subprogram's formal parameter acts as a local variable and the caller's corresponding actual parameter receives the value from the subprogram.

A combination of pass-by-value and pass-by-result. Formal parameters have local storage and the value is returned to the caller.

Passing an access path to a parameter, efficient because of sharing.

Potential for unwanted side effects (collisions) and broadened access (aliases) because of shared reference.

In languages like C, formal parameters can be changed in the subprogram. Implementation varies amongst languages, some prevent changes.

Parameter binding is via textual substitution; the actual binding to a value or address happens later, and the environment of the caller is passed enabling later address calculation.

Different parameter passing methods have varying efficiency in terms of copying and storage needs.

Multiple names or references can refer to the same memory location or object, creating potential for unexpected consequences when modifying these references.

Local variables that are allocated on the stack when a subprogram is called and deallocated when the subprogram returns. This allows storage to be shared among subprograms but can lead to overhead for allocation, de-allocation, and initialization.

Local variables whose memory is allocated once, at the beginning of program execution, and remains allocated throughout the program's lifetime. They retain their values between calls to the subprogram, making them suitable for storing state.

A parameter passing mechanism where the value of the actual parameter is copied into the formal parameter. Changes to the formal parameter do not affect the actual parameter.

A parameter passing mechanism where the value of the formal parameter is copied back to the actual parameter when the function completes. The actual parameter is used as an output variable.

A parameter passing mechanism where the formal parameter uses the same memory location as the actual parameter. Changes to the formal parameter directly affect the actual parameter.

A copying mechanism where a copy of the actual parameter's value is made and used for the formal parameter. Changes made to the formal parameter only affect the copy, not the original.

A parameter passing mechanism where the actual parameter's value is physically copied into the memory location of the formal parameter.

A parameter passing mechanism where the formal parameter receives an access path (pointer or reference) to the actual parameter's memory location, allowing direct modification of the original value.

Local variables that are created and destroyed as needed during program execution.

Static local variables maintain their state between function calls, while dynamic local variables are created and destroyed with each call.

The ability to define multiple functions in the same scope with the same name but different parameter lists (types and number of parameters).

A function or procedure that can work with different data types. It uses type parameters to represent the data types, allowing the subprogram to be reused with different types.

The set of variables and functions that are accessible to a subprogram at the time it is executed. It includes not only the subprogram's local variables but also variables from any enclosing scopes.

A combination of a function and its referencing environment. This allows the function to retain access to variables that are no longer in scope.

A subprogram that generalizes subroutines for non-preemptive multitasking. Allows multiple entry points and suspension of execution without losing state.

Enhance code reusability and flexibility. Reduce code complexity by allowing one function name for multiple functionalities. Improve maintainability and readability.

Promote code reusability and flexibility by working with varying data types. Allow for generic algorithms and data structures. Reduce the need for repetitive code generation.

Allow functions to maintain state across calls, enabling complex behavior. Facilitate data hiding and encapsulation. Support for functional programming paradigms.

A parameter passing mechanism where the value of the actual parameter is copied into the formal parameter. Changes to the formal parameter do not affect the actual parameter.

A parameter passing mechanism where the value of the formal parameter is copied back to the actual parameter after the function completes. The actual parameter is used as an output variable.

A parameter passing mechanism where the formal parameter uses the same memory location as the actual parameter. Changes to the formal parameter directly affect the actual parameter.

The combination of a subprogram's name and the data types of its parameters. It defines the kind of information a subprogram needs to operate correctly.

Static local variables are more efficient when the variable needs to maintain state across multiple function calls. Dynamic variables add overhead with creation and destruction.

Unexpected consequences caused by modifying data in a subprogram that affects the calling function.

Different parameter passing methods offer varying efficiency in terms of copying and storage needs. Pass-by-value might be less efficient for large objects compared to pass-by-reference.

Unexpected changes to the original data outside the function due to modifications made to the parameter within the function. This can happen with pass-by-reference methods.

Provides safety against unintentional side effects by working with a copy of the original value. Useful for passing configuration values that shouldn't be modified.

Can be inefficient for large parameters, like complex objects or arrays, because it requires copying the entire data.

Pass-by-Reference is more memory-efficient because it doesn't create a copy of the original data. It works directly with the original data.

It increases the risk of unintentional side effects. Changes made to the parameter within the function can affect the original data.

By creating a copy of the parameter, changes made within the function are isolated to the copy, leaving the original value intact.

A programming technique where a subprogram calls itself within its own code, often used for tasks like calculating factorials or traversing tree structures.

The current condition or information held by a subprogram, including the values of its variables and its position in execution.

Storing values in a memory location to avoid repeating calculations. This can improve efficiency by reducing the need to recalculate values.

They are suitable for recursive algorithms, where each call needs independent state, like calculating factorials or traversing tree structures.

They're useful for scenarios where maintaining state is required, such as caching computed values, as the value persists across calls.

Multiple functions sharing the same name but differentiated by their parameter profiles (data types and number of parameters).

Enhanced code reusability, reduced complexity through a single name for multiple functionalities, improved maintainability and readability.

Increased code reusability, flexibility by working with different data types, generic algorithms and data structures, less repetitive code.

By having a single logical name for different functionalities, the API becomes easier to understand and use.

Subprograms that enable non-preemptive multitasking, allowing execution to be paused and resumed without losing state, making them ideal for tasks requiring concurrency without full threading.

Often used in I/O-bound applications, such as web servers or user interfaces, where tasks like waiting for user input or database interaction can be suspended to improve responsiveness.

Coroutines are more efficient than threads because they don't need complex synchronization mechanisms, making them easier to debug and maintain.

'async' defines a coroutine function, while 'await' pauses the coroutine until the awaited task completes.

Similar to Python, 'async' marks a function as a coroutine, and 'await' pauses execution.

They offer efficient multitasking without thread management overhead, simplified concurrency compared to threads, and reduced debugging complexity.

Coroutines are used to animate characters or manage user input across frames, ensuring smooth game flow.

'yield' is used in coroutines to return a value and pause execution until resumed, often with a 'next()' call.

Closures are useful for creating factory functions, where you can create functions with specific initial parameters.

Closures simplify code by eliminating the need to create separate classes or objects to manage state.

Functions in JavaScript retain access to their surrounding variables, creating closures.

Functions in Python also form closures, allowing them to hold onto outer variables.

Closures are essential in functional programming because they enable state management without altering the global state.

In web development, closures can be used to create event listeners that retain information about UI elements when created.

When a button is clicked, the closure associated with that button can access its unique ID to execute specific actions.