Question

gt+ without errors or warnings, using the standard flags described in tutorial, namely -Wall -pedantic. Use of String class or other object-oriented code (except for cin or cout and related file-stream objects, which are allowed) will result in a flat deduction of 25%. (That means: don't use advanced techniques to avoid learning the concepts we are attempting to teach you!) Exercise 3 Implement the revised Array based List ADT (19 pts) In Assignment 3 Exercise 1, you were asked to modify the design of the Array based List. In this exercise you will implement and test the revised Array based List. Start from the provided files ArrayList,h, ArrayList.cc, Element,h, and a7q3.cc. These files contain a partial implementation of the Array based List ADT and some tests. In particular, there are only 6 operations provided: createList, destroyList, emptyList, lengthList, insertTail, and deleteTail. This was specifically done to reduce the amount of work required for this question. You do not need to implement the other List operations we have studied in the lectures. Following your pseudocode design from Assignment 3 Exercise 1, modify the Array based List to remove the fixed capacity limit by modifying createlist, and insertTail and adding a growList operation. 1. 2.

a7q3.cc File

#include <iostream>
#include <cstring>
#include "ArrayList.h"

using namespace std;

// Algorithm copy(s)
// Pre: s :: refToChar
// Post: memory allocated on heap to store a copy
// Return: reference to new string

char *copy(char *s) {
char *temp = new char[strlen(s)+1];
strcpy(temp,s);
return temp;
}

void test_ListOperations(){
  
cout << "testing createList" << endl;
  
List *myList = createList(10);
  
if (myList == NULL){
cout << "createList failed" << endl;
return;
} else{
cout << "createList succeeded" << endl;
}

cout << "testing destroyList" << endl;
destroyList(myList);
cout << "testing destroyList succeeded" << endl;

cout << "testing emptyList with an empty list" << endl;
myList = createList(10);
if (! emptyList(myList)){
cout << "testing emptyList failed when an empty list was given"<< endl;
return;
}

cout << "testing lengthList with an empty list" << endl;
if (lengthList(myList) != 0){
cout << "an empty list should have length 0" << endl;
return;
}

cout << "inserting an element at the tail of the list" << endl;
char firstElement[] = "first";
char *toInsert = copy(firstElement);
if (!(insertTail(myList, toInsert))){
cout << "insertTail failed to insert first element" << endl;
return;
}

if (emptyList(myList)){
cout << "testing emptyList failed when a non-empty list was given"<< endl;
return;
}

if (lengthList(myList) != 1){
cout << "A list with 1 element should have length 1"<< endl;
return;
}

cout << "inserting a second element at the tail of the list" << endl;
char secondElement[] = "second";
toInsert = copy(secondElement);
if (!(insertTail(myList, toInsert))){
cout << "insertTail failed to insert second element" << endl;
return;
}

if (emptyList(myList)){
cout << "testing emptyList failed when a non-empty list was given"<< endl;
return;
}

if (lengthList(myList) != 2){
cout << "A list with 2 elements should have length 2"<< endl;
return;
}

cout << "deleting the tail of the list (going from 2 to 1 elements in the list)" << endl;
char * retrievedValue;
deleteTail(myList, &retrievedValue);
if (strcmp(retrievedValue, secondElement) != 0){
cout << "wrong value returned when deleting tail of the list" << endl;
return;
}
delete []retrievedValue;

if (emptyList(myList)){
cout << "testing emptyList failed when a non-empty list was given"<< endl;
return;
}

if (lengthList(myList) != 1){
cout << "A list with 1 element should have length 1"<< endl;
return;
}

cout << "deleting the tail of the list (going from 1 to 0 elements in the list)" << endl;
deleteTail(myList, &retrievedValue);
if (strcmp(retrievedValue, firstElement) != 0){
cout << "wrong value returned when deleting tail of the list" << endl;
return;
}
delete []retrievedValue;
  
if (!emptyList(myList)){
cout << "testing emptyList failed when a non-empty list was given"<< endl;
return;
}

if (lengthList(myList) != 0){
cout << "A list with 0 elements should have length 0"<< endl;
return;
}

char words[][6] = {"one", "two", "three", "four", "five", "six",
"seven", "eight", "nine", "ten"};
cout << "inserting 10 elements" << endl;
for(int i = 0; i < 10; i++){
toInsert = copy(words[i]);
insertTail(myList, toInsert);
}

cout << "deleting 10 elements" << endl;
cout << "should print the words ten nine eight ... one" << endl;
for(int i = 0; i < 10; i++){
deleteTail(myList, &retrievedValue);
cout << retrievedValue << endl;
delete []retrievedValue;
}

destroyList(myList);
cout << "testing list operations complete!" << endl;
}

int main(){
  
test_ListOperations();
cout << "testing complete!" << endl;
return 0;
}

ArrayList.cc File

// Implementation of an array-based List ADT
// Michael Horsch and Ian McQuillan, for CMPT115 2012 WT2, March 2013
// Modified by Craig Thompson for CMPT115/117 WT2 2015
//
// This is only a partial implementation of the List ADT.

#include "ArrayList.h"
#include <cstring>
#include <iostream>

using namespace std;

// CONSTRUCTOR and DESTRUCTOR
// create a new empty list of specified size.
// pre: size is the desired maximum capacity of the list.
// returns: a pointer to newly created List, or NULL if List could not be created.
List *createList(int size) {
List *l = new List;
if (l == NULL) {
return NULL;
}
l->data = new Element[size];
if (l-> data == NULL){
delete l;
return NULL;
}
l->capacity = size;
l->count = 0;
return l;
}

// destroy an existing list
// pre: a pointer to a List
// post: deallocates List . Does not deallocate contents! (may cause a memory leak)
void destroyList(List* l) {
delete [] l->data;
delete l;
}

// STATUS
// check whether the list is empty
// pre: a pointer to a List.
// returns: true if List is empty, false otherwise.
bool emptyList(List* l) {
return (0 == l->count);
}

// STATUS
// check whether the list is empty
// pre: a pointer to a List.
// returns: true if List is empty, false otherwise.
bool fullList(List* l) {
return (l->capacity == l->count);
}

// return the number of elements in the list
// pre: a pointer to the List.
// returns: number of elements in the List.
int lengthList(List* l) {
return l->count;
}

// insert the element into the list at the end of the list
// pre: a pointer to a List, and an element to insert.
// post: the Element is placed in the List as long as long as the list is not full.
// returns: true if successful, false otherwise.
bool insertTail(List* l, Element e) {
if (fullList(l)) {
return false;
} else {
l->data[l->count] = e;
l->count++;
return true;
}
}

// delete the element at the end of the list
// pre: a pointer to a list, and a pointer to an Element
// post: if list is non-empty, it removes the last element, and deallocates memory
// associated with deleted element.
// returns: true if it deleted something, false otherwise.
bool deleteTail(List* l, Element *e) {
if (emptyList(l)) {
return false;
} else {
*e = l->data[l->count-1];
l->count--;
return e;
}
}

// eof

ArrayList.h File

//
// Data structure for List ADT, where the data stored are pointers to Elements
//
// Michael Horsch and Ian McQuillan, for CMPT115 2012 WT2, March 2013
//

#include "Element.h"

#ifndef _LIST_H_
#define _LIST_H_

// a list contains a pointer to the head node and a count
struct List {
Element *data;
int count;
int capacity;
};

//
// the List Operations
//

// CONSTRUCTOR and DESTRUCTOR
// create a new empty list of specified size.
// pre: size is the desired maximum capacity of the list.
// returns: a pointer to newly created List, or NULL if List could not be created.
List *createList(int size);

// destroy an existing list
// pre: a pointer to a List
// post: deallocates List. Does not deallocate contents! (may cause a memory leak)
void destroyList(List*);

// STATUS
// check whether the list is empty
// pre: a pointer to a List.
// returns: true if List is empty, false otherwise.
bool emptyList(List*);

// return the number of elements in the list
// pre: a pointer to the List.
// returns: number of elements in the List.
int lengthList(List*);

// insert the element into the list at the end of the list
// pre: a pointer to a List, and a pointer to an existing Element.
// post: the Element is placed in the List as long as the list is not full.
// returns: true if successful, false otherwise.
bool insertTail(List*, Element);

// delete the element at the end of the list
// pre: a pointer to a list, and a pointer to an Element
// post: if list is non-empty, it removes the last element, and deallocates memory
// associated with deleted element.
// returns: true if it deleted something, false otherwise.
bool deleteTail(List* l, Element *e);

#endif

Element.h File

//
// Element.h
// - define what type gets stored in list nodes
//
// MCH for CMPT115 2015 WT2
// Minor modifications for 2014 (mch)
//

#ifndef _ELEMENT_H_
#define _ELEMENT_H_

//change this depending upon what we want to store
typedef char * Element;

#endif