Csc 340 Midterm

What to do and what not to do.

models of how it could be done

Objects combine data and operations

Classes inherit properties from other classes

Objects determine appropriate operations at execution.

Cohesive modules perform single well-defined tasks. Good for:
1)Self-documenting

2)Easy to revise

3)Easy to reuse

Coupling is a measure of depedence among modules. In other words:

1)Loosely coupled modules desired

2)Independence

3)If module fails, all dependent modules will fail

4)Objects should collaborate

1)Documentation

2)Specifies data flow

3)Does not need to specify the task

4)Remember pre and post conditions

Failed?

Garbage in, garbage out logic!

1)Seperates purpose of a module from its implementation

2)Use without concern about the implementation

3)What not how

4)Sort

1)What does the problem require?

2)What operations are required to be executed on the data?

1)Get size of bag

2)Check if bag is empty

3)Add object to bag

4)Remove an object

etc...

getCurrentSize()

isEmpty()

add(newEntry: ItemType): boolean

remove(anEntry: ItemType): boolean

clearn (): void

getFrequencyOf(anEntry: itemType): integer

contains(anEntry: ItemType): boolean

toVector(): vector

Enter Interlude 1 classes

Uniform Modelling Language

Accessor is a get, mutator is a set.

ItemType getItem() const;

void setItem(const ItemType& theItem);

#ifndef _CLASS

#define _CLASS

//code

#endif

a member function that you expect to be redefined in derived classes. In other words, polymorphism.

Always have one or more virtual methods and cannot be instantiated.

RECURSION: The Mirrors

Breaking larger problems into smaller ones, such is life.

Base

Stack, popped

WallsMirros CHP 3 PPT

A collection of data and a set of operations on that data

What an ADT does, but not how its implemented

Track array elements used, figure out how methods are to be incorporated.

bool roomtoadd = (itemCount<maxItems);

if(roomtoadd){

items[itemCount]=newEntry;
itemCount++;
}
return roomtoadd;

vector<ItemType> bagContents;
for(int i=0;i<itemCount;i++)

bagContents.push_back(items[i]);
return bagContents;

1)return itemCount;

2)return itemCount==-0;

int freq=0;

int curidx=0;
while(curidx<itemCount){

if(items[curidx]==anEntry){
freuq++;
}
curIndex++;

}
return freq;

bool isFound=false;
int curIndex=0;
while(!isFound&&(curIndex<itemCount)){
isFound=(anEntry==items[curIndex]);
if(!isFound)
curIndex++;
}
return isFound;

bool isFound=false;

int results=-1;
int searchIndex=0;
while(!isFound && (searchinedex<itemCount)){
isFound=(items[searchIndex]==target);
if(!isFound)

result=searchIndex;

else

searchIndex++;
}
return result;

int locatedIndex=getindexOf(anEntry);
bool canRemoveItem= !isEmpty() && (locatedIndex>-1);
if(canRemoveItem)
{

itemCount--;

items[locatedIndex]=items[itemCount];
}
return canRemoveItem;

itemCount=0;

int result=-1;

if(searchIndex<itemCount)

{

if(items[searchIndex]==target)

result=searchIndex;

else
result=getindexOf(target, searchIndex+1);

}
return result;

if(searchIndex<itemCount)
{
if(items[searchIndex]==target)
return 1+countFrequency(target,searchIndex+1);
else
return countFrequncy(target, searchIndex+1);
}
else
return 0;

int frequency=0;
if(searchIndex<itemCount)
{
if(items[searchIndex]==target)
frequency =1+countFrequency(target,searchIndex+1);
else
frequency =countFrequency(target,searchIndex+1);
} // end if
} // end if
return frequency

MY MIND IS MELTING

Set a deleted pointer to null and making sure that declared pointers have a value

Declare methods in base class as virtual.

int size=50;

doublt *anArray=new double[size];

delete [] anArray;

for(int i=0;i<arraySize;i++)
anArray[i]=oldArray[i];

delete [] oldArray;

bool hasRoomToAdd = (itemCount < maxItems);
if(!hasRoomToAdd)
{
ItemType* oldArray = items;

items= new ItemType[2*max];
for(int i=0;i<max;i++)

items[i]=oldArray[i];

delete [] oldArray;

max=2*max;

}
items[itemCount]=newEntry;

itemCount++;

return true;

objects

item =anItem;

next=nextNodePtr;

return item;

return next;

getCurrentSize()
isEmpty()
add(newEntry: ItemType): boolean
remove(anEntry: ItemType): boolean
clear(): void
getFrequencyOf(anEntry: ItemType): integer
contains(anEntry: ItemType): boolean
toVector(): vector

Nothing to see here...

Node<ItemType>* newNodePtr= new Node<ItemType>();
newNodePtr->setItem(newEntry);
newNodePtr->setNext(headPtr);
headPtr=newNodePtr;
itemCount++;

return true;

Visits each node in a linked chain

std::vector<ItemType> bagContents;
Node<ItemType>* curPtr= headPtr;
int counter=0;
while((curPtr!=nullptr)&&(counter<itemCount))
{
bagContents.push_back(curPtr->getItem());
curPtr=curPtr->getNext();
counter++;
}
return bagContents;

a