Question

Data Structures and Algorithms C++:

I'm having a hard time getting my main.cpp part of the source code (shown below) to output the following:

Inserting elements to array list:
The list contains
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Deleting elements:

The list contains:

2 4 6 8 10 12 14 16 18 20 22 24

this is a programming problem in chapter 9 (exercise 3) from the Data Abstraction and Problem Solving with C++ (7th Edition).

Any suggestion are highly appreciated! :)

SOURCE CODE:

main.cpp

#include "MyArrayList.cpp"
#include
#include
using namespace std;

// Method to display the listPtr.
void displayMyList(MyArrayList* lstPtr)
{
   // Display message.
   cout << "The list contains " << endl;
   // Use loop to display all the elements.
   for (int pp = 1; pp <= lstPtr->getListCurrentSize(); pp++)
   {
       // display the current element
       cout << lstPtr->getItemByPos(pp) << " ";
   }
   // output new line.
   cout << endl;
}

// main()
int main()
{
   // Create array list.
   MyArrayList mylist;

   // Display message.
   cout<<"Inserting elements to array list: ";
   // Declare string array of data.
   string data1[] = {"1","2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25"};
  
   // Use loop to insert elements.
   for(int kk=0;kk<25;kk++)
   {
       // Call addListElement().
       mylist.addListElement(kk+1,data1[kk]);
       // Call displayMyList().
       displayMyList(&mylist);
       // Display message.
   }
   cout<<"\n\nDeleting elements:"<< endl;
      
   // Use loop to delete elements.
   for(int kk=1;kk<=15;kk++)
   {
       // Call deleteByPos().
       mylist.deleteByPos(kk);
       // Call displayMyList().
       displayMyList(&mylist);
       // Pause output.
       system("pause");
       // Stop.
       return 0;
   }
}

MyArrayList.cpp

// Implementation code for the class MyArrayList.
#include "MyArrayList.h"

// Constructor to set the aryItemCnt and maxItemCap to default values.
template
MyArrayList::MyArrayList()
{
   // Set aryItemCnt to 0.
   aryItemCnt = 0;
   // Set maxItemCap to 0.
   maxItemCap = 5;
   // Allocate memory.
   arrayItems = new ItemType[maxItemCap];
}

// Method outputs true if the list is clear.
template
bool MyArrayList::checkEmpty() const
{
   // Check condition and return the result.
   return aryItemCnt == 0;
}

// Method outputs the number of elements in the list.
template
int MyArrayList::getListCurrentSize() const
{
   // Return the aryItemCnt value.
   return aryItemCnt;
}

// Method outputs true if the newItem is added to the list at newPos.
template
bool MyArrayList::addListElement(int newPos, const ItemType& newItem)
{
   // Check array is full.
   if(aryItemCnt == maxItemCap)
   {
       // On condition success, expand the size.
       expandCapacity();
   }
   // Check newPos is valid.
   bool canAdd = (newPos >= 1) && (newPos <= aryItemCnt + 1);
   // If newPos is valid.
   if (canAdd)
   {
       // Use loop to make space for newItem.
       for (int pp = aryItemCnt; pp >= newPos; pp--)
       {
           // Move elements towards array end.
           arrayItems[pp] = arrayItems[pp - 1];
           // Place the newItem at newPos.
           arrayItems[newPos - 1] = newItem;
           // Increase the aryItemCnt by 1.
           aryItemCnt++;
       }
   }
   // return the canAdd.
   return canAdd;
}

// Method outputs true if element at elementPos is deleted from the list.
template
bool MyArrayList::deleteByPos(int elementPos)
{
   // Check elementPos is valid.
   bool canDelete = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canDelete)
   {
       // Use loop to remove element at elementPos.
       for (int aa = elementPos, bb = aa - 1; aa < aryItemCnt; aa++, bb++)
       // Move elements towards array beginning.
       arrayItems[bb] = arrayItems[aa];
       // Decrease the aryItemCnt value by 1.
       aryItemCnt--;
       // Check condition.
       if(maxItemCap>20 && aryItemCnt<(maxItemCap/2))
       // Call reduceCapacity().
       reduceCapacity();
   }
   // Return the canDelete.
   return canDelete;
}

