The three goals for this exercise are:
1. to continue to improve upon the SmartArray class
2. to practice concepts that related to dealing with references – specifically, for copying an array by hand.
3. to start working towards creating your own tests for your code.
For this exercise, you will implement the SmartArrayResizable class. The key difference between this version & the last version is that the last version only allocated memory once, and if you used it all up, you were out of luck – with this class, you can ask it to allocate a new array if it’s out of memory.
The key thing to learn here is how to make a larger copy of a given array
yourself (i.e., without using any built-in .Net methods) – in a nutshell, you'll
need a variable to hold a temporary reference to the new, larger array, then
you'll need to copy everything from the existing array into the new array, and
finally you'll need to set the rgNums
field to refer to the new array.
Since this is C#, and C# has garbage-collection, you won't need to worry about
releasing the memory occupied by the old array –the language will eventually
notice, and get rid of it for you (well, technically the .Net Common Language
Runtime will do this, but who's quibbling? J ). The exact behavior is
described below.
Once you've done that, you should put (in comments) the running time, in Big "Oh" notation, for each method that you implemented. Make sure to specify the running time for the case wherein you need to allocate the array (remember that the .Net runtime will have to initialize each element of the array to "0" – even though the runtime is doing that for you, it still counts as time! J), as opposed to the situation wherein the array was previously allocated in a different method call.
What you need to do for this exercise:
Test_SmartArrayResizable_Basic
class and the
Test_SmartArrayResizable
class. They should all pass at this point, and if
not, then you should fix your program so that those tests do pass. You can
run the tests using the NUnit support in the provided starter project. You
should feel free to supplement that code with your own test cases if you wish,
but you are neither required nor expected to.Test_SmartArrayResizable_Basic
class serves to make sure that your SmartArrayResizable
still does everything
that a basic SmartArray
does. It is expected that your SmartArrayResizable
will be able to pass these tests simply by virtue of inheriting methods from the
SmartArray base class.SmartArrayResizable
class MUST inherit from the
SmartArray
class in order for
these tests to even compile!Test_SmartArrayResizable
class serves
to check new, SmartArrayResizable
-specific functionality that you’ve
implemented in this exercise
SmartArrayResizable Data & Methods |
|||
Data Field Name |
Type |
Description: |
|
|
Array of |
A reference to an array of integers. |
|
Note: all data fields should be marked private, unless otherwise specified |
|||
Method Name |
Returns |
Description/Parameters: |
|
Default constructor |
<nothing> |
Initializes |
|
|
<nothing> If the memory isn’t allocated, then the C# runtime will throw an exception, so we don’t have to do anything special to handle the case where we ask for more memory than C# can provide. |
Parameters: 1. An integer that is desired new size of the array.
By calling this method, the caller is indicating that the SmartArray
should be resized. If the value of the parameter is larger than the
current size of
If the value of the parameter is smaller than |
|
|
<nothing> |
Parameters: 1. An integer that is the index of the element to set 2. An integer that is the value to set that element to
Conceptually,
this will accomplish the same sort of thing as saying
would accomplish with a normal array
This will throw an |
|
|
The integer value at the array slot. |
Parameters: 1. An integer that is the index of the element to get
Conceptually,
this will accomplish the same sort of thing as saying
would accomplish with a normal array This will throw an |
|
|
Nothing (void) |
Parameters: None
Print all elements of the array, one per line, onto the console.
|
|
|
true if at least one element in the array is the same value as the parameter, false if the given value isn't present in the array. |
Parameter: 1. An integer that may or may not be in the array.
This method takes it's parameter, and sees if that value is located anywhere within the array. If it finds even a single slot of the array with the same value as the parameter, it will return true. If the value isn't found anywhere within the array, it will return false.
|
|
|
An integer – the size, in number of elements, that the SmartArray currently has the capacity to hold. |
If the array hasn't been allocated yet, this will return Int32.MinValue. Otherwise, the following logic should be executed:
|
|
Note: all methods should be marked public |
|