Multi-Dimensional Arrays

So far, when creating an array, we showed a list of values. Here is an example:

Here is an example of how we have learned to create an array of primitive values:

using namespace System;

int main()
{
    array<double> ^ SingleFamilyValues = { 550550, 1215080, 625550, 850450 };

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[1]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[2]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

In the same way, you can create as many arrays as you want in your program. Here are examples:

using namespace System;

int main()
{
    array<double> ^ SingleFamilyValues = { 550550, 1215080, 625550, 850450 };
    array<double> ^ TownhouseValues = { 483045, 912834, 328555, 600425 };
	
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[1]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[2]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilyValues[3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Townhouses");
    Console::WriteLine(L"Market Value: {0:C}", TownhouseValues[0]);
    Console::WriteLine(L"Market Value: {0:C}", TownhouseValues[1]);
    Console::WriteLine(L"Market Value: {0:C}", TownhouseValues[2]);
    Console::WriteLine(L"Market Value: {0:C}", TownhouseValues[3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Single Families
Market Value: $550,500.00
Market Value: $1,215,000.00
Market Value: $625,000.00
Market Value: $850,000.00
=---------------------------=
Townhouses
Market Value: $483,045.00
Market Value: $912,834.00
Market Value: $328,555.00
Market Value: $600,425.00
============================

Press any key to continue . . .

When we introduced arrays, we saw that, when creating and initializing an array, you could also use the gcnew operator before the curly brackets:

array<double> ^ SingleFamilyValues =
	gcnew array<double> { 550550, 1215080, 625550, 850450 };

When an array contains a unique list of items, such an array is referred to as single-dimensional. To indicate that the array is single dimensional, you can use the following formula:

array<DataType, 1> ^ VariableName = gcnew array<DataType>(Dimension);

You can also use the following formula:

array<DataType, 1> ^ VariableName = gcnew array<DataType, 1>(Dimension);

1. To start a new program, launch Microsoft Visual C++ 2005
2. On the main menu, click File -> New -> Project... (or File -> New Project...)
3. On the left side, make sure that Visual C++ is selected. In the Templates list, click CLR Empty Project
4. In the Name box, replace the string with RealEstate13 and click OK
5. To create a source file, on the main menu, click Project -> Add New Item...
6. In the Templates list, click Source File (.cpp)
7. In the New box, type Exercise and click Add
8. In the empty file, type:
    

   using namespace System; int main() { array<__wchar_t, 1> ^ HouseTypes = gcnew array<__wchar_t>(4) { L'S', L'C', L'S', L'T' }; array<int, 1> ^ Bedrooms = gcnew array<int>(4) { 5, 2, 3, 3 }; array<Byte, 1> ^ Stories = gcnew array<Byte>(4) { 3, 1, 3, 2 }; array<double, 1> ^ Bathrooms = gcnew array<double>(4) { 3.5, 1, 2.5, 1.5 }; array<bool, 1> ^ HasGarage = gcnew array<bool>(4) { true, true, false, false }; array<double, 1> ^ Values = gcnew array<double>(4) { 550500, 115000, 425000, 350000 }; Console::WriteLine(L"======================================="); Console::WriteLine(L"Altair Realtors"); Console::WriteLine(L"---------------------------------------"); Console::WriteLine(L"Real Estate Properties Inventory"); Console::WriteLine(L"---------------------------------------"); Console::WriteLine(L"Type Beds Baths Lvl Garage? Value"); Console::WriteLine(L"=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="); for(int house = 0; house < 4; house++) { Console::WriteLine(L"{0,3}{1,5}{2,6}{3,4}{4,8}{5,10}", HouseTypes[house], Bedrooms[house], Bathrooms[house], Stories[house], HasGarage[house], Values[house]); Console::WriteLine(L"---------------------------------------"); } Console::WriteLine(L"=======================================\n"); return 0; }

9. To execute the application, on the main menu, click Debug -> Start Without Debugging
    

   ======================================= Altair Realtors --------------------------------------- Real Estate Properties Inventory --------------------------------------- Type Beds Baths Lvl Garage? Value =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= S 5 3.5 3 True 550500 --------------------------------------- C 2 1 1 True 115000 --------------------------------------- S 3 2.5 3 False 425000 --------------------------------------- T 3 1.5 2 False 350000 --------------------------------------- ======================================= Press any key to continue . . .

10. Close the DOS window

Instead of creating an array that contains a single list of items, you can create an array that contains two lists. It can be illustrated as follows:

Such a list is referred to as two-dimensional. Notice that all values are of the same type. In a program, you can also create a two-dimensional array. If you want to initialize the array when creating it, the formula to use is:

array<DataType, 2> ^ VariableName = { { Members-1 }, { Members-2 } };

The array keyword is required. The value 2 is called the rank of the array. The rank of an array specifies the number of sub-lists that the array contains. In this case, 2 indicates that the array is two-dimenionsal. Make sure you give a name to the variable. As always, the array elements are created inside of curly brackets. Because the main array is in fact made of two sub-lists, each sub-list must be created inside its own curly brackets. Here is an example of creating and initializing a two-dimensional array:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = { { 550550, 1215080, 625550, 850450 },
                                        { 483045,  912834, 328555, 600425 } };

    return 0;
}

After initializing the array, you may be interested in accessing its values. The formula to access an element is:

VariableName[x,y]

After specifying the name of the variable, follow it with curly brackets. The first sub-list has an index of 0 and the second sub-list has an index of 1. Inside of a sub-list, the first element has an index of 0, the second has an index of 1, and so on. Therefore, to access an element, inside the square brackets, type the index of the sub-list, followed by the index of the sub-list, followed by a comma, and followed by the index of the element. Here are examples:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = { { 550550, 1215080, 625550, 850450 },
                                        { 483045,  912834, 328555, 600425 } };
	
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Townhouses");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

Earlier, we saw that, when creating and initializing an array, you could also apply the gcnew operator before the curly brackets. This is also possible for a two-dimensional array. Here is an example:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>
    {
        { 550550, 1215080, 625550, 850450 },
        { 483045,  912834, 328555, 600425 }
    };
	
    . . .

    return 0;
}

If you want, you can first declare the array, then initialize it. To declare a two-dimensional array, the formula to follow is:

array<DataType, 2> ^ VariableName = gcnew array<DataType, 2>(2, Dimension);

The DataType factor is a placeholder for the type of values that the array will hold. The VariableName is the name of the array. The Dimension factor specifies the number of elements that each sub-list will contain.

After declaring the variable, you can initialize the array. To do this, access each element by specifying its sub-list's index and its own index, then assign it the desired value. Here are examples:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>(2, 4);
	
    MarketValues[0,0] = 550550;
    MarketValues[0,1] = 1215080;
    MarketValues[0,2] = 625550;
    MarketValues[0,3] = 850450;

    MarketValues[1,0] = 483045;
    MarketValues[1,1] = 912834;
    MarketValues[1,2] = 328555;
    MarketValues[1,3] = 600425;
	
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Townhouses");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

You can also use this technique to initialize the array when creating it. Here is an example:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>(2, 4)
    {
        { 550550, 1215080, 625550, 850450 },
        { 483045, 912834, 328555, 600425 }
    };
	
    . . .

    return 0;
}

Instead of just one or two sub-lists, you can create an array that contains as many sub-lists we you want. An array made of three sub-lists can be illustrated as follows:

In the same way, an array can be made of 5, 8, 12 or as many sub-lists as you need. This is referred to as a multi-dimensional array. There are two main ways you can create a multi-dimensional array. For example, you can create an array that has a rank of two but that includes as many sub-lists as  you want. If you want to initialize the array when creating it, you can use the following formula to create it:

array<DataType, 2> ^ VariableName = gcnew array<DataType, 2>(Rank, Dimension)
{
    { Members-1 },
    { Members-2 },
    { Members-n } };

The Rank factor specifies the number of sub-lists that the array will contain. The Dimension factor represents the number of elements that each sub-list will contain. For example, to create an array that contains 3 sub-lists and each sub-list will contain 4 elements, you would declare the array as follows:

array<double, 2> ^ MarketValues = gcnew array<double, 2>(3, 4)

Here is an example of such an array:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>(3, 4)
    {
        { 550550, 1215080, 625550, 850450 },
        { 483045,  912834, 328555, 600425 },
        { 224550, 85655, 147576, 92885 }
    };

    return 0;
}

To access an element, after using the name of the array, inside the square brackets, type the index of the sub-list, followed by a comma, followed by the index of the particular element you want to access inside the sub-list. Here are examples:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>(3, 4)
    {
        { 550550, 1215080, 625550, 850450 },
        { 483045,  912834, 328555, 600425 },
        { 224550, 85655, 147576, 92885 }
    };
	
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Townhouses");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Single Families
Market Value: $550,550.00
Market Value: $1,215,080.00
Market Value: $625,550.00
Market Value: $850,450.00
=---------------------------=
Townhouses
Market Value: $483,045.00
Market Value: $912,834.00
Market Value: $328,555.00
Market Value: $600,425.00
=---------------------------=
Condominiums
Market Value: $224,550.00
Market Value: $85,655.00
Market Value: $147,576.00
Market Value: $92,885.00
============================

Press any key to continue . . .

If you want, you can first declare the array, then initialize it. Here is an example:

using namespace System;

int main()
{
    array<double, 2> ^ MarketValues = gcnew array<double, 2>(3, 4);

    MarketValues[0,0] = 550550;
    MarketValues[0,1] = 1215080;
    MarketValues[0,2] = 625550;
    MarketValues[0,3] = 850450;
    MarketValues[1,0] = 483045;
    MarketValues[1,1] = 912834;
    MarketValues[1,2] = 328555;
    MarketValues[1,3] = 600425;
    MarketValues[2,0] = 224550;
    MarketValues[2,1] = 85655;
    MarketValues[2,2] = 147576;
    MarketValues[2,3] = 92885;
	
    . . .

    return 0;
}

Notice that this simple technique allows you to access the members of the multi-dimensional array using the techniques of a two-dimensional array.

Another technique, more explicit but may appear a little dark to comprehend, to create a multi-dimensional array consists of using the rank in the <> operator to specify the number of pages of the array. The formula to use can be shown as follows:

array<DataType, Lists> ^ Variable = gcnew array<DataType, Lists>(Lists, Sub-Lists, Elements)

To illustrate this formula, try to think that you want to create a few lists of items. From our formula, the Lists factor specifies the number of lists that you will need or use. The Sub-Lists factor specifies the number of sub-lists that each Lists will contain. The Elements factor specifies the number of values that each sub-list will contain. Here is an example of declaring such an array:

array<double, 3> ^ MarketValues = gcnew array<double, 3>(3, 2, 4)

This declaration indicates that the array will have 3 lists. Each list will have 2 sub-lists and each sub-list will have 4 elements. After declaring the variable, you can initialize the array. To initialize the array when creating it, create the square brackets for each list. Inside the square brackets of a list, create the square brackets for the sub-list(s). Inside the square brackets of the sub-list, specify the value of each element, separating them with commas.

To access an element, after using the name of the array, type the normal square brackets of an array. Inside the square brackets, type the index of a list, followed by a comma, followed by the index of a sub-list, followed by a comma, followed by the index of the particular element you want to access inside the sub-list. Here are examples:

using namespace System;

int main()
{
    array<double, 3> ^ MarketValues = gcnew array<double, 3>(3, 2, 4)
    {
        // First List
        {
            // First Sub List
            {
                2250550, // 1st List - 1st Sub List - 1st Element
                1215080, // 1st List - 1st Sub List - 2nd Element
                1625550, // 1st List - 1st Sub List - 3rd Element
                850450   // 1st List - 1st Sub List - 4th Element
            },
            // Second Sub-List
            {
                558750, // 1st List - 2nd Sub List - 1st Element
                503150, // 1st List - 2nd Sub List - 2nd Element
		362650, // 1st List - 2nd Sub List - 3rd Element
		435755  // 1st List - 2nd Sub List - 4th Element
            }
        },
        // Second List
        {
            // First Sub-List
            {
                483045, // 2nd List - 1st Sub List - 1st Element
	        622440, // 2nd List - 1st Sub List - 2nd Element
                808445, // 2nd List - 1st Sub List - 3rd Element
		600425  // 2nd List - 1st Sub List - 4th Element
	    },
	    // Second Sub-List
	    {
		283045, // 2nd List - 2nd Sub List - 1st Element
                412834, // 2nd List - 2nd Sub List - 2nd Element
		328555, // 2nd List - 2nd Sub List - 3rd Element
		300425  // 2nd List - 2nd Sub List - 4th Element
	    }
	},
	// Third List
	{
	    // First Sub-List
	    {
		 624550,  // 3rd List - 1st Sub List - 1st Element
		 85655,   // 3rd List - 1st Sub List - 2nd Element
		 1250755, // 3rd List - 1st Sub List - 3rd Element
		 904685   // 3rd List - 1st Sub List - 4th Element
	    },
	    // Second Sub-List
	    {
		 324550, // 3rd List - 2nd Sub List - 1st Element
		 15655,  // 3rd List - 2nd Sub List - 2nd Element
		 147576, // 3rd List - 2nd Sub List - 3rd Element
		 92885   // 3rd List - 2nd Sub List - 4th Element
	    }
	}
    };
	
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Luxurious Estates");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Classy Properties");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0,1,3]);
    Console::WriteLine(L"=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
    Console::WriteLine(L"Townhouses");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"High Standing");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Common Envy");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1,1,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums");
    Console::WriteLine(L"=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
    Console::WriteLine(L"Deluxe Condo");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,0,3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Affordable Living");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2,1,3]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Single Families
=---------------------------=
Luxurious Estates
Market Value: $2,250,550.00
Market Value: $1,215,080.00
Market Value: $1,625,550.00
Market Value: $850,450.00
=---------------------------=
Classy Properties
Market Value: $558,750.00
Market Value: $503,150.00
Market Value: $362,650.00
Market Value: $435,755.00
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Townhouses
=---------------------------=
High Standing
Market Value: $483,045.00
Market Value: $622,440.00
Market Value: $808,445.00
Market Value: $600,425.00
=---------------------------=
Common Envy
Market Value: $283,045.00
Market Value: $412,834.00
Market Value: $328,555.00
Market Value: $300,425.00
=---------------------------=
Condominiums
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Deluxe Condo
Market Value: $624,550.00
Market Value: $85,655.00
Market Value: $1,250,755.00
Market Value: $904,685.00
=---------------------------=
Affordable Living
Market Value: $324,550.00
Market Value: $15,655.00
Market Value: $147,576.00
Market Value: $92,885.00
============================

Press any key to continue . . .

In the same way, you can create an array or many lists, with each list containing sub-lists and each sub-list containing other sub-lists, etc. You may be limited only by your computer's memory.

So far, to declare a managed array, we entered its data type inside the <> operator. In reality, as we will learn in the next lesson, the section inside the <> operator is a placeholder for any valid data type. Because an array is primarily treated as its own (user-defined) data type, it can be used inside the <> operator. This means that you can use this operator to create an array inside of an array. An array created inside of another array is referred to as a jagged array.

To create a jagged array, inside the <> operator, use the array keyword, its own <> operator, a data type and the ^ operator to create the new array. Here is an example:

using namespace System;

int main()
{
    array<array<double> ^> ^ SingleFamilies = gcnew array<array<double> ^>(4);

    return 0;
}

This declaration indicates that you are creating an array named SingleFamilies and that array contains 4 elements. Each element of that array is itself an array of double-precision values. This declaration doesn't indicate how many elements each jagged array will contain. This means that each element of the SingleFamilies array can contain 1, 4, 100 or more elements. You will provide this information when you initialize each element of the SingleFamilies array.

As mentioned above, each element of the main array is itself an array. Therefore, before using it, you must initialize it. Because each element is declared as a handle, you must initialize it using the gcnew operator. To do this, access an element using its 0-based index and allocate memory for it using the gcnew operator. Also, because you are allocating memory for an array, you must specify its dimension. If an element is a one-dimensional array, specify its dimension as 1. This would be done as follows:

using namespace System;

int main()
{
    array<array<double> ^> ^ SingleFamilies = gcnew array<array<double> ^>(2);
 
    SingleFamilies[0] = gcnew array<double>(1);
    SingleFamilies[1] = gcnew array<double>(1);

    return 0;
}

The above code only allocates memory for each element. It initializes its element(s) to 0 if the array is numeric-based.

To access an element of a jagged array, you need at least two pairs of square brackets on the right side of the name of the variable. Inside the first square brackets, enter the index of the element from the main array. Inside the second square brackets, enter the index of the particular element you are trying to access. Here are examples:

using namespace System;

int main()
{
    array<array<double> ^> ^ SingleFamilies = gcnew array<array<double> ^>(2);
 
    SingleFamilies[0] = gcnew array<double>(1);
    SingleFamilies[0][0] = 550550;
    SingleFamilies[1] = gcnew array<double>(1);
    SingleFamilies[1][0] =1215080;

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Single Families");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[0][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[1][0]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Single Families
Market Value: $550,550.00
Market Value: $1,215,080.00
============================

Press any key to continue . . .

Remember that each element of the main is its own but undefined array. This means that you can initialize each any way you want. This also means that one element of the main array can have a different number of elements from the others. As mentioned already, it is when allocating memory for an element of the jagged array that you decide what it would look like. Consider the following example:

using namespace System;

int main()
{
    array<array<double> ^> ^ SingleFamilies = gcnew array<array<double> ^>(4);
 
    SingleFamilies[0] = gcnew array<double>(1);
    SingleFamilies[0][0] = 550550;
    SingleFamilies[1] = gcnew array<double>(1);
    SingleFamilies[1][0] = 1215080;
    SingleFamilies[2] = gcnew array<double>(3);
    SingleFamilies[2][0] = 722040;
    SingleFamilies[2][1] = 1450668;
    SingleFamilies[2][2] = 917297;
    SingleFamilies[3] = gcnew array<double>(2);
    SingleFamilies[3][0] = 325885;
    SingleFamilies[3][1] = 450735;

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Silver Spring");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[0][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[1][0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Potomac");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][1]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][2]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums in DC");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[3][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[3][1]);
    Console::WriteLine(L"============================\n");

    return 0;
}

