### Program Using an Array

```//DISPLAY 7.1 Program Using an Array
//Reads in 5 scores and shows how much each
//score differs from the highest score.
#include <iostream>

int main( )
{
using namespace std;
int i, score, max;

cout << "Enter 5 scores:\n";
cin >> score;
max = score;
for (i = 1; i < 5; i++)
{
cin >> score[i];
if (score[i] > max)
max = score[i];
//max is the largest of the values score,..., score[i].
}

cout << "The highest score is " << max << endl
<< "The scores and their\n"
<< "differences from the highest are:\n";
for (i = 0; i < 5; i++)
cout << score[i] << " off by "
<< (max - score[i]) << endl;

return 0;
}
```

### Indexed Variable as an Argument

```//DISPLAY 7.3 Indexed Variable as an Argument
//Illustrates the use of an indexed variable as an argument.
//Adds 5 to each employee's allowed number of vacation days.
#include <iostream>

const int NUMBER_OF_EMPLOYEES = 3;

//Returns old_days plus 5.

int main( )
{
using namespace std;
int vacation[NUMBER_OF_EMPLOYEES], number;

cout << "Enter allowed vacation days for employees 1"
<< " through " << NUMBER_OF_EMPLOYEES << ":\n";
for (number = 1; number <= NUMBER_OF_EMPLOYEES; number++)
cin >> vacation[number-1];

for (number = 0; number < NUMBER_OF_EMPLOYEES; number++)

cout << "The revised number of vacation days are:\n";
for (number = 1; number <= NUMBER_OF_EMPLOYEES; number++)
cout << "Employee number " << number
<< " vacation days = " << vacation[number-1] << endl;

return 0;
}

{
return (old_days + 5);
}
```

### Function with an Array Parameter

```//DISPLAY 7.4 Function with an Array Parameter
//Function Declaration
void fill_up(int a[], int size);

//Precondition: size is the declared size of the array a.
//The user will type in size integers.
//Postcondition: The array a is filled with size integers
//from the keyboard.

//Function Definition
//Uses iostream:
void fill_up(int a[], int size)
{
using namespace std;
cout << "Enter " << size << " numbers:\n";
for (int i = 0; i < size; i++)
cin >> a[i];
size--;
cout << "The last array index used is " << size << endl;
}

```

### Outline of the Graph Program

```//DISPLAY 7.5 Outline of the Graph Program
//Reads data and displays a bar graph showing productivity for each plant.
#include <iostream>
const int NUMBER_OF_PLANTS = 4;

void input_data(int a[], int last_plant_number);
//Precondition: last_plant_number is the declared size of the array a.
//Postcondition: For plant_number = 1 through last_plant_number:
//a[plant_number-1] equals the total production for plant number plant_number.

void scale(int a[], int size);
//Precondition: a through a[size-1] each has a nonnegative value.
//Postcondition: a[i] has been changed to the number of 1000s (rounded to
//an integer) that were originally in a[i], for all i such that 0 <= i <= size-1.

void graph(const int asterisk_count[], int last_plant_number);
//Precondition: asterisk_count through asterisk_count[last_plant_number-1]
//have nonnegative values.
//Postcondition: A bar graph has been displayed saying that plant
//number N has produced asterisk_count[N-1] 1000s of units, for each N such that
//1 <= N <= last_plant_number

int main( )
{
using namespace std;
int production[NUMBER_OF_PLANTS];

cout << "This program displays a graph showing\n"
<< "production for each plant in the company.\n";

input_data(production, NUMBER_OF_PLANTS);
scale(production, NUMBER_OF_PLANTS);
graph(production, NUMBER_OF_PLANTS);

return 0;
}
```

### Test of Function input_data

