Arrays of Variable Sizes

[- Steve -]

For a school assignment I need to write a class to work with the
following code. The IntArray b(-3, 6) basically means that I need to
produce an array of integer values that has an index going from -3 to
6. I'm completely lost on how I should create that array. Any shoves
in the right direction would be appreciated.

void test2()
{
system("cls");
cout << "2. Array declared with two integers: IntArray b(-3, 6);" <<
endl << endl;
csis << "2. Array declared with two integers: IntArray b(-3, 6);" <<
endl << endl;
IntArray b(-3, 6);
for(int i = b.low(); i <= b.high(); i++)
b[i] = i * 10;
b.setName('b');
cout << b << endl;
csis << b << endl;
wait();
}

[John Harrison]

Comments below.

"- Steve -" <se****@foundat ion.sdsu.edu> wrote in message
news:cb******** *************** ***@posting.goo gle.com...

Okay Scratch all that, I've made some major progress. Take a look at this.
class IntArray
{
private:
int arrayLow, arrayHigh; //low & high index of array
char name; //name of object
Do arrays really need names? And why only a single char for the name?
int *array; //pointer to beggining of array

public:
IntArray(); //Constructor - create array index 0-9
IntArray(int); //Constructor for arrays starting at 0
IntArray(int, int); //Constructor for arrays not starting at 0
IntArray(IntArr ay*); //Constructor for making copy of another IntArray object

Not correct. For a copy constructor you (almost) always write

IntArray(const IntArray&);

then you also need assignment operator

IntArray& operator=(const IntArray&);

Without these two you program will crash, because the copielr will generate
these for you, if you haven't written then yourself. But the compiler
generated version will be incorrect because it will copy your array pointer
instead of allocating more memory.

~IntArray(); //Default Deconstructor

int& IntArray::opera tor[](int); //Overload [] for Assigning Values
IntArray:: is incorrect (but some compilers allow it)

int& operator[](int); //Overload [] for Assigning Values

You also need an overload for accessing values from a const array

int operator[](int) const;

int low() {return arrayLow;} //Returns lowest index of array
int high() {return arrayHigh;} //Returns highest index of array
These should be const, its very important in C++ to mark methods as const if
that is what they are

int low() const {return arrayLow;} //Returns lowest index of array
int high() const {return arrayHigh;} //Returns highest index of array

Without the const methods I've described above, this code would not compile

int print_array(con st IntArray& a)
{
for (int i = a.low(); i <=a.high(); ++i)
cout << a[i];
}

because a is a const.

void setName(char myName) {name=myName;} //Sets name of object
};

#include "intarray.h "

IntArray::IntAr ray()
{
arrayLow=0;
arrayHigh=9;

array=new int[arrayHigh-arrayLow];
}

IntArray::IntAr ray(int size)
{
arrayLow=0; //array starts at 0
arrayHigh=size-1; //highest index of array based on given size

array=new int[size]; //create array memory locations
}

IntArray::IntAr ray(int low, int high)
{
arrayLow=low; //start of array index
arrayHigh=high; //end of array index

if(arrayLow==ar rayHigh)
array=new int[1]; //if high and low are equal create an array 1 unit long
else
array=new int[arrayHigh-arrayLow]; //create array memory locations
The math is wrong

array=new int[(arrayHigh - arrayLow) + 1];

No need to treat low == high as a special case (this should have been a
warning that you'd got something wrong, specail cases are to be avoided if
possible).
}

IntArray::IntAr ray(IntArray* copyThis)
{
arrayLow=copyTh is->low();
arrayHigh=copyT his->high();

if(arrayLow==ar rayHigh)
array=new int[1]; //if high and low are equal create an array 1 unit long
else
array=new int[arrayHigh-arrayLow]; //create array memory locations
Again the math is wrong, but the basic idea is right. Now rewrite this to
use the proper method of writing a copy constructor. The don't forget to add
an assignment operator.

for(int i=arrayLow;i<=a rrayHigh;i++)
array[i]=copyThis->array[i];
}

IntArray::~IntA rray()
{
//for(int i=arrayLow;i<=a rrayHigh;i++)
// delete [] array[i];
//delete [] array;
delete[] array; is correct.
}

int& IntArray::opera tor[] (int forLocation)
{
return array[arrayLow+forLoc ation];
}

Also some quick requirments:

IntArray a(10), w(10); // Ten elements, indexed 0 to 9
IntArray b(-3, 6); // Ten elements, indexed -3 to 6
IntArray c(6, 8); // Three elements, indexed 6 to 8
IntArray d(5, 5); // Single element array, indexed at 5
IntArray z; // Ten elements, indexed 0 to 9

Looks pretty good. You've made the common newbie mistakes, ignoring the
issue of const, and being unsure about copying, but you're not far away from
finishing this.

john

[John Harrison]

Another math error

IntArray::IntAr ray()
{
arrayLow=0;
arrayHigh=9;

array=new int[arrayHigh-arrayLow];

array = new[(arrayHigh-arrayLow)+1];

or rether more simply

array = new[10];

BTW you obviously haven't heard of initaliser lists. Really all your
constructors should be written like this

IntArray::IntAr ray() : arrayLow(0), arrayHigh(9), array(new int[10])
{
}

Look them up in your favourite C++ book.

john