Abstract array - c program, C/C++ Programming

Assignment Help:

Abstract array - c program:

AbstractArray::AbstractArray( int anUpper, int aLower, sizeType aDelta )

{

    PRECONDITION( anUpper >= aLower );

    lastElementIndex = aLower - 1;

    lowerbound = aLower;

    upperbound = anUpper;

    delta = aDelta;

 

    theArray = new Object *[ arraySize() ];

    if( theArray == 0 )

        ClassLib_error(__ENOMEM);

 

    for( int i = 0; i < arraySize(); i++ )

        {

        theArray[ i ] = ZERO;

        }

}

 

AbstractArray::~AbstractArray()

{

    PRECONDITION( theArray != 0 );

    if( ownsElements() )

        for( int i = 0; i < arraySize(); i++ )

            if( theArray[ i ] != ZERO )

                delete theArray[ i ];

    delete [] theArray;

}

 

void AbstractArray::detach( Object& toDetach, DeleteType dt )

{

    detach( find( toDetach ), dt );

}

 

void AbstractArray::detach( int atIndex, DeleteType dt )

{

    PRECONDITION( atIndex >= lowerbound &&

                  atIndex <= upperbound && theArray != 0

                );

 

    if( ptrAt(atIndex) != ZERO )

        {

        if( delObj(dt) )

            delete ptrAt(atIndex);

        itemsInContainer--;

        }

    removeEntry(atIndex);

    if( atIndex <= lastElementIndex )

        lastElementIndex--;

    CHECK( itemsInContainer != UINT_MAX );

}

 

void AbstractArray::flush( DeleteType dt )

{

    if( delObj(dt) )

        for( unsigned i = 0; i <= zeroBase(upperbound); i++ )

            if( theArray[i] != ZERO )

                delete theArray[i];

 

    for( unsigned i = 0; i <= zeroBase(upperbound); i++ )

        theArray[i] = ZERO;

 

    itemsInContainer = 0;

    lastElementIndex = lowerbound-1;

}

 

inline unsigned nextDelta( unsigned sz, unsigned delta )

{

    return (sz%delta) ? ((sz+delta)/delta)*delta : sz;

}

 

void AbstractArray::reallocate( sizeType newSize )

{

    PRECONDITION( newSize > arraySize() );

    if( delta == 0 )

        ClassLib_error(__EEXPANDFS);

 

    sizeType adjustedSize = arraySize() +

                            nextDelta( newSize - arraySize(), delta );

    Object **newArray = new Object *[ adjustedSize ];

    if( newArray == 0 )

        ClassLib_error(__ENOMEM);

 

    memcpy( newArray, theArray, arraySize() * sizeof( theArray[0] ) );

 

    for( int i = arraySize(); i < adjustedSize; i++ )

        newArray[i] = ZERO;

 

    delete [] theArray;

    theArray = newArray;

    upperbound = adjustedSize + lowerbound - 1;

}

 

void AbstractArray::setData( int loc, Object *data )

{

    PRECONDITION( loc >= lowerbound && loc <= upperbound );

    theArray[ zeroBase(loc) ] = data;

}

 

void AbstractArray::insertEntry( int loc )

{

    PRECONDITION( loc >= lowerbound && loc <= upperbound );

    memmove( theArray + zeroBase(loc) + 1,

             theArray + zeroBase(loc),

             (upperbound - loc)*sizeof( theArray[0] )

           );

}

 

void AbstractArray::removeEntry( int loc )

{

    if( loc >= lastElementIndex )

        theArray[zeroBase(loc)] = ZERO;

    else

        squeezeEntry( zeroBase(loc) );

}

 

void AbstractArray::squeezeEntry( int squeezePoint )

{

    PRECONDITION( squeezePoint >= 0 &&

                  squeezePoint <= zeroBase(lastElementIndex)

                );

 

    memmove( theArray + squeezePoint,

             theArray + squeezePoint + 1,

             (zeroBase(lastElementIndex)-squeezePoint)*sizeof( theArray[0] )

           );

        theArray[zeroBase(lastElementIndex)] = ZERO;

}

 

int AbstractArray::find( const Object& o )

{

    if( o == NOOBJECT )

        return INT_MIN;

 

    for( int index = 0; index < arraySize(); index++ )

        if( *(theArray[index]) == o )

            return boundBase(index);

    return INT_MIN;

}

 

inline int isZero( const Object *o )

{

    return o == &NOOBJECT;

}

 

int AbstractArray::isEqual( const Object& testObject ) const

{

    PRECONDITION( isA() == testObject.isA() );

    AbstractArray& test = (AbstractArray&)testObject;

    if( lowerbound != test.lowerbound || upperbound != test.upperbound )

        return 0;

 

    for( int i = 0; i < arraySize(); i++ )

        {

        if( isZero(theArray[i]) != isZero(test.theArray[i]) )

            return 0;

        if( *(theArray[i]) != *(test.theArray[i]) )

            return 0;

        }

    return 1;

}

 

ContainerIterator& AbstractArray::initIterator() const

{

    return *( (ContainerIterator *)new ArrayIterator( *this ) );

}

 

void AbstractArray::printContentsOn( ostream& outputStream ) const

{

    ContainerIterator& printIterator = initIterator();

    printHeader( outputStream );

    while( printIterator != 0 )

        {

        Object& arrayObject = printIterator++;

        if( arrayObject != NOOBJECT )

            {

            arrayObject.printOn( outputStream );

            if( printIterator != 0 )

                printSeparator( outputStream );

            else

                break;

            }

        }

    printTrailer( outputStream );

    delete &printIterator;

}

 

ArrayIterator::ArrayIterator( const AbstractArray& toIterate ) :

    beingIterated( toIterate ),

    currentIndex( toIterate.lowerbound )

{

    restart();

}

 

ArrayIterator::~ArrayIterator()

{

}

 

ArrayIterator::operator int()

{

    return currentIndex <= beingIterated.upperbound;

}

 

Object& ArrayIterator::current()

{

    if ( currentIndex <= beingIterated.upperbound )

        return beingIterated.objectAt( currentIndex );

    else

        return NOOBJECT;

}

 

void ArrayIterator::scan()

{

    if( currentIndex > beingIterated.upperbound )

        return;

 

    while( ++currentIndex <= beingIterated.upperbound &&

           beingIterated.objectAt( currentIndex ) == NOOBJECT )

        ;   // empty body

}

 

void ArrayIterator::restart()

{

    currentIndex = beingIterated.lowerbound;

    if( beingIterated.objectAt( currentIndex ) == NOOBJECT )

        scan();

}

 

Object& ArrayIterator::operator ++ ( int )

{

    Object& res = (currentIndex <= beingIterated.upperbound) ?

        beingIterated.objectAt( currentIndex ) : NOOBJECT;

 

    scan();

 

    return res;

}

Object& ArrayIterator::operator ++ ()

{

    scan();

    return (currentIndex <= beingIterated.upperbound) ?

        beingIterated.objectAt( currentIndex ) : NOOBJECT;

}

 


Related Discussions:- Abstract array - c program

Define the multi dimensional arrays, Define the Multi Dimensional Arrays? ...

Define the Multi Dimensional Arrays? Consequently far we have considered arrays with only one dimension. It is as well possible to define an array which is having a 2-dimension

Explain pure virtual functions, Pure Virtual Functions An abstract clas...

Pure Virtual Functions An abstract class is one, which is used just for deriving some other classes. No object of this class is declared and used in the program. Likewise, ther

Sums a sequence of integers, assume that the first integer read with cin sp...

assume that the first integer read with cin specifies the number of values remaining to be entered. that program should read only one value each time cin is executed .a typical inp

Setup and source code with nice user interface, Virtual Webcam effects - Se...

Virtual Webcam effects - Setup and Source code with Nice User Interface Project Description: I want a similar webcam effects application which can apply effects to webcam fee

Define some features of external storage class in c program, Define some fe...

Define some features of external storage class in c program? The features of an external storage class variable are as follows: Storage - memory Default initial value -

Demonstration using moss open source machine translation, Demonstration usi...

Demonstration using Moss Open Source Machine Translation Project Description: Moses is an open source Statistical Machine Translation System. I need someone to provide me a d

Explain about the variables in c language, Explain about the Variables in c...

Explain about the Variables in c language? The Variable is an identifier that is used to represent some specified kind of information within a designated portion of the program

Logic behind object oriented programming, In this we will take a closer loo...

In this we will take a closer look at the logic behind Object Oriented Programming.  Read through the pseudocode listed below and answer the following questions. Class Square

What do you meant by linear search, Question : (a) One of the most co...

Question : (a) One of the most common sorting techniques we have in programming is the ‘Bubble Sort'. This technique will be used to sort an array of elements in ascending or

String, A string is said to be "Beautiful"€, if it contains only non repet...

A string is said to be "Beautiful"€, if it contains only non repetitive alphabets

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