/***********************************************************************
MEMORIAL UNIVERSITY OF NEWFOUNDLAND
Faculty of Engineering and Applied Science
Engineering 3891(Advanced Programming)
Assignment #7 Instructor: Michael Bruce-Lockhart
Date: 00.11.15 Due: 00.11.24
***********************************************************************/
/* A different kind of vector problem.
*/
// Possible error states - CHANGE no memory, index out of range, non positive size
enum errors{NOMEM,OUTRANGE,NONPOS};
class Vector{
public:
// Constructors
Vector(int s=1); // constructor, nonpos error if s<1
// Accessors
int ub() const; // The last index (indices run from 0 to size - 1)
int howMany() const; // return total no. of Vector objects
// Some operator overloads
double& operator[](int i); // See notes for discussion
Vector operator+(const Vector& rhs); // NOT an error if sizes are different
// if v longer, add 1st size components of v
// if v shorter, add to only 1st v.size components
// outrange is error
// The BIG THREE, copy constructor, assignment overload, destructor
Vector(const Vector& orig);
Vector& operator=(const Vector& rhs);
~Vector();
private:
double *p;
int size;
static int count; // The number of vector objects currently in existence
};
/* We repeat the class here with a full specification
class Vector{
public:
// In the case of an error, or an inability to create the requested vector
// because there is not enough space on the heap (which is NOT an error),
// construct a NULL object (p and size both set to 0. increase count by
1
// because a NULL object is STILL an object.
// The vector constructor does not initialize the vector array itself.
Vector(int s=1); // constructor, nonpos error if s<1.
// Accessors
int ub() const; // The last index
int howMany(); // return total no. of Vector objects
// Some operator overloads
double& operator[](int i); // See notes for discussion
// Error if i is not in range. If i is out of range, operator[] will return
// a reference to a single safe location (see notes for more detail)
// outrange is error
----------------------------------------
Vector operator+(const Vector& rhs); // NOT an error if sizes are different
// if v longer, add 1st size components of v
// if v shorter, add to only 1st v.size components
In the case of unequal lengths, the sum operator should return a Vector
equal in length to the longest of the two operand Vectors with addition
carried out over only the n leftmost components where n is the size of
the shorter Vector. The extra components are just copied from the longer
Vector (i.e. treating the shorter one as if it were padded out with zeros)
// The BIG THREE, Copy constructor, assignment overload, destructor
Vector& operator=(const Vector& rhs);
// Again, sizes may be different. the left hand operand will be resized
to
// the same size as the right. The old storage will be released properly.
The
// code should work properly for the degenerate case of x = x where x is
a
// vector object.
// Create a NULL object if there is insufficient room on the heap
Vector(const Vector& orig); // Copy constructor
~Vector(); // The destructor
private:
double *p; // Pointer into the heap to the actual vector array
int size; // Of the vector
static int count; // The number of vector objects currently in existence
};
*/
void vError(errors e);
/* You are NOT TO PROVIDE CODE FOR THIS ERROR FUNCTION! We will do
that in our grading routine. However, unlike other error handling
mechanisms you may have seen, YOU ARE NOT TO EXIT (which will bring
the whole grading program to a screeching halt). Instead you are to call
vError() telling it which of the three defined errors was made.
The grading program will be looking for your call and so know if you
are calling the error routine correctly. After your call, you should -
Construct a NULL object (size = 0, p = 0 BUT count still incremented)
in the case of an error in either constructor call.
Have a static (i.e. permanent) dummy double you can return in the
case of an out of range error in a call to the array operator[]
overload. This allows you to write something like
Vector v(3); // construct a vector 3 elements long
v[5] = 7; // write to the 5'th element!
harmlessly. The second line involves a call to the array operator.
The assignment requires that the number 7.0 by written somewhere. The
fact that the operator[] function returns a reference is what allows
this write operation. By returning a reference to a safe, dummy
location, the 7.0 is written somewhere that it can do no harm.
In the case of the +operator, a new sum must be constructed. There
may not be enough memory. In that case construct a NULL object as
with the constructors.
In the case of the assignment operator, the left side may be of a
different length than the right in which case a new object will
need to be constructed. Same problem and same solution as above.
*/