// Method removes all the elements in the list.
template
void MyArrayList::clearList()
{
   // Set aryItemCnt to 0.
   aryItemCnt = 0;
}

// Method outputs item at the elementPos.
template
ItemType MyArrayList::getItemByPos(int elementPos) const
{
   //check if elementPos is valid.
   bool canGet = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canGet)
   {
       // Return the item at the elementPos.
       return arrayItems[elementPos - 1];
   }
   // If elementPos is not valid,
   else
   {
       // Throw the exception.
       throw std::invalid_argument("Element Position is not valid.");
   }
}

// Method sets the newItem at the given elementPos.
template
void MyArrayList::setItemByPos(int elementPos, const ItemType& newItem)
{
   // Check elementPos is valid.
   bool canSet = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canSet)
   // Set the newItem at elementPos.
   arrayItems[elementPos - 1] = newItem;
   // If elementPos is not valid,
   else
   {
       // Throw the exception.
       throw std::invalid_argument("Element Position is not valid.");
   }
}

// Method that expands the array.
template
void MyArrayList::expandCapacity()
{
   // Double the maxItemCap.
   maxItemCap = 2 * maxItemCap;
   // create tp.
   ItemType *tp = new ItemType[maxItemCap];
   // use loop to copy the array items.
   for (int kk = 0; kk < aryItemCnt; kk++)
   {
       // Copy the current item.
       tp[kk]=arrayItems[kk];
       // Delete arrayItems.
       delete[] arrayItems;
       // Update the arrayItems.
       arrayItems = tp;
   }
}

// Method to reduce the array size.
template
void MyArrayList::reduceCapacity()
{
   // Reduce the maxItemCap.
   maxItemCap = 3 * (maxItemCap/4);
   // Create tp.
   ItemType *tp = new ItemType[maxItemCap];
   // Use loop to copy the array items.
   for(int kk = 0; kk < aryItemCnt; kk++)
   {
       // Copy the current item.
       tp[kk]=arrayItems[kk];
       // Delete arrayItems.
       delete[] arrayItems;
       // Update the arrayItems.
       arrayItems = tp;
   }
}

MyArrayList.h

#ifndef MYARRAYLIST_H
#define MYARRAYLIST_H
#include "MyArrayListInterface.h"
#include "stdexcept"

// declare class MyArrayList
template
class MyArrayList : public MyArrayListInterface
{
private:
   // this itemtype function declares an array of ItemType.
   ItemType *arrayItems;
   // this int function declares aryItemCnt (array item count).
   int aryItemCnt;
   // this int function declares maxItemCap (maximum item capacity).
   int maxItemCap;
   // this void function expands the array.
   void expandCapacity();
   // this void function reduces the array size.
   void reduceCapacity();

public:
   // this is our default constructor.
   MyArrayList();
   // this boolean function outputs true if the list is clear.
   bool checkEmpty() const;
   // this int function outputs the number of elements in the list.
   int getListCurrentSize() const;
   // this boolean function outputs true if the newItem is added to the list at newPos.
   bool addListElement( int newPos, const ItemType& newItem);
   // this boolean function outputs true if element at position is deleted from the list.
   bool deleteByPos( int elementPos);
   // this void function removes all the elements in the list.
   void clearList();
   // this class itemtype function outputs item at the position.
   ItemType getItemByPos( int elementPos) const;
   // this void function sets the newItem at the given position.
   void setItemByPos( int elementPos, const ItemType& newItem);

   // End of MyArrayList.
};

#endif

MyArrayListInterface.h

#ifndef MYARRAYLISTINTERFACE_H
#define MYARRAYLISTINTERFACE_H

// declare class MyArrayListInterface
template
class MyArrayListInterface
{
public:
   //this boolean function outputs true if the list is clear.
   bool checkEmpty() const;
   //this int function outputs the number of elements in the list.
   int getListCurrentSize() const;
   //this boolean function outputs true if the newItem is added to the list at newPos.
   bool addListElement( int newPos, const ItemType& newItem);
   //this boolean function outputs true if element at position is deleted from the list.
   bool deleteByPos( int elementPos);
   //this void function removes/clears all the elements in the list.
   void clearList();
   //this class type function outputs item at the position.
   ItemType getItemByPos( int elementPos) const;
   //this void function sets the newItem at the given position.
   void setItemByPos( int elementPos, const ItemType& newItem);