```//DISPLAY 7.6 Test of Function input_data
//Tests the function input_data.
#include <iostream>
const int NUMBER_OF_PLANTS = 4;

void input_data(int a[], int last_plant_number);
//Precondition: last_plant_number is the declared size of the array a.
//Postcondition: For plant_number = 1 through last_plant_number:
//a[plant_number-1] equals the total production for plant number plant_number.

void get_total(int& sum);
//Reads nonnegative integers from the keyboard and
//places their total in sum.

int main( )
{
using namespace std;
int production[NUMBER_OF_PLANTS];
char ans;

do
{
input_data(production, NUMBER_OF_PLANTS);
cout << endl
<< "Total production for each"
<< " of plants 1 through 4:\n";
for (int number = 1; number <= NUMBER_OF_PLANTS; number++)
cout << production[number - 1] << " ";

cout << endl
<< "Test Again?(Type y or n and Return): ";
cin >> ans;
}while ( (ans != 'N') && (ans != 'n') );

cout << endl;

return 0;
}
//Uses iostream:
void input_data(int a[], int last_plant_number)
{
using namespace std;
for (int plant_number = 1;
plant_number <= last_plant_number; plant_number++)
{
cout << endl
<< "Enter production data for plant number "
<< plant_number << endl;
get_total(a[plant_number - 1]);
}
}

//Uses iostream:
void get_total(int& sum)
{
using namespace std;
cout << "Enter number of units produced by each department.\n"
<< "Append a negative number to the end of the list.\n";

sum = 0;
int next;
cin >> next;
while (next >= 0)
{
sum = sum + next;
cin >> next;
}

cout << "Total = " << sum << endl;
}

```

### The Function scale

```//DISPLAY 7.7 The Function scale
//Demonstration program for the function scale.
#include <iostream>
#include <cmath>

void scale(int a[], int size);
//Precondition: a through a[size-1] each has a nonnegative value.
//Postcondition: a[i] has been changed to the number of 1000s (rounded to
//an integer) that were originally in a[i], for all i such that 0 <= i <= size -1.

int round(double number);
//Precondition: number >= 0.
//Returns number rounded to the nearest integer.

int main( )
{
using namespace std;
int some_array, index;

cout << "Enter 4 numbers to scale: ";
for (index = 0; index < 4; index++)
cin >> some_array[index];

scale(some_array, 4);

cout << "Values scaled to the number of 1000s are: ";
for (index = 0; index < 4; index++)
cout << some_array[index] << " ";
cout << endl;

return 0;
}

void scale(int a[], int size)
{
for (int index = 0; index < size; index++)
a[index] = round(a[index]/1000.0);
}

//Uses cmath:
int round(double number)
{
using namespace std;
return static_cast<int>(floor(number + 0.5));
}

```

### Production Graph Program

```//DISPLAY 7.8 Production Graph Program
//Reads data and displays a bar graph showing productivity for each plant.
#include <iostream>
#include <cmath>
using namespace std;

const int NUMBER_OF_PLANTS = 4;

void input_data(int a[], int last_plant_number);
//Precondition: last_plant_number is the declared size of the array a.
//Postcondition: For plant_number = 1 through last_plant_number:
//a[plant_number-1] equals the total production for plant number plant_number.

void scale(int a[], int size);
//Precondition: a through a[size-1] each has a nonnegative value.
//Postcondition: a[i] has been changed to the number of 1000s (rounded to
//an integer) that were originally in a[i], for all i such that 0 <= i <= size -1.
void graph(const int asterisk_count[], int last_plant_number);
//Precondition: asterisk_count through asterisk_count[last_plant_number-1]
//have nonnegative values.
//Postcondition: A bar graph has been displayed saying that plant
//number N has produced asterisk_count[N-1] 1000s of units, for each N such that
//1 <= N <= last_plant_number

void get_total(int& sum);
//Reads nonnegative integers from the keyboard and
//places their total in sum.

int Round(double number);
//Precondition: number >= 0.
//Returns number rounded to the nearest integer.

void print_asterisks(int n);
//Prints n asterisks to the screen.

int main( )
{

int production[NUMBER_OF_PLANTS];

cout << "This program displays a graph showing\n"
<< "production for each plant in the company.\n";

input_data(production, NUMBER_OF_PLANTS);
scale(production, NUMBER_OF_PLANTS);
graph(production, NUMBER_OF_PLANTS);
return 0;
}

//Uses iostream:
void input_data(int a[], int last_plant_number)
{
using namespace std;
for (int plant_number = 1;
plant_number <= last_plant_number; plant_number++)
{
cout << endl
<< "Enter production data for plant number "
<< plant_number << endl;
get_total(a[plant_number - 1]);
}
}

//Uses iostream:
void get_total(int& sum)
{
using namespace std;
cout << "Enter number of units produced by each department.\n"
<< "Append a negative number to the end of the list.\n";

sum = 0;
int next;
cin >> next;
while (next >= 0)
{
sum = sum + next;
cin >> next;
}

cout << "Total = " << sum << endl;
}

void scale(int a[], int size)
{
for (int index = 0; index < size; index++)
a[index] = Round(a[index]/1000.0);
}

//Uses cmath:
int Round(double number)
{
using namespace std;
return static_cast<int>(floor(number + 0.5));
}
void graph(const int asterisk_count[], int last_plant_number)
{
using namespace std;
cout << "\nUnits produced in thousands of units:\n";
for (int plant_number = 1;
plant_number <= last_plant_number; plant_number++)
{
cout << "Plant #" << plant_number << " ";
print_asterisks(asterisk_count[plant_number - 1]);
cout << endl;
}
}

//Uses iostream:
void print_asterisks(int n)
{
using namespace std;
for (int count = 1; count <= n; count++)
cout << "*";
}

```

