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();
}

[Gianni Mariani]

- Steve - wrote:

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();
}

your IntArray class needs to overload operator [] ... ?

Try creating a class and post the results ....

[Alf P. Steinbach]

On 25 Jul 2003 19:56:06 -0700, se****@foundati on.sdsu.edu (- Steve -) wrote:

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.
(0)
A std::vector be a good idea for representing the storage.
Wrap that in a class.
void test2()
{
system("cls");
(1)
Not a good idea. Only works on a system with cls command.
Cannot be redirected to a file.

cout << "2. Array declared with two integers: IntArray b(-3, 6);" <<
endl << endl;
csis << "2. Array declared with two integers: IntArray b(-3, 6);" <<
(2)
What's "csis"?
Presumably some log file.
Why not just redirect standard output?

(3)
Duplicated literal text, use a named constant.

endl << endl;
IntArray b(-3, 6);
(4)
This tells you that you need a constructor with two arguments.

for(int i = b.low(); i <= b.high(); i++)
(5)
This tells you that you need accessor methods called "low" and
"high".

b[i] = i * 10;
(6)
This tells you that you need an operator[]. See TCPPPL for an
example. For example.

b.setName('b');
(7)
This tells you that you need a modifier method called "setName".

cout << b << endl;
(8)
This tells you that you need something that makes it possible
to use an IntArray as an argument to an output stream. It
could be a custom operator<<. It could be an operator const char*.

csis << b << endl;
wait();
(9)
Assuming "wait" waits for user input that is ABSOLUTELY NOT a good
idea because it means you cannot automate the testing.
}

[Clive]

> A std::vector be a good idea for representing the storage.

Wrap that in a class.
Isn't that a bit of overkill? From what i understand, the arrays created
don't have to be variable themselves. Just the index which created them.

Could you just create a class, that has a int start, and and int end, an int
a[end-start] and then a function, getInt(arrayInd ex) which would presumably
be between the start and end (i'm sure you could also do checks for this).

so then you would go

MyClass m = myClass(-3, 6);
m.getInt(-1)

"Alf P. Steinbach" <al***@start.no > wrote in message
news:3f******** ********@News.C IS.DFN.DE... On 25 Jul 2003 19:56:06 -0700, se****@foundati on.sdsu.edu (- Steve -) wrote:

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.
(0)

void test2()
{
system("cls");

(1)
Not a good idea. Only works on a system with cls command.
Cannot be redirected to a file.

cout << "2. Array declared with two integers: IntArray b(-3, 6);" <<
endl << endl;
csis << "2. Array declared with two integers: IntArray b(-3, 6);" <<

(2)
What's "csis"?
Presumably some log file.
Why not just redirect standard output?

(3)
Duplicated literal text, use a named constant.

endl << endl;
IntArray b(-3, 6);

(4)
This tells you that you need a constructor with two arguments.

for(int i = b.low(); i <= b.high(); i++)

(5)
This tells you that you need accessor methods called "low" and
"high".

b[i] = i * 10;

(6)
This tells you that you need an operator[]. See TCPPPL for an
example. For example.

b.setName('b');

(7)
This tells you that you need a modifier method called "setName".

cout << b << endl;

(8)
This tells you that you need something that makes it possible
to use an IntArray as an argument to an output stream. It
could be a custom operator<<. It could be an operator const char*.

csis << b << endl;
wait();

(9)
Assuming "wait" waits for user input that is ABSOLUTELY NOT a good
idea because it means you cannot automate the testing.

}

[Clive]

> > MyClass m = myClass(-3, 6);

m.getInt(-1)
That wouldn't satisfy the OP's requirements.

Yes, after reading the testing thing, i realise that this is wrong :(
The requirements would inspire me to learn how to do operator overloading.
Up until now... i just cant be bothered.
No. An array's size is a compile-time constant. A std::vector member is
just right for this; the alternative is explicitly memory-managing a
dynamic array. And vector will check your subscripts for you if you ask
it nicely.

i mean more like int* array = new int[end-start]

I got the impression that if it's a high school assignment. They wouldn't
need to jump right into vectors quite yet. Maybe i'm wrong though..

I guess i'm a fan of doing things your own way, doing as much stuff for
yourself instead of using someone elses stuff. the vector would do a fine
job of it, i just dont like thinking of all the extra resources and space
that they might use :) but on computers these days.. who cares right?

[John Harrison]

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

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();
}

The difficulty in answering this question is that you've given no clue as to
your level of ability. Do you know how to create a class for instance?