   // End of MyArrayListInterface.
};

#endif

Answer 1

First you don't need MyArrayListInterface to be base class of MyArrayList class. you are duplicating all the public functions so interface is useless.

Second you have problem in every for loop. see my code how to end { }. you also need to provide template argument for class functions.

see the changes i made in code and compare with previous code. if you still have any problem or doubt, let me know. thank you.

====================================

MyArrayList .h

====================================

#ifndef MYARRAYLIST_H
#define MYARRAYLIST_H
#include "stdexcept"

// declare class MyArrayList
template <typename ItemType>
class MyArrayList
{
private:
   // this itemtype function declares an array of ItemType.
   ItemType* arrayItems;
   // this int function declares aryItemCnt (array item count).
   int aryItemCnt;
   // this int function declares maxItemCap (maximum item capacity).
   int maxItemCap;
   // this void function expands the array.
   void expandCapacity();
   // this void function reduces the array size.
   void reduceCapacity();

public:
   // this is our default constructor.
   MyArrayList();
   // this boolean function outputs true if the list is clear.
   bool checkEmpty() const;
   // this int function outputs the number of elements in the list.
   int getListCurrentSize() const;
   // this boolean function outputs true if the newItem is added to the list at newPos.
   bool addListElement(int newPos, const ItemType& newItem);
   // this boolean function outputs true if element at position is deleted from the list.
   bool deleteByPos(int elementPos);
   // this void function removes all the elements in the list.
   void clearList();
   // this class itemtype function outputs item at the position.
   ItemType getItemByPos(int elementPos) const;
   // this void function sets the newItem at the given position.
   void setItemByPos(int elementPos, const ItemType& newItem);

   // End of MyArrayList.
};

#endif

===================================

MyArrayList .cpp

===================================

// Implementation code for the class MyArrayList.
#include "MyArrayList.h"
#include <iostream>
using namespace std;

// Constructor to set the aryItemCnt and maxItemCap to default values.
template <typename ItemType>
MyArrayList<ItemType>::MyArrayList()
{
   // Set aryItemCnt to 0.
   aryItemCnt = 0;
   // Set maxItemCap to 0.
   maxItemCap = 5;
   // Allocate memory.
   arrayItems = new ItemType[maxItemCap];
}

// Method outputs true if the list is clear.
template <typename ItemType>
bool MyArrayList<ItemType>::checkEmpty() const
{
   // Check condition and return the result.
   return aryItemCnt == 0;
}

// Method outputs the number of elements in the list.
template <typename ItemType>
int MyArrayList<ItemType>::getListCurrentSize() const
{
   // Return the aryItemCnt value.
   return aryItemCnt;
}

// Method outputs true if the newItem is added to the list at newPos.
template <typename ItemType>
bool MyArrayList<ItemType>::addListElement(int newPos, const ItemType& newItem)
{
   // Check array is full.
   if (aryItemCnt == maxItemCap)
   {
       // On condition success, expand the size.
       expandCapacity();
   }
   // Check newPos is valid.
   bool canAdd = (newPos >= 1) && (newPos <= (aryItemCnt + 1));
   // If newPos is valid.
   if (canAdd)
   {
       // Use loop to make space for newItem.
       for (int pp = aryItemCnt; pp >= newPos; pp--)
       {
           // Move elements towards array end.
           arrayItems[pp] = arrayItems[pp - 1];
       }
       // Place the newItem at newPos.
       arrayItems[newPos - 1] = newItem;
       // Increase the aryItemCnt by 1.
       aryItemCnt++;
   }
   // return the canAdd.
   return canAdd;
}

