The Array Class

An array is a technique of storing similar information of different items in a common variable of one name. Based on this, consider the following list:

This type of list can be created using a String-based array. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *lstItemsNames[] = { S"Women Coat", S"Men Jacket", S"Teen Jeans",
		                        S"Women Bathing Suit", S"Children Playground Dress" };
}

The above type of list is referred to as a single-dimensional. To provide more information about items, you can associate a second or even a third list to the first as follows:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *itemsNumbers[] = { S"624376", S"274952", S"497852", S"749752", S"394085" };
	 String *lstItemsNames[]    = { S"Women Coat", S"Men Jacket", S"Teen Jeans",
		                             S"Women Bathing Suit", S"Children Playground Dress" };
	 double itemsPrices[]      = { 225.55, 175.75, 24.50, 34.65, 75.05 };
}

To support C++ arrays, the .NET Framework provides the Array class, which is defined in the System namespace. Based on this, you can formally use the Array class to create an array. To support the creation of an array, the Array class is equipped with the CreateInstance() method that comes in various versions. To create a one-dimensional array, you can use the following version:

public: static Array* CreateInstance(Type* elementType, int length);

The first argument is used to specify the type of array you want to create. Since it is declared as Type, you can use the __typeof operator to cast your type.

The second argument specifies the number of items of the list. Like a normal C++ array, the items in an Array-based list use a zero-based index, meaning that the first item has an index of 0, the second has an index of 1, and so on. Using the Array class, you can create a list of the above item names as follows:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 Array *lstItemsNames = Array::CreateInstance(__typeof(String), length);
}

Creating various lists that would be later connected can be confusing and even overwhelming, as mentioned earlier.

Practical Learning: Creating a List Class

The Length of an Array

In C++, when creating an array that you are not initializing, you must provide the number of items that the list will contain. This number is passed inside the variable's square brackets as a constant integer. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	String *lstItemsNames[] = __gc new String*[5];
}

If you create a list using the Array::CreateInstance() method using the above version, you must pass a constant integer as the second argument. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 Array *lstItemsNames = Array::CreateInstance(__typeof(String), 5);
}

If the array exists already, to find out the number of items it contains, you can access its Length property. Alternatively, you can call the Array::GetLength() method. Its syntax is:

public: int GetLength(int dimension);

For a single dimensional array as those declared above, you must pass the argument as 0. This method returns a 32-bit integer that represents the number of items in the array.

Practical Learning: Starting a List-Based Application

Operations on Arrays

Two-Dimensional Array Creation

The type of array we declared earlier is referred to as a single-dimensional. To provide more information about items, you can associate a second or even a third list to the first as follows:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *lstItemsNames[]    = { S"Women Coat", S"Men Jacket", S"Teen Jeans",
		                                 S"Women Bathing Suit", S"Children Playground Dress" };
}

You can create a two-dimensional array by entering a comma in the square brackets of the array variable and two constant integers separated by a comma when allocating memory for the array. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *lstItemsNames[,] = __gc new String*[2,3];				 
}

If you want to use the Array::CreateInstance() method to create a two-dimensional array, you can call the following version:

public: static Array* CreateInstance(Type* elementType, int length1, int length2);

A two-dimensional array is also called an array of two arrays. If using the classic technique of declaring an array, the first number specified when allocating memory, in the above example it would be 2, represents the number of arrays. This is the same number of the second argument of the current CreateInstance() method. For a two-dimensional array, this number is always 2. The second number of the classic declaration and the third argument of the current CreateInstance() method specify the number of items that each list would contain. In the above declaration, the number 3 means that each array will be made of three items.

Based on this, here is an example of declaring a two-dimensional array using the CreateInstance() method:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 Array *lstItemsNumbers = Array::CreateInstance(__typeof(String), 2, 3);
	 String *storeItems[,] = __gc new String*[2,3];
}

To know the total number of items that an array contains, you can access its Length property. To know the number of items that a particular list contains, call the Array::GetLength() method and pass the number corresponding to the array. To know the number of items in the first list, pass the argument as 0. To know the number of items in the second list, pass the argument as 1.

Besides the single or two-dimensional, you can create multidimensional arrays by specifying the number of commas in the square brackets and specifying the numbers in the right square brackets. If you want to use the Array::CreateInstance() method to create a multidimensional array, you can call the following version:

public: static Array* CreateInstance(Type* elementType, int lengths __gc[]);

With this version of the method, the second argument specifies the number of arrays that the variable will hold

If you want to find out the total number of items that an array contains, access its Length property. To get the number of items that a particular list contains, you can call the Array::GetLength() method and pass the number corresponding to the array.

To know the number of lists that an array variable contains, you can access its Rank property.

In C++, there are two main techniques you can use to initialize an array. You can create its list of items when declaring the array. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 double itemsPrices[] = { 225.55, 175.75, 24.50, 34.65, 75.05 };
}

Another technique C++ provides is to first declare the array, then initialize each of its members. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *storeItems[] = new String*[4];
				 
	 storeItems[0] = S"Women Coat";
	 storeItems[1] = S"Women Bathing Suit";
	 storeItems[2] = S"Quilted Down Jacket";
	 storeItems[3] = S"Men Jacket";
}

Here is an example for a two-dimensional array:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *storeItems[,] = __gc new String*[2,3];
				 
	 storeItems[0,0] = S"Women Coat";
	 storeItems[0,1] = S"Women Bathing Suit";
	 storeItems[0,2] = S"Quilted Down Jacket";
	 storeItems[1,0] = S"Men Jacket";
	 storeItems[1,1] = S"Children Playground Dress";
	 storeItems[1,2] = "Boys Trousers";
}

The Array class also provides its own support for adding items to an array. This is done using the Array::SetValue() that is overloaded with various versions. To add a new item to a single-dimensional array, you can use the following syntax:

public: void SetValue(Object* value, int index);

The first argument is the value to add to the list. The second argument is the index of the item to be added. The first item has index 1; the second item has index 2, and so on. Here is an example:

System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 String *storeItems[] = new String*[4];
				 
	 storeItems->SetValue(S"Women Coat", 0);
	 storeItems->SetValue(S"Women Bathing Suit", 1);
	 storeItems->SetValue(S"Quilted Down Jacket", 2);
	 storeItems->SetValue(S"Men Jacket", 3);
}

The Array class provides a SetValue() version for each corresponding CreateInstance() method we reviewed earlier.

Practical Learning: Adding Items to an Array

Array Members

Accessing the Members of an Array

Probably the most regularly performed operation on a list consists of retrieving the values of its members. In C++, you access the member of an array using its index as we saw earlier. To perform the same operation, the Array class is equipped with the GetValue() method that is overloaded with a version corresponding to each version of the CreateInstance() and the SetValue() method. For example, to access the values stored in a one-dimensional array, you can call call this version:

public: Object* GetValue(int index);

The argument is the zero-based index of the member whose value you want to access. If you pass an invalid value, the computer would throw an IndexOutOfRangeException exception.

Practical Learning: Accessing the Members of an Array

The Arrangement of the List

When a new item is added to the array, it assumes the last position. If you want, you can re-arrange the list in a consecutive order. If the list is a one-dimensional array made of strings, you can arrange it in alphabetical order. If it is made of numbers, you can order them in increment or decrement order. If the list is a two, three, or multi-dimensional array, you can arrange it based on a list-part of your choice. To support the ability to re-organize the list, the Array class is equipped with the Sort() method that is overloaded with as many versions as you can possibly need.

To arrange a single-dimensional array in a consecutive order, you can call the following version of the Array::Sort() method:

public: static void Sort(Array* array);

To reverse the sequence of items of a one-dimensional array, you can call the Array::Reverse() method. Its syntax is:

public: static void Reverse(Array* array);

When using a list, you may want to know whether a particular item exists in the list. There are usually two ways to perform this operation. In a C++ array, you usually can use a for statement to scan a list. With this approach, you navigate through the list by visiting the index of each item and checking the value of that index. Another solution consists of writing a function to perform the search. The Array class provides its own support of both solutions using various methods that can be used to perform this operation.

The Array::IndexOf() method scans a list by accessing the index of each item. This method is overloaded in three versions. To apply it on a single-dimensional array, use the following version:

public: static int IndexOf(Array* array, Object* value);

This method visits each index of the array, looking for the value. Once it finds value in the array, it stops and returns the index where the first occurrence of value was found. The IndexOf() method actually looks for the first occurrence of an item in an array. If you prefer to get the last occurrence of that item in the array, you can call the Array::LastIndexOf() method. It also is overloaded in three versions.