Continue with the project from the previous exercise.

Add the following function definition immediately after the using namespace System; line:

void func(int arr[], size_t size)
{
    Console::WriteLine("Size in func: {0}", sizeof(arr));
    for(size_t i=0; i<size; i++)
        Console::WriteLine(arr[i]);
}

The first argument to the function alerts the compiler that the address of an array is going to be passed, which is equivalent to passing a pointer. It’s very common to see int* used, instead. The second argument passes the size of the array—in effect, the amount of memory pointed to by the first argument. The function prints out the array by using the size, just as before.

Call the function from the main routine, as shown here:

func(arr, 10);

What if the array size needs to be changed at some point? You can make your code more robust by calculating the number of elements in the array automatically by using the sizeof operator, like this:

func(arr, sizeof(arr)/sizeof(arr[0]));

The sizeof operator returns the size of its argument in bytes, where the argument can be a variable name or a type name. Using sizeof on an array returns the total size of the array in bytes, in this case, 40 bytes. When divided by the size of one element—4 bytes—you’re left with the number of elements in the array.

Build and run the application.

The right values print out as well as the fact that the array is of size 4 bytes. This reflects the fact that it is passed to the function as a pointer.

Create a new CLR Console Application project named MultiD.

Open the source file MultiD.cpp and add the following code to the main function:

int main(array<System::String ^> ^args)
{
    Console::WriteLine("Multidimensional Arrays");

    // Create a 2D array
    int arr[2][3];

    // Fill the array
    for(int i=0; i<2; i++)
        for(int j=0; j<3; j++)
            arr[i][j] = (i+1)*(j+1);

    return 0;
}

Observe that a two-dimensional array is declared by using two sets of square brackets. You don’t put the two values inside one set of brackets, as you do in many other languages, and for higher-order arrays, you simply add more sets of square brackets. As with single-dimensional arrays, you have to provide the size at compile time, and the indices of each dimension vary from zero to one less than the declared size. Array elements are also accessed by using two sets of square brackets.

Print out the array by using an extension of the method for printing out the elements of the single-dimensional array, as follows:

// Print the array content
for(int i=0; i<2; i++)
{
    for(int j=0; j<3; j++)
        Console::Write("{0} ", arr[i][j]);

    Console::WriteLine();
}

Notice that one row of the array is printed on one line. The inner loop prints a single row by using repeated calls to Console::Write. After each row has been output, a call to Console::WriteLine outputs a new line.

Create a new CLR Console Application project named Dynamic.

Open the source file Dynamic.cpp and edit the main function as shown:

const size_t SIZE = 10;

int main(array<System::String ^> ^args)
{
    Console::WriteLine("Dynamic Arrays");

    // Create an array dynamically
    int *pa = new int[SIZE];

    // Fill the array
    for(size_t i=0; i<SIZE; i++)
        pa[i] = i*2;

    // Print the array content
    for(size_t j=0; j<SIZE; j++)
        Console::WriteLine(pa[j]);

    // Get rid of the array once we're finished with it
    delete [] pa;

    return 0;
}

You’ve previously used the gcnew operator to create .NET reference types; the new operator is used in traditional C++ code in a similar way to allocate memory dynamically at run time. The syntax is new, followed by the type of the array and then the dimension enclosed in square brackets. After the array has been created, you’re returned a pointer to the start of the array. Pointers work in a similar way to handles, but they use an asterisk (*) instead of a caret.

Create a new CLR Console Application project named SysArray.

At the top of the main function, add declarations for some loop counters and a two-dimensional array of 32-bit integers, as demonstrated in the following:

// Declare loop counters
int i,j,k;

// Create a multidimensional array of ints
array<int, 2> ^arr = gcnew array<int, 2>(3,2);

This is the array that you’ll use for exploring the features of the System::Array class in the rest of this section.

Because this is a managed array, it inherits directly from System::Array, so you can use the Rank and Length properties of the Array class to find out the rank (number of dimensions) and total length of the array. Add the following code to the main function:

Console::WriteLine("Rank is {0}", arr->Rank);
Console::WriteLine("Length is {0}", arr->Length);

When you run this code, you should find that the rank is two and the total length is six, which matches the declaration.

The GetLength method—not to be confused with the Length property—returns the size of any one dimension of the array, so you can print out the sizes of each dimension, as presented here:

// Print out the array dimension information
for (i=0; i<arr->Rank; i++)
    Console::WriteLine("Dimension {0} is of size {1}", i, arr->GetLength(i));

Now that you have an array and can find out how large each dimension is, you need to know how to get and set elements in the array.

Add the following nested loops to the end of your code:

// Fill the array with values
for (j=0; j<arr->GetLength(0); j++)
    for (k=0; k<arr->GetLength(1); k++)
        arr[j,k] = (j+1)*(k+1);

The outer loop iterates over the rows, whereas the inner loop iterates over the columns, and the [x,y] notation is used to reference the array elements. The Array class also has the SetValue method, which provides an alternative way of setting values for those languages that don’t support the array notation style of C++.

// Put '10' in array element [1,1]
arr->SetValue(10, 1, 1);

Print out the values in the array by using a similar pair of nested loops.

// Print out the array data
for (j=arr->GetLowerBound(0); j<=arr->GetUpperBound(0); j++)
    for (k=arr->GetLowerBound(1); k<=arr->GetUpperBound(1); k++)
        Console::WriteLine("pn[{0},{1}] = {2}", j, k, arr[j,k]);

Again, the outer loop iterates over the rows, and the inner loop iterates over the columns. In this case, the GetLowerBound and GetUpperBound methods return the indices of the lower and upper bounds. The argument to GetUpperBound and GetLowerBound is the dimension of the array whose bound you want to find. In C++, the lower bound is invariably 0 and the upper bound can be obtained by using the GetLength method, so these are mainly useful in other languages for which it might be common to have arrays with arbitrary lower and upper bounds.

Build and run the application. Check that the results are what you expect.

Continue by using the Strings project; add the following using declaration after the using namespace System; line:

using namespace System::Collections;

The IEnumerator interface is defined in the System::Collection namespace, so it’s easier to use enumerators if you add a using declaration for the namespace.

Add the following code to the end of the main function:

Console::WriteLine("---Using Enumerator---");
IEnumerator ^ie = sa->GetEnumerator();
while (ie->MoveNext())
    Console::WriteLine(ie->Current);

Build and run the application.

You’ll notice several things about this code. To begin with, the enumerator starts off positioned before the first element, so you need to call MoveNext once to get to the first element. When there are no more elements to retrieve, calls to MoveNext return false. The property Current retrieves the current object but doesn’t move the pointer, so you’ll get the same value back until you call MoveNext again. The Current property also returns a general Object handle, so you’ll often need to cast this to the actual type of the object by using the C++ dynamic_cast or the .NET equivalent keyword, safe_cast. (See Chapter 11, for details on how to use safe_cast.)

What isn’t obvious from the preceding code is that the enumerator gets a snapshot of the underlying collection. Enumerators are designed for read-only access to collections, and you can have several independent enumerators active on the same collection at one time. If any changes are made to the underlying collection, the snapshot will fall out of synchronization, which causes the IEnumerator to throw an InvalidOperationException, alerting you that it no longer reflects the underlying data.

Create a new CLR Console Application project named MyList.

Open the MyList.cpp source file and add the following line immediately after the using namespace System; line:

using namespace System::Collections::Generic;

The List class is defined in the System::Collections::Generic namespace. By inserting a using directive, you can use the name without having to fully qualify it every time.

Add the following code to the main function:

int main(array<String ^> ^args)
{
    Console::WriteLine("List Demo");

    // Create an empty List
    List<int> ^lst = gcnew List<int>();

    // Look at the count and capacity
    Console::WriteLine("Capacity={0}", lst->Capacity);
    Console::WriteLine("Count={0}", lst->Count);

    // Adjust the capacity
    lst->Capacity = 10;
    Console::WriteLine("Capacity={0}", lst->Capacity);

    // Add some elements
    lst->Add(0);
    lst->Add(2);
    lst->Add(3);
    lst->Insert(1, 1);
    Console::WriteLine("Count is now {0}", lst->Count);

    return 0;
}

The default List constructor creates an empty List. Because this is a generic type, you need to specify the type that the List is to contain, in this case int.

The next two lines use the Capacity and Count properties to print the current capacity of the List and a count of how many objects it currently contains. If you run this code, you’ll find that the count is 0—not surprising because you haven’t added anything yet—and that the capacity is also 0. Using the following alternative constructor, you can specify a different initial capacity:

    // Create a List with a capacity of ten elements
    List<int> ^pal = gcnew List<int>(10);

If you exceed the capacity when adding elements, it will automatically be doubled. If your array is too large, you can reduce its capacity to match the actual number of elements stored by calling TrimToSize. You can also reset the capacity of the List at any time by using its Capacity property.

The List doesn’t contain any elements until you add some by using the Add or Insert functions. Add appends a new item to the end of the list, whereas Insert takes a zero-based index and inserts a new item at that position.

Because List implements IEnumerator, you can print out the contents of the List by using a for each loop.

for each (int i in lst)
    Console::WriteLine(i);

The syntax for removing items from a List is similar to that used for retrieving them.

// Remove item at index 2
lst->RemoveAt(2);
Console::WriteLine("---Item removed---");
for each(int i in lst)
{
    Console::WriteLine(i);
}

If you want to remove more than one element, the RemoveRange function takes a starting index and a number of elements to remove. In addition, if you have stored a handle to an object in the collection, you can use the Remove function, which will search the List and remove the first occurrence.

Build and run the application.

Create a new CLR Console Application project named SortedList.

Open the SortedList.cpp source file and add the following line immediately after the using namespace System; line:

using namespace System::Collections::Generic;

The SortedList class is defined in the System::Collections::Generic namespace, and by inserting a using directive, you can use the name without having to fully qualify it every time.

Add the following code to the main function to create a SortedList and add some data to it:

SortedList<String^, int> ^sl = gcnew SortedList<String^, int>();

sl->Add("Dilbert", 1044);
sl->Add("Wally", 2213);
sl->Add("Ted", 1110);
sl->Add("Alice", 3375);

When you create a SortedList, you must specify the types for the key and the value within the angle brackets. In this case, we are using a String^ for the key, and an int for the value.

As with the List discussed in the previous section, a SortedList has a default capacity and will automatically increase its capacity as necessary. Using alternative constructors, you can create SortedList classes with particular initial capacities, and you can trim excess by using the Trim ToSize function.

The Add method takes key/value pairs and adds them to the SortedList. If the key already exists in the collection, the method throws an ArgumentException.

Add some code to print out the contents of the SortedList by using a for each loop.

for each (KeyValuePair<String^, int> kp in sl)
    Console::WriteLine("Key={0}, value={1}", kp.Key, kp.Value);

In addition to retrieving values by index, you can retrieve them by key, as demonstrated here:

Console::WriteLine("Value for key 'Alice' is {0}", sl["Alice"]);

The indexer uses the key to return its associated value if a match is found; if no match is found, the indexer throws an exception.

As an alternative to handling an exception, you can use TryGetValue, which returns a bool to let you know whether it found a value.

int value = 0;
if (sl->TryGetValue("Fred", value))
    Console::WriteLine("Value is {0}", value);
else
    Console::WriteLine("Key not found");

In this code, value is passed through to TryGetValue by reference so that the function can update it.

You can also modify entries in the list by using the indexer, like this:

// Change the value associated with key 'Alice'
sl["Alice"] = 5555;
Console::WriteLine("Value for 'Alice' is {0}", sl["Alice"]);

If the key already exists, its associated value is overwritten; if it doesn’t exist, a new key/value pair is created.

Build and run the application.