If yes then have a go and post the resulting code, it doesn't matter if bits
are missing, it doesn't even matter if it doesn't compile. When we see how
good (or bad!) your coding is we'll be able to give appropriate advice.

If you don't know how to write a class then you've got a lot of catching up
to do.

john

[Peter van Merkerk]

"Clive" <cl***@clive.cl ive> wrote in message
news:3f******** *************** @freenews.iinet .net.au...

MyClass m = myClass(-3, 6);
m.getInt(-1)
That wouldn't satisfy the OP's requirements.

Yes, after reading the testing thing, i realise that this is wrong :(
The requirements would inspire me to learn how to do operator overloading.
Up until now... i just cant be bothered.

No. An array's size is a compile-time constant. A std::vector member is
just right for this; the alternative is explicitly memory-managing a
dynamic array. And vector will check your subscripts for you if you ask
it nicely.

i mean more like int* array = new int[end-start]

I got the impression that if it's a high school assignment. They wouldn't
need to jump right into vectors quite yet. Maybe i'm wrong though..

If you look at it another way it might actually make sense to learn simple
things like std::vector first and learn the low level stuff (which needed to
implement a vector class) later.
I guess i'm a fan of doing things your own way, doing as much stuff for
yourself instead of using someone elses stuff.
That is a great approach if the goal is to expand your knowledge and to get
a better insight how things work. On the other hand there is much to be said
for not reinventing the wheel every time and using the tools you have
already at your disposal. Spending some time in getting familiar with the
standard library is an investment that will pay itself back in no time. For
serious projects your approach is hardly practial; writing everything from
scratch takes a lot of time and for most projects time is a rather scarce
and expensive commodity.
the vector would do a fine
job of it, i just dont like thinking of all the extra resources and space
that they might use :) but on computers these days.. who cares right?

The amount of extra space required when using std::vector compared to your
own homebuild equivalent may very well be close to zero. Optimization based
on presumptions is a bad thing and more importantly a waste of time. Get the
code right and as clear as possible first (the standard library can help a
lot here), if and only if the perfomance/memory usage is not acceptable,
find the bottleneck(s) and optimize the relevant parts of your code.
--
Peter van Merkerk
peter.van.merke rk(at)dse.nl

[- Steve -]

Okay here's my class I'm working on right now, plus all the info I
think is needed to see what I'm trying to do. Basically I need the
following three lines of code to run

IntArray a(10);
for(int i=a.low();i<=a. high();i++)
a[i]=i*10;

I'm trying to overload the [] operator. The function ARRAYSTRUCT
IntArray::opera tor[] (int forLocation) is where things are starting to
fall apart I believe.

//My Class and such

typedef struct { //Array structure
int location;
int value;
} ARRAYSTRUCT;

class IntArray
{
private:
int arrayLow, arrayHigh; //low & high index of array
char name; //name of object
ARRAYSTRUCT *array; //pointer to beggining of array

public:
IntArray(int); //Constructor for arrays starting at 0
// IntArray(int, int); //Constructor for arrays not starting at 0

ARRAYSTRUCT IntArray::opera tor[](int); //Overload [] - Pass location,
assign value

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

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

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

array=new ARRAYSTRUCT[size]; //create array memory locations

for(int i=arrayLow;i<=a rrayHigh;i++)
{
array->location=i; //Sets index of array
array->value=NULL; //Sets value of array to NULL
}
}

ARRAYSTRUCT IntArray::opera tor[] (int forLocation)
{
ARRAYSTRUCT *myLocation=arr ay;

for(int i=0;i<(arrayLow +forLocation);i ++) //get myLocation to
correct spot
myLocation++;

return *myLocation;
}

"John Harrison" <jo************ *@hotmail.com> wrote in message news:<bf******* *****@ID-196037.news.uni-berlin.de>...

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

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();
}

The difficulty in answering this question is that you've given no clue as to
your level of ability. Do you know how to create a class for instance?

If yes then have a go and post the resulting code, it doesn't matter if bits
are missing, it doesn't even matter if it doesn't compile. When we see how
good (or bad!) your coding is we'll be able to give appropriate advice.

If you don't know how to write a class then you've got a lot of catching up
to do.

john

[- Steve -]

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
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

~IntArray(); //Default Deconstructor

int& IntArray::opera tor[](int); //Overload [] for Assigning Values

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

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
}

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

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;
}

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

se****@foundati on.sdsu.edu (- Steve -) wrote in message news:<cb******* *************** ***@posting.goo gle.com>...

