在 C++ ArrayList ADT 实现中尝试用更大的列表替换列表时出错

Question

我正在尝试向我的 ArrayList impl 添加重新分配逻辑，但出现此错误

将“std::__cxx11::basic_string [newSize]”分配给“std::__cxx11::basic_string [5]”时的类型不兼容

我尝试定义新数组以匹配旧数组

项目类型 new_items[5];

它给出了另一个错误

无效的数组赋值

这是 ArrayList 的 header 文件

//  Created by Frank M. Carrano and Tim Henry.
//  Copyright (c) 2013 __Pearson Education__. All rights reserved.

/** ADT list: Array-based implementation.
    Listing 9-1.
    @file ArrayList.h */

#ifndef _ARRAY_LIST
#define _ARRAY_LIST

#include "ListInterface.h"

#include <stdexcept>
#include <string>

using namespace std;

template<class ItemType>
class ArrayList : public ListInterface<ItemType>
{
private:
    static const int DEFAULT_CAPACITY = 5; // Small capacity to test for a full list 
    ItemType items[DEFAULT_CAPACITY];      // Array of list items
   int itemCount;                         // Current count of list items 
   int maxItems;                          // Maximum capacity of the list
   
public:
   ArrayList();
   // Copy constructor and destructor are supplied by compiler
   
   bool isEmpty() const;
   int getLength() const;
   bool insert(int newPosition, const ItemType& newEntry);
   bool remove(int position);
   void clear();
   
   ItemType getEntry(int position) const;

   void setEntry(int position, const ItemType& newEntry);

   bool swap(int i, int j);

   void reverse();

   void resize(int newSize);
}; // end ArrayList

#include "ArrayList.cpp"
#endif 

这是实现

//  Created by Frank M. Carrano and Tim Henry.
//  Copyright (c) 2013 __Pearson Education__. All rights reserved.

/** Implementation file for the class ArrayList.
 @file ArrayList.cpp */

#include "ArrayList.h"  // Header file
#include <iostream>
#include <cstring>

template<class ItemType>
ArrayList<ItemType>::ArrayList() : itemCount(0), maxItems(DEFAULT_CAPACITY)
{
}  // end default constructor

template<class ItemType>
bool ArrayList<ItemType>::isEmpty() const
{
   return itemCount == 0;
}  // end isEmpty

template<class ItemType>
int ArrayList<ItemType>::getLength() const
{
   return itemCount;
}  // end getLength

template<class ItemType>
bool ArrayList<ItemType>::insert(int newPosition, const ItemType& newEntry)
{
   bool ableToInsert = (newPosition >= 1) && (newPosition <= itemCount + 1);

   if (ableToInsert)
   {
      if (itemCount == maxItems) {
         resize(maxItems*2);
      }
      // Make room for new entry by shifting all entries at
      // positions >= newPosition toward the end of the array
      // (no shift if newPosition == itemCount + 1)
      for (int pos = itemCount; pos >= newPosition; pos--)
         items[pos] = items[pos - 1];
         
      // Insert new entry
      items[newPosition - 1] = newEntry;
      itemCount++;  // Increase count of entries
   }  // end if
   
   return ableToInsert;
}  // end insert

template<class ItemType>
bool ArrayList<ItemType>::remove(int position)
{
   bool ableToRemove = (position >= 1) && (position <= itemCount);
   if (ableToRemove)
   {
      // Remove entry by shifting all entries after the one at
      // position toward the beginning of the array
      // (no shift if position == itemCount)
      for (int fromIndex = position, toIndex = fromIndex - 1; fromIndex < itemCount;
            fromIndex++, toIndex++)
         items[toIndex] = items[fromIndex];
         
      itemCount--;  // Decrease count of entries
   }  // end if
   
   return ableToRemove;
}  // end remove

template<class ItemType>
void ArrayList<ItemType>::clear()
{
   itemCount = 0;
}  // end clear

template<class ItemType>
ItemType ArrayList<ItemType>::getEntry(int position) const
{
   // Enforce precondition
   bool ableToGet = (position >= 1) && (position <= itemCount);
   if (ableToGet)
      return items[position - 1];
   else
   {
      string message = "getEntry() called with an empty list or "; 
      message  = message + "invalid position.";
      return nullptr;
   }  // end if
}  // end getEntry

template<class ItemType>
void ArrayList<ItemType>::setEntry(int position, const ItemType& newEntry)
{
   // Enforce precondition
   bool ableToSet = (position >= 1) && (position <= itemCount);
   if (ableToSet)
      items[position - 1] = newEntry;
   else
   {
      string message = "setEntry() called with an empty list or "; 
      message  = message + "invalid position.";
   }  // end if
}  // end setEntry

template<class ItemType>
bool ArrayList<ItemType>::swap(int i, int j)
{
   if (i < 0 || j < 0 || i > itemCount || j > itemCount) {
      return false;
   }

   ItemType temp = items[i];
   items[i] = items[j];
   items[j] = temp;

   return true;
}  // end swap

template<class ItemType>
void ArrayList<ItemType>::reverse()
{
   for (int i = 0; i < itemCount/2; i++) {
      swap(i,itemCount-i-1);
   }
}

template<class ItemType>
void ArrayList<ItemType>::resize(int newSize)
{
   ItemType new_items[newSize];

   for (int i = 0; i < itemCount; i++) {
      new_items[i] = items[i];
   }

   items = new_items;
   maxItems = newSize;
}


//  End of implementation file.