// Method outputs true if element at elementPos is deleted from the list.
template <typename ItemType>
bool MyArrayList<ItemType>::deleteByPos(int elementPos)
{
   // Check elementPos is valid.
   bool canDelete = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canDelete)
   {
       // Use loop to remove element at elementPos.
       for (int aa = elementPos, bb = aa - 1; aa < aryItemCnt; aa++, bb++)
           // Move elements towards array beginning.
           arrayItems[bb] = arrayItems[aa];
       // Decrease the aryItemCnt value by 1.
       aryItemCnt--;
       // Check condition.
       if (maxItemCap > 20 && aryItemCnt < (maxItemCap / 2))
           // Call reduceCapacity().
           reduceCapacity();
   }
   // Return the canDelete.
   return canDelete;
}

// Method removes all the elements in the list.
template <typename ItemType>
void MyArrayList<ItemType>::clearList()
{
   // Set aryItemCnt to 0.
   aryItemCnt = 0;
}

// Method outputs item at the elementPos.
template <typename ItemType>
ItemType MyArrayList<ItemType>::getItemByPos(int elementPos) const
{
   //check if elementPos is valid.
   bool canGet = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canGet)
   {
       // Return the item at the elementPos.
       return arrayItems[elementPos - 1];
   }
   // If elementPos is not valid,
   else
   {
       // Throw the exception.
       throw std::invalid_argument("Element Position is not valid.");
   }
}

// Method sets the newItem at the given elementPos.
template <typename ItemType>
void MyArrayList<ItemType>::setItemByPos(int elementPos, const ItemType& newItem)
{
   // Check elementPos is valid.
   bool canSet = (elementPos >= 1) && (elementPos <= aryItemCnt);
   // If elementPos is valid,
   if (canSet)
       // Set the newItem at elementPos.
       arrayItems[elementPos - 1] = newItem;
   // If elementPos is not valid,
   else
   {
       // Throw the exception.
       throw std::invalid_argument("Element Position is not valid.");
   }
}

// Method that expands the array.
template <typename ItemType>
void MyArrayList<ItemType>::expandCapacity()
{
   // Double the maxItemCap.
   maxItemCap = 2 * maxItemCap;
   // create tp.
   ItemType* tp = new ItemType[maxItemCap];
   // use loop to copy the array items.
   for (int kk = 0; kk < aryItemCnt; kk++)
   {
       // Copy the current item.
       tp[kk] = arrayItems[kk];
   }
   // Delete arrayItems.
   delete[] arrayItems;
   // Update the arrayItems.
   arrayItems = tp;
}

// Method to reduce the array size.
template <typename ItemType>
void MyArrayList<ItemType>::reduceCapacity()
{
   // Reduce the maxItemCap.
   maxItemCap = 3 * (maxItemCap / 4);
   // Create tp.
   ItemType* tp = new ItemType[maxItemCap];
   // Use loop to copy the array items.
   for (int kk = 0; kk < aryItemCnt; kk++)
   {
       // Copy the current item.
       tp[kk] = arrayItems[kk];
   }
   // Delete arrayItems.
   delete[] arrayItems;
   // Update the arrayItems.
   arrayItems = tp;
}

===================================

main.cpp

===================================

#include "MyArrayList.cpp"
#include <iostream>
using namespace std;

// Method to display the listPtr.
template <typename ItemType>
void displayMyList(MyArrayList<ItemType>* lstPtr)
{
   // Display message.
   cout << "The list contains " << endl;
   // Use loop to display all the elements.
   for (int pp = 1; pp <= lstPtr->getListCurrentSize(); pp++)
   {
       // display the current element
       cout << lstPtr->getItemByPos(pp) << " ";
   }
   // output new line.
   cout << endl;
}

// main()
int main()
{
   // Create array list.
   MyArrayList<int> mylist;

   // Display message.
   cout << "Inserting elements to array list: ";
  
   // Use loop to insert elements.
   for (int kk = 0; kk < 25; kk++)
   {
       // Call addListElement().
       mylist.addListElement(kk + 1, kk + 1);
   }
   // Call displayMyList().
   displayMyList(&mylist);
  
   // Display message.
   cout << "\n\nDeleting elements:" << endl;

   // Use loop to delete elements.
   for (int kk = 1; kk <= 15; kk++)
   {
       // Call deleteByPos().
       mylist.deleteByPos(kk);
   }
   // Call displayMyList().
   displayMyList(&mylist);
   // Pause output.
   system("pause");
   // Stop.
  
   return 0;
}