In the above example, the first and the second elements of the main array each is an array that contains only one element. The third element of the main array contains 3 elements and the fourth contains 2 elements.

The above code would produce:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Silver Spring
Market Value: $550,550.00
Market Value: $1,215,080.00
=---------------------------=
Potomac
Market Value: $722,040.00
Market Value: $1,450,668.00
Market Value: $917,297.00
=---------------------------=
Condominiums in DC
Market Value: $325,885.00
Market Value: $450,735.00
============================

Press any key to continue . . .

As done for regularly managed arrays, you can create a function that returns a jagged array. When creating the function, specify its return type as a jagged array using the same formula of the array as we saw above. The function can be declared as follows:

array<array<double> ^> ^ GetSingleFamilies();

At the time the function is declared, it only knows that it would return a jagged array. The function doesn't know what the individual internal arrays would look like. This means the array returned could be simple or multi-dimensional. It is when you define the function that you will specify the structures of the internal arrays of the jagged one.

When implementing the function, you can locally declare a jagged array of the type that must be returned, then define or initialize the array. Before exiting the function, make sure it returns the type of array it was declared to return. Here is an example:

using namespace System;

array<array<double> ^> ^ GetSingleFamilies();

int main()
{
    array<array<double> ^> ^ SingleFamilies = GetSingleFamilies();

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Silver Spring");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[0][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[1][0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Potomac");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][1]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[2][2]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums in DC");
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[3][0]);
    Console::WriteLine(L"Market Value: {0:C}", SingleFamilies[3][1]);
    Console::WriteLine(L"============================\n");

    return 0;
}