### Partially Filled Array

```//DISPLAY 7.9 Partially Filled Array
//Shows the difference between each of a list of golf scores and their average.
#include <iostream>
const int MAX_NUMBER_SCORES = 10;

void fill_array(int a[], int size, int& number_used);
//Precondition: size is the declared size of the array a.
//Postcondition: number_used is the number of values stored in a.
//a through a[number_used-1] have been filled with
//nonnegative integers read from the keyboard.

double compute_average(const int a[], int number_used);
//Precondition: a through a[number_used-1] have values; number_used > 0.
//Returns the average of numbers a through a[number_used-1].

void show_difference(const int a[], int number_used);
//Precondition: The first number_used indexed variables of a have values.
//Postcondition: Gives screen output showing how much each of the first
//number_used elements of a differs from their average.

int main( )
{
using namespace std;
int score[MAX_NUMBER_SCORES], number_used;

cout << "This program reads golf scores and shows\n"
<< "how much each differs from the average.\n";

cout << "Enter golf scores:\n";
fill_array(score, MAX_NUMBER_SCORES, number_used);
show_difference(score, number_used);
return 0;
}
//Uses iostream:
void fill_array(int a[], int size, int& number_used)
{
using namespace std;
cout << "Enter up to " << size << " nonnegative whole numbers.\n"
<< "Mark the end of the list with a negative number.\n";
int next, index = 0;
cin >> next;
while ((next >= 0) && (index < size))
{
a[index] = next;
index++;
cin >> next;
}

number_used = index;
}

double compute_average(const int a[], int number_used)
{
double total = 0;
for (int index = 0; index < number_used; index++)
total = total + a[index];
if (number_used > 0)
{
return (total/number_used);
}
else
{
using namespace std;
cout << "ERROR: number of elements is 0 in compute_average.\n"
<< "compute_average returns 0.\n";
return 0;
}
}

void show_difference(const int a[], int number_used)
{
using namespace std;
double average = compute_average(a, number_used);
cout << "Average of the " << number_used
<< " scores = " << average << endl
<< "The scores are:\n";
for (int index = 0; index < number_used; index++)
cout << a[index] << " differs from average by "
<< (a[index] - average) << endl;
}

```

### Searching an Array