Okay here's my class I'm working on right now, plus all the info I
think is needed to see what I'm trying to do. Basically I need the
following three lines of code to run

IntArray a(10);
for(int i=a.low();i<=a. high();i++)
a[i]=i*10;

I'm trying to overload the [] operator. The function ARRAYSTRUCT
IntArray::opera tor[] (int forLocation) is where things are starting to
fall apart I believe.

//My Class and such

typedef struct { //Array structure
int location;
int value;
} ARRAYSTRUCT;

class IntArray
{
private:
int arrayLow, arrayHigh; //low & high index of array
char name; //name of object
ARRAYSTRUCT *array; //pointer to beggining of array

public:
IntArray(int); //Constructor for arrays starting at 0
// IntArray(int, int); //Constructor for arrays not starting at 0

ARRAYSTRUCT IntArray::opera tor[](int); //Overload [] - Pass location,
assign value

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

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

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

array=new ARRAYSTRUCT[size]; //create array memory locations

for(int i=arrayLow;i<=a rrayHigh;i++)
{
array->location=i; //Sets index of array
array->value=NULL; //Sets value of array to NULL
}
}

ARRAYSTRUCT IntArray::opera tor[] (int forLocation)
{
ARRAYSTRUCT *myLocation=arr ay;

for(int i=0;i<(arrayLow +forLocation);i ++) //get myLocation to
correct spot
myLocation++;

return *myLocation;
}

"John Harrison" <jo************ *@hotmail.com> wrote in message news:<bf******* *****@ID-196037.news.uni-berlin.de>...

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

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();
}

The difficulty in answering this question is that you've given no clue as to
your level of ability. Do you know how to create a class for instance?

If yes then have a go and post the resulting code, it doesn't matter if bits
are missing, it doesn't even matter if it doesn't compile. When we see how
good (or bad!) your coding is we'll be able to give appropriate advice.

If you don't know how to write a class then you've got a lot of catching up
to do.

john

[Alf P. Steinbach]

On 26 Jul 2003 18:18:12 -0700, se****@foundati on.sdsu.edu (- Steve -) wrote:

Okay Scratch all that, I've made some major progress. Take a look at this.
Progress, very good.
class IntArray
{
private:
int arrayLow, arrayHigh; //low & high index of array
char name; //name of object
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
The copy constructor has a standard signature,
IntArray( IntArray const& another )
which allows you to write e.g.
IntArray a;
IntArray b = a; // Copy constructor invoked.
When you define a copy constructor you should -- usually -- also
define an assignment operator,
IntArray& operator=( IntArray const& rhs )
which allows you to write
b = a;
Generally when one form of copying is needed the other one is also
needed.

~IntArray(); //Default Deconstructor

int& IntArray::opera tor[](int); //Overload [] for Assigning Values

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

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

#include "intarray.h "

IntArray::IntA rray()
{
arrayLow=0;
arrayHigh=9;

array=new int[arrayHigh-arrayLow];
}
Is it meaningful to have a default constructor?

If you choose to have an assignment operator (see above comments),
then a default constructor can make practical sense.

But is it then meaningful to have it create anything other than
a _zero size_ array? I see further down that you list that as
a requirement. If it is a requirement then it seems to be a
requirement (analysis/design-level) bug, to be reported.
IntArray::IntA rray(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
}
The 'name' member is not initialized.

Tip: look up constructor initializer lists.

IntArray::IntA rray(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
}
Here is an additional bug. When bug-free all cases except
arrayHigh<array Low-1 should be treated the same. Assuming the
requirements you list further down.


IntArray::IntA rray(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
Now here's that bug again.
for(int i=arrayLow;i<=a rrayHigh;i++)
array[i]=copyThis->array[i];
}
Just a stylistic hint. For various reasons old-timers prefer
to write "++i" instead of "i++". One reason is that this _can_
be more efficient, another is that when you have a general
iterator instead of an integer or pointer the iterator may only
support the prefix form, so that form is more general.


IntArray::~Int Array()
{
//for(int i=arrayLow;i<=a rrayHigh;i++)
// delete [] array[i];
//delete [] array;
}
I assume this is work in progress.
int& IntArray::opera tor[] (int forLocation)
{
return array[arrayLow+forLoc ation];
}
Works, but isn't the point of having specified bounds to also
have bounds-checking?
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

Possibly the last one should be reported as impractical, and in general,
when a requirement introduces arbitrariness it's probably a screw-up.

Okay, that's my comments.

Great work, keep that up!