array<array<double> ^> ^ GetSingleFamilies()
{
    array<array<double> ^> ^ houses = gcnew array<array<double> ^>(4);
	
    houses[0] = gcnew array<double>(1);
    houses[0][0] = 550550;
    houses[1] = gcnew array<double>(1);
    houses[1][0] = 1215080;
    houses[2] = gcnew array<double>(3);
    houses[2][0] = 722040;
    houses[2][1] = 1450668;
    houses[2][2] = 917297;
    houses[3] = gcnew array<double>(2);
    houses[3][0] = 325885;
    houses[3][1] = 450735;

    return houses;
}

The actual arrays inside the jagged array are defined only in the function.

You can pass a jagged array to a function as argument. To do this, in the parentheses of the function, declare the jagged as you normally would. If you are only declaring the function, you don't have to name the argument. Here is an example:

void ShowSingleFamilies(array<array<double> ^> ^);

In the body of the function, use the array as you see fit. For example, you can retrieve the values of its elements. Here is an example of a function that takes a jagged array as argument:

using namespace System;

array<array<double> ^> ^ GetSingleFamilies();
void ShowSingleFamilies(array<array<double> ^> ^);

int main()
{
    array<array<double> ^> ^ SingleFamilies = GetSingleFamilies();

    ShowSingleFamilies(SingleFamilies);
    return 0;
}