```//DISPLAY 7.10 Searching an Array
//Searches a partially filled array of nonnegative integers.
#include <iostream>
using namespace std;
const int DECLARED_SIZE = 20;

void fill_array(int a[], int size, int& number_used);
//Precondition: size is the declared size of the array a.
//Postcondition: number_used is the number of values stored in a.
//a through a[number_used-1] have been filled with
//nonnegative integers read from the keyboard.

int search(const int a[], int number_used, int target);
//Precondition: number_used is <= the declared size of a.
//Also, a through a[number_used -1] have values.
//Returns the first index such that a[index] == target,
//provided there is such an index; otherwise, returns -1.

int main( )
{

int arr[DECLARED_SIZE], list_size, target;

fill_array(arr, DECLARED_SIZE, list_size);

char ans;
int result;
do
{
cout << "Enter a number to search for: ";
cin >> target;

result = search(arr, list_size, target);
if (result == -1)
cout << target << " is not on the list.\n";
else
cout << target << " is stored in array position "
<< result << endl
<< "(Remember: The first position is 0.)\n";

cout << "Search again?(y/n followed by Return): ";
cin >> ans;
}while ((ans != 'n') && (ans != 'N'));

cout << "End of program.\n";
return 0;
}
//Uses iostream:
void fill_array(int a[], int size, int& number_used)
{

cout << "Enter up to " << size << " nonnegative whole numbers.\n"
<< "Mark the end of the list with a negative number.\n";
int next, index = 0;
cin >> next;
while ((next >= 0) && (index < size))
{
a[index] = next;
index++;
cin >> next;
}

number_used = index;
}

int search(const int a[], int number_used, int target)
{

int index = 0;
bool found = false;
while ((!found) && (index < number_used))
if (target == a[index])
found = true;
else
index++;

if (found)
return index;
else
return -1;
}

/*
int search(const int a[], int number_used, int target)
{

int index = 0;

while(index < number_used)
{
if (target == a[index])
return index;

index++;
}

return -1;
}
*/

```

### Sorting an Array

```//DISPLAY 7.12 Sorting an Array
//Tests the procedure sort.
#include <iostream>
using namespace std;

void fill_array(int a[], int size, int& number_used);
//Precondition: size is the declared size of the array a.
//Postcondition: number_used is the number of values stored in a.
//a through a[number_used - 1] have been filled with
//nonnegative integers read from the keyboard.

void sort(int a[], int number_used);
//Precondition: number_used <= declared size of the array a.
//The array elements a through a[number_used - 1] have values.
//Postcondition: The values of a through a[number_used - 1] have
//been rearranged so that a <= a <= ... <= a[number_used - 1].

void swap_values(int& v1, int& v2);
//Interchanges the values of v1 and v2.

int index_of_smallest(const int a[], int start_index, int number_used);
//Precondition: 0 <= start_index < number_used. Referenced array elements have
//values.
//Returns the index i such that a[i] is the smallest of the values
//a[start_index], a[start_index + 1], ..., a[number_used - 1].

int main( )
{
using namespace std;
cout << "This program sorts numbers from lowest to highest.\n";

int sample_array, number_used;
fill_array(sample_array, 10, number_used);
sort(sample_array, number_used);

cout << "In sorted order the numbers are:\n";
for (int index = 0; index < number_used; index++)
cout << sample_array[index] << " ";
cout << endl;
return 0;
}

//Uses iostream:
void fill_array(int a[], int size, int& number_used)
{

cout << "Enter up to " << size << " nonnegative whole numbers.\n"
<< "Mark the end of the list with a negative number.\n";
int next, index = 0;
cin >> next;
while ((next >= 0) && (index < size))
{
a[index] = next;
index++;
cin >> next;
}

number_used = index;
}

void swap_values(int& v1, int& v2)
{
int temp;
temp = v1;
v1 = v2;
v2 = temp;
}

void sort(int a[], int number_used)
{
int   index_of_next_smallest;
for (int index = 0; index < number_used - 1; index++)
{//Place the correct value in a[index]:

index_of_next_smallest = index_of_smallest(a, index, number_used);

swap_values(a[index], a[index_of_next_smallest]);
//a <= a <=...<= a[index] are the smallest of the original array
//elements. The rest of the elements are in the remaining positions.
}
}

int index_of_smallest(const int a[], int start_index, int number_used)
{
int min = a[start_index];
int   index_of_min = start_index;
for (int index = start_index + 1; index < number_used; index++)
if (a[index] < min)
{
min = a[index];
index_of_min = index;
//min is the smallest of a[start_index] through a[index]
}

return index_of_min;
}

```

This topic: KenyonCpp > WebHome > CodeArray1
Topic revision: r3 - 2015-10-01 - JimSkon

Copyright © 2008-2020 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback