在类中使用动态数组——编译时接收错误

评论中回答的问题 因为我的声誉，我无法以常规方式回答。我稍后会在回答中补充细节，已经在评论中提到了。谢谢**

大家好-

毫无疑问，你会在这个问题上看到，我是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&);
};