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

#change to palidrome program, #A palindrome is a string that reads the same...

#A palindrome is a string that reads the same from both the ends. Given a string S convert it to a palindrome by doing character replacement. Your task is to convert S to palindrom

Where php basically used, Why many companies are switching their current bu...

Why many companies are switching their current business language to PHP? Where PHP basically used? PHP is rapidly gaining popularity and numerous companies are switching their

Graphics, demonstrates shearing about origin

demonstrates shearing about origin

My program, palindrome program with minimum character replacements

palindrome program with minimum character replacements

Sort wars, Explain each of the algorithms in a way that would be understand...

Explain each of the algorithms in a way that would be understandable to an intelligent person who is not familiar with programming. You should not use any code (or even pseudo code

Explain the #undef directive, The #undef Directive This directive undef...

The #undef Directive This directive undefines a previously explained macro. For, example the following will give an error since PI is undefined.                 #define PI 3

Creates and implements a class to represent the queue, Purpose This ass...

Purpose This assignment is an exercise in implementing the queue ADT using a singly-linked list. This assignment also introduces the concept of templates. Assignment Th

Explain object conversions, Object Conversions Just like initialization...

Object Conversions Just like initialization, conversions are also done automatically when an object of a derived class is assigned to an object of the base class. Though, the c

Optimize and profile a c++ library for speed, Optimize and Profile a C++ li...

Optimize and Profile a C++ library for speed Project Description:  Optimize and Profile an existing C++ library for speed. This library uses OpenMP and OpenCV and C++ stan

Program is to read the characters from keyboard, Program is to read the cha...

Program is to read the characters from keyboard: Program is to read the characters from keyboard one by one stored in different files as upper constants, lower constants, othe

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