Использование динамического массива внутри класса Получение ошибки во время компиляции

ВОПРОС ОТВЕЧЕН В КОММЕНТАРИЯХ Из-за моей репутации я не могу ответить на него обычным образом. Позже я добавлю подробности в ответ, уже рассмотренный в комментариях. Спасибо.**

Всем привет -

Как вы, несомненно, увидите, основываясь на вопросе, я новичок в C++, но имею опыт работы с некоторыми языками более высокого уровня. (что, кажется, больше вредит, чем помогает)

Для класса мне нужно создать оболочку для массива, типизированного целыми числами. (На этом этапе класса нет шаблонов) Мне также нужно разрешить классу иметь ненулевой начальный индекс. Я использую массив элементов в классе для хранения своих данных (в этой точке класса пока нет векторов) и выполняю некоторый перевод из общедоступных методов для доступа к соответствующему внутреннему элементу массива.

Проблема, с которой я сталкиваюсь, заключается в том, что я не знаю размер внутреннего массива во время компиляции, поэтому я объявляю его как глобальный указатель класса и устанавливаю размер в конструкторе. Фрагмент кода находится ниже в проблемной области:

int *list;
safeArray::safeArray(int start, int initialSize)
{
    if(initialSize <= 0)
    {
        throw "Array size must be a positive integer";
    }
    maxSize = initialSize + 1;
    startIndex = start;
    endIndex = start + initialSize;
    list = new int[maxSize];    // Error thrown here
    int *tempArray = new int[maxSize];
    copyArray(tempArray);
    clearArray();   
}

Ошибка, которую я получаю,

Incompatible types in assignment of 'int*' to 'int[0u]'

Я не уверен на 100%, что такое тип int[0u]. Это буквальное значение ноль, а u для беззнакового? Я проверил в отладчике, что maxSize содержит значение, а также заменил его постоянным целочисленным значением и получил ту же ошибку.

Поскольку моя строка int *tempArray = new int[maxSize]; работала, я подумал, что это может быть связано с необходимостью одновременного объявления и размера, поэтому я решил сделать memcpy. (Что на самом деле выходит за рамки задания, поэтому должно быть что-то еще, что я упускаю) Memcpy терпит неудачу, потому что кажется, что я затираю свои другие переменные. Когда я печатаю адрес списка в GDB, он дает мне тот же адрес, что и другая глобальная переменная в моем коде, поэтому этот маршрут также казался выходящим за рамки назначения.

Общая тема, которую я видел на других форумах, заключается в том, что вы не можете назначать массивы, как другие переменные, но я не думал, что это будет включать оператор new. Я ошибаюсь в этом предположении?

Единственные ошибки компиляции, которые я сейчас вижу, это та, что указана выше, и я вижу ее для каждого оператора list = new int[maxSize]; в коде.

Мои вопросы:

1. Что такое тип int[0u] и где этот тип генерируется? Это должно быть из нового заявления, верно?

2. Как лучше всего использовать ресурс динамического массива внутри класса? Помимо использования вектора? знак равно

Я думаю, что это вся необходимая информация, но прошу прощения, если пропустил важную часть данных. Ниже приведен оставшийся код реализации.

/*
 *  safeArray.cpp
 *  safearray
 *
 *  Created by Jeffery Smith on 6/1/11.
 *  
 *
 */

#include "safeArray.h"
#include <iostream>


using namespace std;


    int startIndex = 0;
    int endIndex = 0;
    int maxSize = 1;
    int currentSize = 0;
    int *list;

safeArray::safeArray(int start, int initialSize)
{
    if(initialSize <= 0)
    {
        throw "Array size must be a positive integer";
    }
    maxSize = initialSize + 1;
    startIndex = start;
    endIndex = start + initialSize;
    list = new int[maxSize];    // Error thrown here
    int *tempArray = new int[initialSize + 1];
    copyArray(tempArray);
    clearArray();

}

safeArray::safeArray(const safeArray &sArray)
{
    list = new int[sArray.maxSize];
    copyArray(sArray);
    startIndex = sArray.startIndex;
    endIndex = sArray.endIndex;
    maxSize = sArray.maxSize;
    currentSize = sArray.currentSize;
}

void safeArray::operator=(const safeArray &right)
{
    list = new int[right.maxSize];
    copyArray(right);
    startIndex = right.startIndex;
    endIndex = right.endIndex;
    maxSize = right.maxSize;
    currentSize = right.currentSize;
}

safeArray::~safeArray()
{
    delete [] list;
}



int safeArray::operator[](int index)
{
    if(OutofBounds(index))
    {
        throw "You tried to access an element that is out of bounds";
    }
    return list[index - startIndex];
}

void safeArray::add(int value)
{
    if(this->isFull())
    {
        throw "Could not add element. The Array is full";
    }
    currentSize++;
    list[currentSize + startIndex];
}

void safeArray::removeAt(int value)
{
    if(OutofBounds(value))
    {
        throw "The requested element is not valid in this list";
    }
    compressList(value);
    currentSize--;
}

void safeArray::insertAt(int location, int value)
{
    if(OutofBounds(location) || this->isFull())
    {
        throw "The requested value is either out of bounds or the list is full";
    }
    expandList(location, value);
    currentSize++;
}


void safeArray::clearList()
{
    clearArray();
}

bool safeArray::isFull()
{
    return(maxSize == currentSize);
}

int safeArray::length()
{
    return currentSize;
}

int safeArray::maxLength()
{
    return this->maxSize;
}

bool safeArray::isEmpty()
{
    return(currentSize == 0);
}

bool safeArray::OutofBounds(int value)
{
    return (value > endIndex || value < startIndex);
}

void safeArray::clearArray()
{
    for(int i = 0; i < maxSize; i++)
    {
        list[i] = 0;
    }
    currentSize = 0;
}

void safeArray::compressList(int value)
{
    for(int i = value; i < endIndex; i++)
    {
        list[i] = list[i + 1];
    }
}

void safeArray::expandList(int location, int value)
{
    int tempHolder = list[location];
    list[location] = value;
    for(int i = location; i < endIndex; i++)
    {
        tempHolder = list[location];
        list[location] = value;
        value = tempHolder;
    }
}

void safeArray::copyArray(int *srcAddr )
{

    memcpy(list, srcAddr, sizeof(int) * maxSize);

}

void safeArray::copyArray(const safeArray &sArray)
{

    memcpy(list, &sArray, sizeof(int) * maxSize);

}

Вот определение заголовка:

/*
 *  safeArray.h
 *  safearray
 *
 *  Created by Jeffery Smith on 6/1/11.
 *  Copyright 2011 Accenture. All rights reserved.
 *
 */



class safeArray {

public:
    safeArray(int,int);    //Standard constructor
    ~safeArray();          //Destructor
    int operator[](int);
    void operator=(const safeArray&);   //Assignment overload
    safeArray(const safeArray &sArray); //Copy Constructor

    void add(int);
    int maxLength();
    int length();
    bool isFull();
    bool isEmpty();
    void clearList();
    void removeAt(int);
    void insertAt(int,int);

protected:
    int list[];
    int startIndex;
    int endIndex;
    int maxSize;
    int currentSize;

private:
    void clearArray();
    bool OutofBounds(int);
    void expandList(int,int);
    void compressList(int);
    void copyArray(int*);
    void copyArray(const safeArray&);
};