Design and test a reference array, Data Structure & Algorithms

Assignment Help:

Instructions

  • Design and test a reference array. Reference array stores the references to user supplied objects of different types. Just think it as a heterogeneous array which can contain elements of different types.
  • Exceptions must be used to handle all type of errors that may be encountered while using the array. The main errors are:
    • No object is found while trying to access an object from the array at a given position
    • The index may be beyond the array limits.
  • The necessary classes for the problems and also the driver main function are given. You have to provide the implementations of the member functions whose actual code is missing.

// ArrayImp.h

#include

#include

enum SortOrder { Asc, Desc};

class ArrayImp{

                protected:

                                size_t  size;

                                void ** vp;

                                ArrayImp( size_t sz);

                                ArrayImp( const ArrayImp& cp);

                                ~ ArrayImp();

                                ArrayImp& operator=(const ArrayImp & cp);

                                void * Get( size_t  index);

                                void * Put(size_t  index, const void * what);

                                void Print() const;

};

ArrayImp:: ArrayImp(size_t sz){

                if (sz > 0){

                                size = sz;

                                vp = new void* [size];

                                for ( int I = 0; I < size; i++)

                                                vp[i] = 0;

                }else{

                                vp = 0;

                                size 0;

                }

}

ArrayImp:: ArrayImp( const ArrayImp& cp){

                if ( cp.size > 0){

                                size = cp.size;

                                vp = new void * [size];

                                for ( int I = 0; i< size; i++)

                                                vp[i] = cp.vp[i];

                } else{

                                size = 0;

                                vp = 0;

                }

}

ArrayImp&  ArrayImp ::operator=(const ArrayImp & cp){

                                //  your responsibility

}

void * ArrayImp:: Get( size_t  index){

                return  vp[index];

}

void * ArrayImp:: Put(size_t  index, const void * what){

                void * oldVal = vp[index];

                vp[index] = const_cast (what);

                return oldVal;

};

void * ArrayImp:: ArrayImp:: Print() const{

                cout<<"Contents:"<

                for ( int I = 0; i< size; i++)

                                cou<

                cout<

};

// AExection.h

class  ArrayException{

                private:

                                size_t  index;                        // index causing exception

                public

                                ArrayException(size_t  pos){ index = pos;}

                                virtual const char * GetDescription() const = 0;

                                size_t   GetExceptionIndex() const{

                                                return index;

                                }

};

class NoObjectException: public ArrayException{

               public:

                                NoObjectException( size_t  pos): ArrayException(pos){}            

                                const char * GetDescription() const {

                                                return "ERROR: No object at the specified index position";

                                }

};

class RangeException: public ArrayException{

               protected:

                                size_t    size;

                public:

                                RangeException( size_t  pos, size_t   aSize): ArrayException(pos), size(aSize){}      

                                const char * GetDescription() const {

                                                 return "ERROR: Index out of bound";

                                }

                                size_t  GetArraySize() const { return  size;}

}

// SafeArray.h

#include

#include< ArrayImp.h >

#include< AExection.h>

const size_t  MAX = 256;

template

class SafeArray: private  ArrayImp{

                public:

                                SafeArray ( int sz = MAX);

                                SafeArray( const SafeArray & cp);

                                SafeArray & operator=(const SafeArray & cp);

                                ~ SafeArray();

                                int GetSize(){ return size;}

                                T& Get(size_t  pos) throw (NoObjectException, RangeException);

                                T& Put(size_t  pos, const T & thisObj) throw (RangeException);

                                T& operator[](size_t  index);

                                void Print() const;

};

// main driver program

#include

#include

#include< ArrayImp.h >

#include< AExection.h>

#include

int main(){

                SafeArray x(10), y(10);

                int  a= 10, b = -100;

                x.Put(0,a);

                x.Put(1,b);

                x.Print();

                x[1] = x[0];

                y = x;

                y.Print();

                try{

                                x[11] = x[3];

                }

                catch(const NoObjectException & exp){

                                cout<<"Caught: NoObjectException Exception"<

                                cout<<"Index Error : " <

                };

                catch(...){

 

                                cout<<"Caught an Exception<

                };

                cout<<"Trying to access beyond arrya limit"<

                try{

                                x[11] = x[12];

                }

                catch(const ArrayException& exp){

                                cout<<

                                cout<<"Index Error : " <

                };

                catch(...){

                                 cout<<"Caught an Exception<

                };

                return 0;

}


Related Discussions:- Design and test a reference array

Properties of red- black tree, Any Binary search tree has to contain follow...

Any Binary search tree has to contain following properties to be called as a red- black tree. 1. Each node of a tree must be either red or black. 2. The root node is always b

Trees, What is AVL Tree? Describe the method of Deletion of a node from and...

What is AVL Tree? Describe the method of Deletion of a node from and AVL Tree ?

Explain the term group support system, (a) Explain the term Group Support S...

(a) Explain the term Group Support System and elaborate on how it can improve groupwork. (b) Briefly explain three advantages of simulation. (c) Explain with the help of a

Programme in c to create a single linked list, Q. Write  down a   p...

Q. Write  down a   programme  in  C  to  create  a  single  linked  list also  write the functions to do the following operations (i)  To insert a new node at the end (ii

Multiple stack in single dimensional array, Implement multiple stacks in a ...

Implement multiple stacks in a single dimensional array. Write algorithms for various stack operations for them.

Binary tree construction, Construct a B+ tree for the following keys, start...

Construct a B+ tree for the following keys, starting with an empty tree.  Each node in the tree can hold a maximum of 2 entries (i.e., order d = 1). Start with an empty root nod

The theta-notation, This notation bounds a function to in constant factors....

This notation bounds a function to in constant factors. We say f(n) = Θ(g(n)) if there presents positive constants n 0 , c 1 and c 2 such that to the right of n 0 the value of f

Analysis of algorithms, A common person's faith is that a computer can do a...

A common person's faith is that a computer can do anything. It is far from truth. In realism computer can carry out only definite predefined instructions. The formal illustration o

Simulation of queues, Simulation of queues: Simulation is the process of f...

Simulation of queues: Simulation is the process of forming an abstract model of a real world situation in order to understand the effect of modifications and the effect of introdu

Write Your Message!

Captcha
Free Assignment Quote

Assured A++ Grade

Get guaranteed satisfaction & time on delivery in every assignment order you paid with us! We ensure premium quality solution document along with free turntin report!

All rights reserved! Copyrights ©2019-2020 ExpertsMind IT Educational Pvt Ltd