array<array<double> ^> ^ GetSingleFamilies()
{
    array<array<double> ^> ^ houses = gcnew array<array<double> ^>(4);
	
    houses[0] = gcnew array<double>(1);
    houses[0][0] = 550550;
    houses[1] = gcnew array<double>(1);
    houses[1][0] = 1215080;
    houses[2] = gcnew array<double>(3);
    houses[2][0] = 722040;
    houses[2][1] = 1450668;
    houses[2][2] = 917297;
    houses[3] = gcnew array<double>(2);
    houses[3][0] = 325885;
    houses[3][1] = 450735;

    return houses;
}

void ShowSingleFamilies(array<array<double> ^> ^ homes)
{
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Silver Spring");
    Console::WriteLine(L"Market Value: {0:C}", homes[0][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[1][0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Potomac");
    Console::WriteLine(L"Market Value: {0:C}", homes[2][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[2][1]);
    Console::WriteLine(L"Market Value: {0:C}", homes[2][2]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums in DC");
    Console::WriteLine(L"Market Value: {0:C}", homes[3][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[3][1]);
    Console::WriteLine(L"============================\n");
}

Once again, it is important to know that, when the function that takes the jagged array is called, the caller doesn't specify, doesn't know about, and doesn't impose on, the individual arrays that make up the jagged array. Consider the following program:

using namespace System;

array<array<double> ^> ^ GetSingleFamilies();
void ShowSingleFamilies(array<array<double> ^> ^);

int main()
{
    array<array<double> ^> ^ SingleFamilies = GetSingleFamilies();

    ShowSingleFamilies(SingleFamilies);
    return 0;
}

array<array<double> ^> ^ GetSingleFamilies()
{
    array<array<double> ^> ^ houses = gcnew array<array<double> ^>(4);
	
    houses[0] = gcnew array<double>(4);
    houses[0][0] = 550550;
    houses[0][1] = 937450;
    houses[0][2] = 1143855;
    houses[0][3] = 758060;
    houses[1] = gcnew array<double>(2);
    houses[1][0] = 1215080;
    houses[1][1] = 885560;
    houses[2] = gcnew array<double>(6);
    houses[2][0] = 722040;
    houses[2][1] = 1450668;
    houses[2][2] = 917297;
    houses[2][3] = 442255;
    houses[2][4] = 665775;
    houses[2][5] = 825675;
    houses[3] = gcnew array<double>(1);
    houses[3][0] = 325885;

    return houses;
}

void ShowSingleFamilies(array<array<double> ^> ^ homes)
{
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Silver Spring");
    Console::WriteLine(L"Market Value: {0:C}", homes[0][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[0][1]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Potomac");
    Console::WriteLine(L"Market Value: {0:C}", homes[1][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[1][1]);
    Console::WriteLine(L"Market Value: {0:C}", homes[1][2]);
    Console::WriteLine(L"Market Value: {0:C}", homes[1][3]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums in DC");
    Console::WriteLine(L"Market Value: {0:C}", homes[2][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[2][1]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Condominiums in Alexandria");
    Console::WriteLine(L"Market Value: {0:C}", homes[3][0]);
    Console::WriteLine(L"Market Value: {0:C}", homes[3][1]);
    Console::WriteLine(L"Market Value: {0:C}", homes[3][2]);
    Console::WriteLine(L"============================\n");
}

This program compiles fine and this is how it works. When the GetSingleFamilies() function is declared, the compiler doesn't know what internal arrays the function will return. When this function is defined, the programmer decides that it will return a jagged array made of 4 internal arrays, 2 internal arrays, 6 internal arrays, and 1 internal array. When the ShowSingleFamilies() function is declared, the compiler doesn't know what the internal arrays the argument holds. When this function is defined, the programmer decides to access 2 elements from the first internal array (regardless of how many elements that first array contains), 4 elements from the second internal array (again, the programmer doesn't know how many elements the second array contains), 2 elements from the 3rd internal array (without knowing how many elements are in that array), and 3 elements from the 4th internal array. The new programmer could continue accessing subsequent arrays because there is no information that specifies the number of internal arrays in the jagged array nor the number of elements that each array contains. And this information is not know to the compiler either.

When the program runs, when the compiler tries to access either an internal array that doesn't exist in the argument, or an element that is not present in an internal array, it would throw an IndexOuOfRangeException exception internal array. Again, the above program would compile fine but it tries the execute all the functions, it would hang somewhere and produce the following:

Altair Realtors
=---------------------------=
Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Silver Spring
Market Value: $550,550.00
Market Value: $937,450.00
=---------------------------=
Potomac
Market Value: $1,215,080.00
Market Value: $885,560.00

Unhandled Exception: System.IndexOutOfRangeException: 
	Index was outside the bounds of the array.
   at ShowSingleFamilies(Double[][] homes) in 
	e:\programs\arrays1\arrays1\exercise.cpp:line 52
   at main() in e:\programs\arrays1\arrays1\exercise.cpp:line 10
Press any key to continue . . .

The solution is that, when calling a function that takes a jagged array, you must know about the internal arrays (how many there are) and their elements (how many elements each internal array contains).

A jagged array can be created as two-dimensional. to create it, you can start with a normal single-dimensional array. Inside the <> operator, create a two-dimensional array by specifying its data type and its rank as 2. Here is an example:

array<array<double, 2> ^> ^ MarketValues = gcnew array<array<double, 2> ^>(3);

After allocating memory for the main array, you should do the same (allocate memory) for each element of the jagged array. When doing this, you must use the same formula you created the jagged array with inside the <> operator. Then, when allocating memory for each element of the jagged array, you can specify its ranks and how many elements it would have. This can be done as follows:

using namespace System;

int main()
{
    array<array<double, 2> ^> ^ MarketValues = gcnew array<array<double, 2> ^>(3);

    // The first element of the main array is an array of
    // 2 lists and each list contains 3 elements
    MarketValues[0] = gcnew array<double, 2>(2, 3);

    // The second element of the main array is an array of
    // 4 lists and each list contains 1 element
    MarketValues[1] = gcnew array<double, 2>(4, 1);

    // The third element of the main array is an array of
    // 1 list and that list contains 5 elements
    MarketValues[2] = gcnew array<double, 2>(1, 5);

    return 0;
}

To access an element of a jagged array, you use at least two pairs of square brackets. In the fist pair, specify the rank of the current element from the main array:

using namespace System;

int main()
{
    array<array<double, 2> ^> ^ MarketValues = gcnew array<array<double, 2> ^>(3);

    // The first element of the main array is an array of
    // 2 lists and each list contains 3 elements
    MarketValues[0] = gcnew array<double, 2>(2, 3);
    MarketValues[0][]

    // The second element of the main array is an array of
    // 4 lists and each list contains 1 element
    MarketValues[1] = gcnew array<double, 2>(4, 1);
    MarketValues[1][]

    return 0;
}

In the second square brackets, you apply the formula we used to access an element of a multi-dimensional array. Then you do what you want, such as assigning the desired value or retrieving the value of the element. Here are examples:

using namespace System;

int main()
{
    array<array<double, 2> ^> ^ MarketValues = gcnew array<array<double, 2> ^>(3);

    // The first element of the main array is an array of
    // 2 lists and each list contains 3 elements
    MarketValues[0] = gcnew array<double, 2>(2, 3);
    MarketValues[0][0,0] = 1150760;
    MarketValues[0][0,1] = 665265;
    MarketValues[0][0,2] = 888500;
    MarketValues[0][1,0] = 450550;
    MarketValues[0][1,1] = 565265;
    MarketValues[0][1,2] = 475640;

    // The second element of the main array is an array of
    // 4 lists and each list contains 1 element
    MarketValues[1] = gcnew array<double, 2>(4, 1);
    MarketValues[1][0,0] = 250550;
    MarketValues[1][1,0] = 465265;
    MarketValues[1][2,0] = 1215080;
    MarketValues[1][3,0] = 388500;

    // The third element of the main array is an array of
    // 1 list and that list contains 5 elements
    MarketValues[2] = gcnew array<double, 2>(1, 5);
    MarketValues[2][0,0] = 725660;
    MarketValues[2][0,1] = 635605;
    MarketValues[2][0,2] = 285555;
    MarketValues[2][0,3] = 447650;
    MarketValues[2][0,4] = 277800;

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Available Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Alexandria, VA");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,2]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Washington, DC");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][2,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][3,0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Chevy Chase, MD");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,3]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,4]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Available Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Alexandria, VA
Market Value: $1,150,760.00
Market Value: $665,265.00
Market Value: $888,500.00
Market Value: $450,550.00
Market Value: $565,265.00
Market Value: $475,640.00
=---------------------------=
Washington, DC
Market Value: $250,550.00
Market Value: $465,265.00
Market Value: $1,215,080.00
Market Value: $388,500.00
=---------------------------=
Chevy Chase, MD
Market Value: $725,660.00
Market Value: $635,605.00
Market Value: $285,555.00
Market Value: $447,650.00
Market Value: $277,800.00
============================

Press any key to continue . . .

The above array was two-dimensional. A jagged array can also be created as multi-dimensional. From the formula of the two-dimensional array, you simply change the rank from 2 to the desired rank. Here is an example:

using namespace System;

int main()
{
    array<array<double, 3> ^> ^ MarketValues = gcnew array<array<double, 3> ^>(3);

    return 0;
}

To allocate memory for each jagged array, you must first use the same rank you specified when declaring the variable. Then, you must specify the rank and dimension that each particular jagged array will use. Here are examples:

using namespace System;

int main()
{
    array<array<double, 3> ^> ^ MarketValues = gcnew array<array<double, 3> ^>(3);

    // The first element of the main array is an array of
    // 2 lists. Each list will contain 3 sub-lists
    // Each sub-list will contain 1 element
    MarketValues[0] = gcnew array<double, 3>(2, 3, 1);

    // The second element of the main array is an array of
    // 4 lists. Each list will contain 1 sub-list
    // The sub-list will contain 2 elements
    MarketValues[1] = gcnew array<double, 3>(4, 1, 2);

    // The third element of the main array is an array of
    // 1 list. The list will contain 2 sub-lists
    // Each sub-list will contain 5 elements
    MarketValues[2] = gcnew array<double, 3>(1, 2, 5);

    return 0;
}

To access an element of the jagged array, you use two pairs of square brackets. In the fist pair, specify the rank of an element from the main array. In the second square brackets, enter the index of the first dimension of the jagged array, followed by a comma, followed by the appropriate index of the second dimension, followed by a comma, and followed by an index corresponding to the last dimension. You can then you do what you want, including assigning the desired value or retrieving the value of the element. Here are examples:

using namespace System;

int main()
{
    array<array<double, 3> ^> ^ MarketValues = gcnew array<array<double, 3> ^>(3);

    // The first element of the main array is an array of
    // 2 lists. Each list contains 3 sub-lists
    // Each sub-list contains 1 element
    MarketValues[0] = gcnew array<double, 3>(2, 3, 1);
    MarketValues[0][0,0,0] = 1150760;
    MarketValues[0][0,1,0] = 665265;
    MarketValues[0][0,2,0] = 888500;
    MarketValues[0][1,0,0] = 450550;
    MarketValues[0][1,1,0] = 565265;
    MarketValues[0][1,2,0] = 475640;

    // The second element of the main array is an array of
    // 4 lists. Each list contains 1 sub-list
    // The sub-list contains 2 elements
    MarketValues[1] = gcnew array<double, 3>(4, 1, 2);
    MarketValues[1][0,0,0] = 250550;
    MarketValues[1][0,0,1] = 465265;
    MarketValues[1][1,0,0] = 1215080;
    MarketValues[1][1,0,1] = 388500;
    MarketValues[1][2,0,0] = 255550;
    MarketValues[1][2,0,1] = 464235;
    MarketValues[1][3,0,0] = 2365770;
    MarketValues[1][3,0,1] = 730458;

    // The third element of the main array is an array of
    // 1 list. The list contains 2 sub-lists
    // Each sub-list contains 5 elements
    MarketValues[2] = gcnew array<double, 3>(1, 2, 5);
    MarketValues[2][0,0,0] = 725660;
    MarketValues[2][0,1,1] = 635605;
    MarketValues[2][0,0,2] = 285555;
    MarketValues[2][0,1,3] = 447650;
    MarketValues[2][0,0,4] = 277800;
    MarketValues[2][0,1,0] = 7345665;
    MarketValues[2][0,0,1] = 5555565;
    MarketValues[2][0,1,2] = 2225055;
    MarketValues[2][0,0,3] = 645825;
    MarketValues[2][0,1,4] = 707650;

    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Available Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Virginia");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,2,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,2,0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Washington, DC");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][0,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][1,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][1,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][2,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][2,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][3,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][3,0,1]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Maryland");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,3]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,4]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,3]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,4]);
    Console::WriteLine(L"============================\n");

    return 0;
}

This would produce:

Altair Realtors
=---------------------------=
Available Properties Listing
=--=--=--=--=--=--=-=-=-=-=-=
Virginia
Market Value: $1,150,760.00
Market Value: $665,265.00
Market Value: $888,500.00
Market Value: $450,550.00
Market Value: $565,265.00
Market Value: $475,640.00
=---------------------------=
Washington, DC
Market Value: $250,550.00
Market Value: $465,265.00
Market Value: $1,215,080.00
Market Value: $388,500.00
Market Value: $255,550.00
Market Value: $464,235.00
Market Value: $2,365,770.00
Market Value: $730,458.00
=---------------------------=
Maryland
Market Value: $725,660.00
Market Value: $635,605.00
Market Value: $285,555.00
Market Value: $447,650.00
Market Value: $277,800.00
Market Value: $7,345,665.00
Market Value: $5,555,565.00
Market Value: $2,225,055.00
Market Value: $645,825.00
Market Value: $707,650.00
============================

Press any key to continue . . .

As described for single-dimensional jagged arrays, you can create a function that returns a multi-dimensional jagged array. You can also create a function that takes a multi-dimensional jagged array as argument. Here are examples:

using namespace System;

array<array<double, 3> ^> ^ GetMarketValues()
{
    array<array<double, 3> ^> ^ MarketValues = gcnew array<array<double, 3> ^>(3);

    // The first element of the main array is an array of
    // 2 lists. Each list contains 3 sub-lists
    // Each sub-list contains 1 element
    MarketValues[0] = gcnew array<double, 3>(2, 3, 1);
    MarketValues[0][0,0,0] = 1150760;
    MarketValues[0][0,1,0] = 665265;
    MarketValues[0][0,2,0] = 888500;
    MarketValues[0][1,0,0] = 450550;
    MarketValues[0][1,1,0] = 565265;
    MarketValues[0][1,2,0] = 475640;

    // The second element of the main array is an array of
    // 4 lists. Each list contains 1 sub-list
    // The sub-list contains 2 elements
    MarketValues[1] = gcnew array<double, 3>(4, 1, 2);
    MarketValues[1][0,0,0] = 250550;
    MarketValues[1][0,0,1] = 465265;
    MarketValues[1][1,0,0] = 1215080;
    MarketValues[1][1,0,1] = 388500;
    MarketValues[1][2,0,0] = 255550;
    MarketValues[1][2,0,1] = 464235;
    MarketValues[1][3,0,0] = 2365770;
    MarketValues[1][3,0,1] = 730458;

    // The third element of the main array is an array of
    // 1 list. The list contains 2 sub-lists
    // Each sub-list contains 5 elements
    MarketValues[2] = gcnew array<double, 3>(1, 2, 5);
    MarketValues[2][0,0,0] = 725660;
    MarketValues[2][0,1,1] = 635605;
    MarketValues[2][0,0,2] = 285555;
    MarketValues[2][0,1,3] = 447650;
    MarketValues[2][0,0,4] = 277800;
    MarketValues[2][0,1,0] = 7345665;
    MarketValues[2][0,0,1] = 5555565;
    MarketValues[2][0,1,2] = 2225055;
    MarketValues[2][0,0,3] = 645825;
    MarketValues[2][0,1,4] = 707650;

    return MarketValues;
}

void ShowMarketValues(array<array<double, 3> ^> ^ MarketValues)
{
    Console::WriteLine(L"Altair Realtors");
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Available Properties Listing");
    Console::WriteLine(L"=--=--=--=--=--=--=-=-=-=-=-=");
    Console::WriteLine(L"Virginia");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][0,2,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[0][1,2,0]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Washington, DC");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][0,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][1,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][1,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][2,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][2,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][3,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[1][3,0,1]);
    Console::WriteLine(L"=---------------------------=");
    Console::WriteLine(L"Maryland");
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,3]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,4]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,0]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,1]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,2]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,0,3]);
    Console::WriteLine(L"Market Value: {0:C}", MarketValues[2][0,1,4]);
    Console::WriteLine(L"============================\n");
}

int main()
{
    array<array<double, 3> ^> ^ MarketValues = GetMarketValues();
    ShowMarketValues(MarketValues);
	
    return 0;
}