Question

Suppose that you have the following declarations: int times[30][7]; int speed[15][7]; int trees[100][7]; int students[50][7]; a. Write the definition of the function print that can be used to output the contents of these arrays. b. Write the C++ statements that calls the function print to output the contents of the arrays times, speed, trees, and students.

Short answer

Define a generic print function for 2D arrays and call it with the respective arrays.

Step-by-step solution

Define the print Function

To define a function in C++ that can print any of the given arrays, we need a function that accepts a two-dimensional array and its dimensions as parameters. The function will then iterate through each element of the array and print it. Here is an example of such a function: ```cpp void print(int arr[][7], int rows) { for (int i = 0; i < rows; i++) { for (int j = 0; j < 7; j++) { std::cout << arr[i][j] << ' '; } std::cout << std::endl; } } ```

Call the Function for Each Array

Now with the function defined, we can call it to print each of the arrays: `times`, `speed`, `trees`, and `students`. The key here is to pass the array along with the number of rows it has. ```cpp print(times, 30); // Calls print to output the "times" array print(speed, 15); // Calls print to output the "speed" array print(trees, 100); // Calls print to output the "trees" array print(students, 50); // Calls print to output the "students" array ```

Key concepts

Two-Dimensional Arrays

When working with C++, a two-dimensional array is essentially an array of arrays. Imagine it as a table with rows and columns, similar to a spreadsheet. Each element in this table is accessed using two indices: one for the row and one for the column.
For instance, the declaration `int times[30][7];` tells the compiler to create a matrix of 30 rows and 7 columns. Here, `int` specifies that each element in this matrix is an integer.

• The first index `30` refers to the number of rows.
• The second index `7` refers to the number of columns.

This structure makes it suitable for storing tabular data, such as weekly timesheets (`times`), speeds on different days (`speed`), and so on. To access or modify an element at the third row and fifth column, for example, you use the notation `times[2][4]` (remember indices start at zero).
Two-dimensional arrays are crucial both for organizing data efficiently and facilitating complex computations.

Function Parameters

Function parameters in C++ allow you to pass pieces of data into a function. These parameters act as placeholders used to perform operations or calculations inside the function. When we define a function to work with two-dimensional arrays, we need to specify this as a parameter by including the array's dimension information.
In this exercise, the function `print` is defined with parameters as `(int arr[][7], int rows)`. Here are the key points:

• `int arr[][7]` refers to a parameter that is a two-dimensional array with a specified column size of 7. The row size can vary, which is why it's given explicitly as another parameter.
• `int rows` is an integer that specifies the number of rows the specific array contains.

These parameters ensure flexibility, allowing the same `print` function to handle arrays of different row sizes but identical column sizes. When you call the function, you simply pass the array and its row count as arguments.

Function Definition

In C++, defining a function means specifying a block of code that performs a specific task. The function definition includes the function’s name, return type, parameters, and the body containing the code.
For the `print` function in this exercise, here is how the definition is structured:

• The return type `void` suggests that this function does not return a value; its purpose is to perform a task - printing.
• The function name `print` clearly indicates what the function does.
• Parameters, `(int arr[][7], int rows)`, describe what inputs the function will accept. We’ve already discussed these in the last section.
• The function body is enclosed in curly braces `{ }`. Inside, the use of nested loops iterates through the array and outputs its elements, line-by-line.

After defining a function, it can be reused as many times as needed, just by calling it with the appropriate arguments. This encapsulates the print functionality in one reusable block, promoting code modularity.

Iteration

Iteration in programming refers to the repetition of a process. In C++, loops allow you to repeat a block of code until a specified condition is met.
For the `print` function, we employed iteration to traverse through each element of a two-dimensional array using nested loops. Here's how it works:

• An outer loop (`for (int i = 0; i < rows; i++)`) iterates over each row of the array.
• An inner loop (`for (int j = 0; j < 7; j++)`) iterates over each column of the current row.

These loops help access each element one by one and `std::cout` prints them, guaranteeing that every value in the array gets displayed. Each complete pass of the inner loop corresponds to one full row being printed, reinforcing the array's visual representation as a "table" of values.
Iteration ensures that operations scale with the data size, making it an essential tool for working with arrays.