Introduction to Arrays

Arrays Fundamentals

Introduction

An array of airplanes An array of bugs

An array of cards An array of characters

When you look at the stuff on each group above, you realize that the items on each picture share a lot
of characteristics, though each one still maintains specific features that set it apart from the others.
Everyone of the items on the first picture is an airplane; if you decide to be specific, then you may
state that the first airplane of the group is bright green while the second is black; the first and the
fourth airplanes don't have helices although all the others do. On the second picture (from left to
right), all of these items are bugs; they don't seem to look alike, but everyone of them is still a bug. If
you play cards sometimes (Solitaire or FreeCell), then you are familiar with the third picture.
Everyone of the items on the third picture is a card, same size, same white background, though they
display different card values, different character colors (and they would have different effects
depending on how your game is going). Whenever you are typing, you are aligning arrays of
characters, characters as those of the last picture. This shows that a word or a sentence is actually a
group or letters.

An array is a group of items that can be identified as similar because they are of the same nature.

Arrays come in two flavors: one dimensional and multi-dimensional arrays. Everyone of the pictures
above represents a single dimensional array.
Declaring an Array

Just like any variable you are already familiar with, an array has to be declared before being used. Yet
the difference this time is that you need to tell the compiler what kind of array you are defining, an
array of books? An array of students? An array of billiard balls? An arrays of clothes? This is because,
once more, the compiler wants to know how much space your array is going to occupy in the
computer memory. This is because when you declare an array of items, the compiler puts each one of
the items in an appropriate location.

Like any other variable, the syntax of declaring an array is:

DataType ArrayName[dimension\order]

The array is first identified by its kind, which could be a char, an int, a float, etc; followed by its name
that follows the C++ naming rules. The name is then followed by square brackets that specify the
dimension of the array or its size.

Here are examples of declaring arrays:

int age[12];
float grade[100];
double angle[360];

int Age[12]; declares a group or array of 12 values, each one being an integer.

float Grade[100]; declares an array of 100 floating-point values.

double Angle[360]; declares an array of double-precision numbers. There are 360 of these items in the
group.
Initializing an Array

Just like any variable can be initialized, an array also can be initialized. To accomplish this, for a one-
dimensional array, the syntax used is:

DataType ArrayName[dimension] = { element1, element2, , elementn};

Therefore, you can start with the data type to specify the kind of array you are declaring. This is
followed by the array name, and the square brackets. After specifying the dimension or not, and after
the closing square bracket, type the assignment operator. The elements, also called items, that compose
the array are included between an opening curly bracket '{' and a closing curly bracket '}'. Each item is
separate from the next by a comma operator. As a normal C/C++ initialization, you end it with a semi-
colon.

Here are examples of declaring an initializing arrays:

int number[12] = {18, 42, 25, 12, 34, 15, 63, 72, 92, 26, 26, 12};
double distance[5] = {44.14, 720.52, 96.08, 468.78, 6.28};

If you have decided to initialize the array while you are declaring it, you can omit the dimension.
Therefore, these arrays can be declared as follows:

int number[] = {18, 42, 25, 12, 34, 15, 63, 72, 92, 26, 26, 12};
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28};
Processing the Elements of an Array
After initializing an array, its elements are counted from left to right. Each element of the array, also
called a member of the array, has a specific and constant position. The position of an item is also called
its index. The first member of the array, the most left, has an index of 0. The second member of the
array has an index of 1. Since each array has a number of items which can be specified as n, the last
member of the array has an index of n-1

Based on this system of indexing, to locate a member of an array, use its index in the group. Imagine
you declare and initialize an array as follows:

double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28};

To locate the value of the 3rd member of the array, you would type distance[2]. In the same way, the 1st
member of the array can be located with distance[0].

Once you can locate a member of the array, you can display its value using cout. Here is an example:

#include <iostream>
using namespace std;

int main()
{
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "2nd member = " << distance[1] << endl;

cout << "5th member = " << distance[4] << endl;

return 0;
}

This would produce:

2nd member = 720.52

5th member = 6.28

Using this approach, each member of the array can have its value accessed. Here is an example:

#include <iostream>
using namespace std;

int main()
{
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Distance 1: " << distance[0] << endl;

cout << "Distance 2: " << distance[1] << endl;
cout << "Distance 3: " << distance[2] << endl;
cout << "Distance 4: " << distance[3] << endl;
cout << "Distance 5: " << distance[4] << endl;

return 0;
}

This would produce:

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
The Size of an Array

When declaring an array, we saw that you must specify the number of items that the array is made of.
Here is an example:

float averagePrice[45];

Depending on how you want to deal with your array, you may sometimes need to increase or decrease
its dimension. To do this, you would need to locate the declaration of the array and change its
dimension. If the program is long and the array is declared in some unusual place, this could take some
time. The alternative is to define a constant prior to declaring the array and use that constant to hold the
dimension of the array. Here is an example:

#include <iostream>
using namespace std;

int main()
{
const int numberOfItems = 5;
double distance[numberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Distance 1: " << distance[0] << endl;

cout << "Distance 2: " << distance[1] << endl;
cout << "Distance 3: " << distance[2] << endl;
cout << "Distance 4: " << distance[3] << endl;
cout << "Distance 5: " << distance[4] << endl;

return 0;
}

You can use such a constant in a for loop to scan the array and access each of its members. Here is an
example:

#include <iostream>
using namespace std;

int main()
{
const int numberOfItems = 5;
double distance[numberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Members of the array\n";

 for(int i = 0; i < numberOfItems; ++i)
cout << "Distance " << i + 1 << ": " << distance[i] << endl;

return 0;
}

In both cases, this would produce:

Members of the array

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
We knew the dimensions of the arrays we have used so far, because we could count the number of
members of the array. Imagine you declare a large array, possibly made of 100 or 300 members, you
wouldn't start counting the number of members. C/C++ provides the sizeof operator that can be used
to get the dimension of an array. The syntax you would use is:
sizeof(ArrayName) / sizeof(DataType)

Imagine you declare an array as follows:

int number[] = {18, 42, 25, 12, 34, 15, 63, 72, 92, 26, 26, 12, 127, 4762, 823,
236, 84, 5};

Instead of counting the number of members of this array (it makes me dizzy when I try), you can use
the sizeof operator as follows:

int NumberOfItemsOfTheArray = sizeof(Number)/sizeof(int);

One of the advantages of the sizeof operator used to get the number of members of the array is that it
can be used on a for loop to scan an array, either to locate the members or to look for a value in the
array. Here is an example of using this concept:
#include <iostream>
using namespace std;

int main()
{
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28};
// Using the sizeof operator to get the dimension of the array
int index = sizeof(distance) / sizeof(double);

cout << "Array members and their values\n";

// Using a for loop to scan an array
for(int i = 0; i < index; ++i)
cout << "Distance : " << i + 1 << distance[i] << endl;

return 0;
}

This would produce:

Array members and their values
Distance : 144.14
Distance : 2720.52
Distance : 396.08
Distance : 4468.78
Distance : 56.28
Filling Up an Array

When you declare an array without initializing it, we have mentioned that the compiler reserves an
amount of memory space for the members of the array. But that is only what the compiler does. Each
part of such reserved space is filled with garbage. Therefore, you must make sure that you know the
value held by a member of the array before making any attempt to process the value held by that
member of the array. Consider the following example:
#include <iostream>
using namespace std;

int main()
{
const int numberOfItems = 5;
double distance[numberOfItems];

cout << "Distance 1: " << distance[0] << endl;

cout << "Distance 2: " << distance[1] << endl;
cout << "Distance 3: " << distance[2] << endl;
cout << "Distance 4: " << distance[3] << endl;
cout << "Distance 5: " << distance[4] << endl;

return 0;
}

This would produce:

Distance 1: -9.25596e+061
Distance 2: -9.25596e+061
Distance 3: -9.25596e+061
Distance 4: -9.25596e+061
Distance 5: -9.25596e+061
As you can see, the members of the array in the beginning don't have any recognizable value. There
are two solutions to this problem. You can either initialize the array or request the values of the
members of the array from the user.
So far, when we used an array, we made sure to provide the exact number of members we needed for
the array. We also saw that we could declare and initialize an array without specifying its dimension.
The advantage of not specifying the dimension of the array is that we trust the compiler to find out the
number of elements of the array. If you decide to specify the dimension of the array and initialize it,
make sure you specify the elements less than or equal to the number you specified. Here is an
example:
#include <iostream>
using namespace std;

int main()
{
const int numberOfItems = 5;
 double distance[numberOfItems] = {44.14, 720.52, 96.08};

cout << "Distance 1: " << distance[0] << endl;

cout << "Distance 2: " << distance[1] << endl;
cout << "Distance 3: " << distance[2] << endl;
cout << "Distance 4: " << distance[3] << endl;
cout << "Distance 5: " << distance[4] << endl;

return 0;
}

This would produce:

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 0
Distance 5: 0
If you provide more members than the number of elements you specified, the compiler would provide
garbage values to the extra members. Here is an example:
#include <iostream>
using namespace std;

int main()
{
const int NumberOfItems = 5;
double distance[NumberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Distance 1: " << distance[0] << endl;

cout << "Distance 2: " << distance[1] << endl;
cout << "Distance 3: " << distance[2] << endl;
cout << "Distance 4: " << distance[3] << endl;
cout << "Distance 5: " << distance[4] << endl;
cout << "Distance 6: " << distance[5] << endl;
cout << "Distance 7: " << distance[6] << endl;
cout << "Distance 8: " << distance[7] << endl;

return 0;
}

This would produce:

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
Distance 6: 2.64214e-308
Distance 7: 2.12414e-314
Distance 8: 1.00532e-307

Depending on the compiler you are using, you would also receive a (strong) warning.
Streaming Array Members

We have already seen how to define an array, how to locate the elements of an array, and how to
display the values of these elements (displaying the value of a member of an array is one aspect of
streaming). The arrays we have seen so far had their dimensions and their elements defined by the
programmer. Many times you will have to get these elements from the user.

When you need to get an array from the user, first decide on what kind of array it is. Next, try to think
of the maximum number of members you will need for the array. When you define an array and
specify its dimension, the compiler will reserve the number of cells in memory that can accommodate
your array. Here is an example:

int Page[5];
Each member of the array can be located using its index, as we have seen so far. In the same way, you
can request the value of any member of the array using its index. In the following example, we declare
an array of 5 integers and then we request the values of the 1st and the 4th members:
#include <iostream>
using namespace std;

int main()
{
const int counter = 5;
int page[counter];

cout << "Enter the number of pages of your books\n";

cout << "Book 1: ";
cin >> page[0];
cout << "Book 4: ";
cin >> page[3];

cout << "\nSummary of books";

cout << "\nBook 1: " << page[0] << " pages";
cout << "\nBook 4: " << page[3] << " pages\n";

return 0;
}

Here is an example of running the program:

Enter the number of pages of your books

Book 1: 842
Book 4: 1204

Summary of books
Book 1: 842 pages
Book 4: 1204 pages
Operations on Arrays

Each member of an array is a pseudo-variable and can be processed as such. This means that you can
add the values of two members of the array(Number[2]+Number[0]), you can subtract the value of
one of the members from another member(member[1]-Number[4]). In the same way, you can perform
multiplication, division, or remainder operations on members of an array.
One of the regular operations performed on an array consists of adding the values of the members to
produce a sum. Here is an example:
#include <iostream>
using namespace std;

int main()
{
// We know that we need a constant number of elements
const int max = 10;
int number[max];

// We will calculate their sum

int sum = 0;

cout << "Please type 10 integers.\n";

for( int i = 0; i < max; i++ )

{
cout << "Number " << i + 1 << ": ";
cin >> number[i];
sum += number[i];
}

cout << "\n\nThe sum of these numbers is " << Sum << "\n\n";

return 0;
}

This would produce:

Please type 10 integers.

Number 1: 120
Number 2: 42
Number 3: 75
Number 4: 38
Number 5: 904
Number 6: 6
Number 7: 26
Number 8: 55
Number 9: 92
Number 10: 20

The sum of these numbers is 1378

Another type of operation regularly performed on an array consists of looking for a value held by one
of its members. For example, you can try to know if one of the members holds a particular value you
are looking for. Here is an example:
#include <iostream>
using namespace std;
int main()
{
// Declare the members of the array
int numbers[] = {8, 25, 36, 44, 52, 60, 75, 89};
int find;
int i, m = 8;

cout << "Enter a number to search: ";

cin >> find;

for (i = 0; (i < m) && (Numbers[i] != Find); ++i)

continue;

// Find whether the number typed is a member of the array

if (i == m)
cout << find << " is not in the list" << endl;
else
cout << find << " is the " << i + 1
<< "th element in the list" << endl;
return 0;
}

This would produce:

Enter a number to search: 44

44 is the 4th element in the list
One of the most regular operations performed consists of comparing the values of different members
to get the lowest value of the members. Here is an example:
// Example of finding the minimum member of an array
#include <iostream>
using namespace std;

int main()
{
// The members of the array
int numbers[] = {8, 25, 36, 44, 52, 60, 75, 89};
int minimum = numbers[0];
int a = 8;

// Compare the members

for (int i = 1; i < a; ++i) {
if (numbers[i] < minimum)
minimum = numbers[i];
}

// Announce the result

cout << "The lowest member value of the array is "
<< minimum << "." << endl;

return 0;
}

This would produce:

The lowest member value of the array is 8.

You can use this same approach to get the maximum value of the members of an array. Here is an
example:

// Example of finding the maximum member of an array

#include <iostream>
using namespace std;

int main()
{
// The members of the array
int numbers[] = {8, 25, 36, 44, 52, 60, 75, 89};
int maximum = numbers[0];
int a = 8;

// Compare the members

for (int i = 1; i < a; ++i) {
if (numbers[i] > maximum)
maximum = numbers[i];
}

// Announce the result

cout << "The highest member value of the array is "
<< maximum << "." << endl;

return 0;
}
Arrays and Functions

An array can be passed to a function as argument. An array can also be returned by a function. To
declare and define that a function takes an array as argument, declare the function as you would do for
any regular function and, in its parentheses, specify that the argument is an array. Here is an example:
#include <iostream>
using namespace std;

void DisplayTheArray(double member[5]);

int main()
{
const int numberOfItems = 5;
double distance[numberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

return 0;
}

void DisplayTheArray(double member[5])

{
for(int i = 0; i < 5; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}
You don't have to specify the dimension of the array. This means that you can leave the square
brackets empty:

#include <iostream>
using namespace std;

void DisplayTheArray(double member[]);

int main()
{
const int NumberOfItems = 5;
double distance[NumberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

return 0;
}

void DisplayTheArray(double member[])

{
for(int i = 0; i < 5; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}

We have already seen that when you declare an array, the compiler reserves an amount of memory
space for the members of the array. To locate these members, the compiler aligns them in a
consecutive manner. For example (hypothetically), if a member is located at 1804 Lockwood drive,
the next member would be located at 1805 Lockwood Drive. This allows the compiler not only to
know where the members of a particular array are stored, but also in what block (like the block houses
of a city) the array starts. This means that, when you ask the compiler to locate a member of an array,
the compiler starts where the array starts and moves on subsequently until it finds the member you
specified. If the compiler reaches the end of the block but doesn't find the member you specified, it
stops, instead of looking for it all over the computer memory.

Based on this, when you call a function that has an array as argument, the compiler only needs the
name of the array to process it. Therefore, the above function can be called as follows:
#include <iostream>
using namespace std;

void DisplayTheArray(double member[])

{
for(int i = 0; i < 5; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}

int main()
{
const int numberOfItems = 5;
double distance[numberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Members of the array";

DisplayTheArray(distance);
 return 0;
}

This would produce:

Members of the array

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
The good scenario we have used so far is that we know the number of members of our array and we
can directly use it in the function that is passed the argument. Imagine that we want the function to
know how many members the array has and we want to let the function know while we are calling it,
after all, in some circumstances, we will not always know how many members we want the function
to process. This should easily be done as follows:
#include <iostream>
using namespace std;

void DisplayTheArray(double member[])

{
for(int i = 0; i < 5; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}

int main()
{
const int NumberOfItems = 5;
double distance[NumberOfItems] = {44.14, 720.52, 96.08, 468.78, 6.28};

cout << "Members of the array";

DisplayTheArray(distance[3]);

return 0;
}
Unfortunately, this program will not compile. Remember, we saw that the compiler wants only the
name of the array, because the name by itself represents the whole array. distance[3] is a specific value
of a member of the array, it is not a group of values. In other words, distance[3] is the same as 468.78.
It is as if we want to pass 468.78 as the value to be treated and not as a subsequent group of values,
because that is what an array is. Therefore, the compiler complains that you are passing a value after
you have specifically stated that the argument was a group of values and not a single value.
When you declare and define a function that takes an array as argument, if you plan to process the
array, for example, if you want the calling function to control the number of elements to be processed,
you should/must pass another argument that will allow the function to know how many members of
the array would be considered. Such a function can be declared as follows:
#include <iostream>
using namespace std;

void DisplayTheArray(double mbr[], int count);

int main()
{
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04,
364.55, 6234.12};

// Processing 5 members of the array

cout << "Members of the array";
DisplayTheArray(distance, 5);

// Processing all members of the array

int sizeOfArray = sizeof(Distance)/sizeof(double);

cout << "\nMembers of the array";

DisplayTheArray(distance, sizeOfArray);

return 0;
}

void DisplayTheArray(double member[], int counter)

{
for(int i = 0; i < counter; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}

This would produce:

Members of the array

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28

Members of the array

Distance 1: 44.14
Distance 2: 720.52
Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
Distance 6: 68.04
Distance 7: 364.55
Distance 8: 6234.12
Using this same concept of passing accompanying arguments, you can control how the called function
would process the array. For example, you can specify the starting and end point to the processing of
the array. Here is an example:
#include <iostream>
using namespace std;

// This function process an array but starts and ends at specific positions
void DisplayTheArray(double mbr[], int Start, int End);

int main()
{
 double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04,
364.55, 6234.12};

// Scan the array from the 3rd to the 7th member

cout << "Members of the array";
DisplayTheArray(distance, 2, 6);

return 0;
}

void DisplayTheArray(double member[], int start, int ending)

{
for(int i = start; i < ending; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}

This would produce:

Members of the array

Distance 3: 96.08
Distance 4: 468.78
Distance 5: 6.28
Distance 6: 68.04
When declaring a function that takes an array argument, as we learned with other arguments, you don't
have to provide a name to the argument. Simply typing the square brackets on the right side of the
data type in the parentheses is enough. The name of the argument is only necessary when defining the
function. Therefore, the above function can be declared as follows:
#include <iostream>
using namespace std;

// This function process an array but starts and ends at specific positions
void DisplayTheArray(double[], int, int);

int main()
{
double distance[] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04,
364.55, 6234.12};

// Scan the array from the 3rd to the 7th member

cout << "Members of the array";
DisplayTheArray(distance, 2, 6);

return 0;
}

void DisplayTheArray(double member[], int Start, int Ending)

{
for(int i = Start; i < Ending; ++i)
cout << "\nDistance " << i + 1 << ": " << member[i];
cout << endl;
}
Two-Dimensional Arrays
Introduction
A 2-dimensional array is an array of arrays. In other words, it is an array where each member of the
array is also an array. Consider the following table
Country\Data Map Flag Area (sq km) Population

United States 9,629,091 272,639,608

Cameroon 475,440 15,456,092

Guatemala 108,890 12,335,580

Italy 301,230 56,735,130

Oman 212,460 2,446,645

Declaring and Initializing a 2-Dimensional Array

This two-dimensional array is made of rows and columns . Each column represents one category of
data that everyone of the rows shares with the other rows. As different as each map looks, it still
remains a map; each country on the table is known for its map, its flag, its area, and its population,
though remaining different from the others. To see another two-dimensional array, look at a calendar
that displays a month with its week days.

Like the above table, a 2-dimensional array is made rows and columns. To declare it, use double pair
of a opening and closing square brackets. Here is an example:

int numberOfStudentsPerClass[12][50];

This declaration creates a first group of 12 elements; it could be an array of 12 classes. Each element
of the array contains 50 elements. In other words, each of the 12 members of the group is an array of
50 items. Simply stated, this declarations creates 12 classes and each class contains 50 students.

Before using the members of an arrays, you should/must make sure you know the values that its
members hold. As done with one-dimensional arrays, there are two ways you can solve this problem:
you can initialize the array or you can get its values by another means.

You can initialize an array the same way you would proceed the a one-dimensional array: simply
provide a list of values in the curly brackets. A multidimensional array is represented as an algebraic
matrix as MxN. This means that the array is made of M rows and N columns. For example, a 5x8
matrix is made of 5 rows and 8 columns. To know the actual number of members of a
multidimensional array, you can multiply the number of rows by the number of columns. Therefore a
2x16 array contains 2*16=32 members.
Based on this, when initializing a 2-dimensional array, make sure you provide a number of values that
is less than or equal to the number of members.

Here is an example:

double distance[2][4] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04, 364.55,

6234.12};
To locate a member of the array, this time, each must be identified by its double index. The first
member is indexed at [0][0]. The second is at [0][1]. For a 2x4 array as this one, the 5th member is at
[1][0]. You can use this same approach to display the values of the members of the array. Here is an
example:
#include <iostream>
using namespace std;

int main()
{
// A 2-Dimensional array
double distance[2][4] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04,
364.55, 6234.12};

// Scan the array from the 3rd to the 7th member

cout << "Members of the array";
cout << "\nDistance [0][0]" << ": " << distance[0][0];
cout << "\nDistance [0][1]" << ": " << distance[0][1];
cout << "\nDistance [0][2]" << ": " << distance[0][2];
cout << "\nDistance [0][3]" << ": " << distance[0][3];
cout << "\nDistance [1][0]" << ": " << distance[1][0];
cout << "\nDistance [1][1]" << ": " << distance[1][1];
cout << "\nDistance [1][2]" << ": " << distance[1][2];
cout << "\nDistance [1][3]" << ": " << distance[1][3];

cout << endl;

return 0;
}

This would produce:

Members of the array

Distance [0][0]: 44.14
Distance [0][1]: 720.52
Distance [0][2]: 96.08
Distance [0][3]: 468.78
Distance [1][0]: 6.28
Distance [1][1]: 68.04
Distance [1][2]: 364.55
Distance [1][3]: 6234.12
To make the above array a little easier to read when initializing it, you can type the values of each row
on its own line. For example, the above array can be initialized as follows:
double distance[2][4] = { 44.14, 720.52, 96.08, 468.78,
6.28, 68.04, 364.55, 6234.12 };
C++ also allows you to include each row in its own pair of curly brackets. You must separate each row
from the next with a comma. Once again, this makes code easier to read. Here is an example:

double distance[2][4] = { { 44.14, 720.52, 96.08, 468.78 },

{ 6.28, 68.04, 364.55, 6234.12 }
};
Processing a 2-Dimensional Array
To scan a 2-dimensional array, you should know how many columns the array contains. You can use
two for loops to navigate the array. Here is an example:
#include <iostream>
using namespace std;

int main()
{
// A 2-Dimensional array
double distance[][4] = {
{ 44.14, 720.52, 96.08, 468.78 },
{ 6.28, 68.04, 364.55, 6234.12 }
};

// Scan the array from the 3rd to the 7th member

cout << "Members of the array";
for(int i = 0; i < 2; ++i)
for(int j = 0; j < 4; ++j)
cout << "\nDistance [" << i << "][" << j << "]: " <<
distance[i][j];

cout << endl;

return 0;
}

This would produce the same result as previously.

Multidimensional Arrays

Multi-dimensional arrays are characterized by more than one line of representation.

Here are examples of a three-dimensional arrays