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

Basic Programming Constructs, Write a program to print all the factors of a...

Write a program to print all the factors of a positive integer A

Define and explain flow chart with an example, C Programming and Data Struc...

C Programming and Data Structures 1. Define and explain flow chart with an example. 2. Write an algorithm to print all even numbers in descending order and draw the flowcha

Evaluate the credit worthiness of a client, Write a C++ program that can be...

Write a C++ program that can be used to evaluate the credit worthiness of a client. The program reads the credit limit and the price and quantity of the item to be purchased by the

C++ , a program to find the area under the curve y = f(x) between x = a and...

a program to find the area under the curve y = f(x) between x = a and x = b, integrate y = f(x) between the limits of a and b. The area under a curve between tw

Write a program to find the area under the curve y =, Write a program to fi...

Write a program to find the area under the curve y = f(x) between x = a and x = b, integrate y = f(x) between the limits of a and b.   #include float start_poin

Cpp, At a shop of marbles, packs of marbles are prepared. Packets are named...

At a shop of marbles, packs of marbles are prepared. Packets are named A, B, C, D, E …….. All packets are kept in a VERTICAL SHELF in random order. Any numbers of packets with thes

Can one create operator** for "to-the-power-of" operations?, A: no, can't. ...

A: no, can't. The names of, precedence of, associativity of, and arity of operators is fixed through the language. In C++, there is no operator** so you cannot create one for a

Define the data type modifiers in c language, Define the Data Type Modifier...

Define the Data Type Modifiers in C language? There are three data types(int, float & double) above have the following modifiers. 1. short 2. long 3. signed 4. unsigned

When should you employ multiple inheritance?, Q: When should you employ mul...

Q: When should you employ multiple inheritance? A:There  are  three  acceptable  answers:-  "Rarely," "Never," and  "while  the  problem  domain cannot be modeled accurately any

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