C++数组类的问题

Question

好的，所以没有详细说明为什么我正在写这个类，在这里。

template<class aType> 
    class nArray 
    { 
    public: 
    aType& operator[](int i) 
    { 
    return Array[i]; 
    } 
    nArray() 
    { 
    aType * Array = new aType[0]; 
    _Size = 0; 
    _MaxSize = 0; 
    _Count = 0; 
    } 
    nArray(int Count) 
    { 
    aType * Array = new aType[Count*2](); 
    _Size = Count; 
    _MaxSize = Count * 2; 
    _Count = 0; 
    } 

    int Resize(int newSize) 
    { 
    aType *temp = new aType[newSize*2]; 
    for(int i=0;i<_Count;i++) 
    { 
    temp[i] = Array[i]; 
    } 
    delete[] Array; 
    aType * Array = new aType[newSize*2]; 
    for(int i=0;i<_Count;i++) 
    { 
    Array[i] = temp[i]; 
    } 
    delete [] temp; 
    _Size = newSize; 
    _MaxSize = newSize*2; 
    return 0; 
    } 
    int Push_Back(aType Item) 
    { 
    if(_Count+1 >= _Size) 
    { 
    Resize(_MaxSize); 
    } 
    Array[_Count] = Item; 
    _Count++; 
    return _Count - 1; 
    } 
    aType GetAt(int Index, int &ret) 
    { 
    if(Index > _Size-1) 
    ret = 1; 
    return aType(); 
    ret = 0; 
    return Array[Index]; 
    } 
    private: 
    int _Size; 
    int _Count; 
    int _MaxSize; 
    aType * Array; 
    }; 

它应该是一个std :: Vector类型的对象，没有所有的花里胡哨。 问题是，它似乎没有工作。

我基本上是去

nArray<string> ca = nArray<string>(5); 
ca.Push_Back("asdf"); 
ca.Push_Back("asdf2"); 
int intret = 0; 
cout << ca.GetAt(1,intret); 

开始我得到一个访问冲突读取位置错误，它击中的的push_back函数的行

Array[_Count] = Item 

。

问题似乎是它没有将Array对象视为内存中的数组。

我花了一段时间来逐步完成代码，我不知道还有什么要说的，它没有正确操作。我不知道该怎么说。我只是希望有人会阅读我的代码，并指出我犯了一个愚蠢的错误，因为我确信这就是它的全部内容。 更新 所以，现在我改变了nArray（），nArray（诠释计数）数组的初始化3，并调整其大小（INT新尺寸）

template<class aType> 
    class nArray 
    { 
    public: 
     aType& operator[](int i) 
     { 
      return Array[i]; 
     } 
     nArray() 
     { 
      Array = new aType[0]; 
      _Size = 0; 
      _MaxSize = 0; 
      _Count = 0; 
     } 
     nArray(int Count) 
     { 
      Array = new aType[Count*2](); 
      _Size = Count; 
      _MaxSize = Count * 2; 
      _Count = 0; 
     } 

     int Resize(int newSize) 
     { 
      aType *temp = new aType[newSize*2]; 
      for(int i=0;i<_Count;i++) 
      { 
       temp[i] = Array[i]; 
      } 
      delete[] Array; 
      Array = new aType[newSize*2]; 
      for(int i=0;i<_Count;i++) 
      { 
       Array[i] = temp[i]; 
      } 
      delete [] temp; 
      _Size = newSize; 
      _MaxSize = newSize*2; 
      return 0; 
     } 
     int Push_Back(aType Item) 
     { 
      if(_Count+1 >= _Size) 
      { 
       Resize(_MaxSize); 
      } 
      Array[_Count] = Item; 
      _Count++; 
      return _Count - 1; 
     } 
     aType GetAt(int Index, int &ret) 
     { 
      if(Index > _Size-1) 
       ret = 1; 
       return aType(); 
      ret = 0; 
      return Array[Index]; 
     } 
    private: 
     int _Size; 
     int _Count; 
     int _MaxSize; 
     aType * Array; 
    }; 

这是我的代码怎么回事了。无论如何，最初的问题是，当我尝试访问数组中的特定元素时，它只是访问第一个元素，并且它似乎没有添加元素eather。它似乎并不把Array当作一个数组。

Answer 1

int Resize(int newSize) 
    { 
    . 
    . 
    aType * Array = new aType[newSize*2]; 

在这一点上，而不是更新的成员变量如你意，你实际上已经创建了一个名为数组，其值是从调整大小（）丢弃在退出时局部变量。将该行更改为

Array = new aType[newSize*2]; 

同样的事情发生在您的构造函数中，它们也需要相应地改变。而且，由于默认的构造函数分配了一个数组，所以你应该相应地设置成员的大小。你有太多的这些：一个数组需要跟踪当前元素数量和最大容量，但是你似乎有三个成员。第三个目的是什么？冗余信息不好，它使代码难以阅读，没有单一的事实说明就容易犯错误。

使用Resize（）中的代码，您可以做得更好：第二个副本完全是多余的。

int Resize(int newSize) 
    { 
    aType *temp = new aType[newSize*2]; 
    for(int i=0;i<_Count;i++) 
    { 
    temp[i] = Array[i]; 
    } 
    delete[] Array; 
    Array = temp; 
    _Size = newSize; 
    _MaxSize = newSize*2; 
    return 0; 
    } 

此外，在

aType GetAt(int Index, int &ret) 
     { 
      if(Index > _Size-1) 
       ret = 1; 
       return aType(); 
      ret = 0; 
      return Array[Index]; 
     } 

你需要周围的，如果（），只是对自己的缩进身体大括号不会做的伎俩：

aType GetAt(int Index, int &ret) 
     { 
      if(Index > _Size-1) 
      { 
       ret = 1; 
       return aType(); 
      } 
      ret = 0; 
      return Array[Index]; 
     } 

Answer 2

你有一些问题。据猜测，目前导致问题的原因是您的默认ctor（nArray::nArray()）定义了一个本地变量，它初始化为Array，这会使nArray::Array未初始化。

虽然你可能还没有看到它的任何症状，但你至少还有一个问题。名称以下划线开头，后跟大写字母（例如您的_Size,_MaxSize和_Count）被保留用于执行 - 即您不允许使用它们。

Resize中的逻辑看起来效率不高（如果不彻底破坏），虽然考虑到时间也许这只是我的大脑在这个早晨的这个小时不能正常工作。

Answer 3

您的数组是而不是由构造函数初始化并调整resize函数（改为使用局部变量）。

是否有你想要存储字符串的实例，而不是指向字符串（字符串*）指针的原因？

Answer 4

我想更改后的答案是在月影的回复中：

aType GetAt(int Index, int &ret) 
    { 
     if(Index > _Size-1) 
      ret = 1; 
      return aType(); 
     ret = 0; 
     return Array[Index]; 
    } 

此代码将始终为return aType()，最后两行永远不会到达。

你可能还想检查一下如果你从一个默认构造的nArray开始会发生什么。 （提示：你叫Resize(_MaxSize);但什么是_MaxSize在这种情况下，值

---

编辑： 这个输出“asdf2”对我来说，它应该是（与初始化和支架固定）：

template<class aType> 
class nArray 
{ 
public: 
    aType& operator[](int i) 
    { 
     return Array[i]; 
    } 
    nArray() 
    { 
     Array = new aType[0]; 
     _Size = 0; 
     _MaxSize = 0; 
     _Count = 0; 
    } 
    nArray(int Count) 
    { 
     Array = new aType[Count*2](); 
     _Size = Count; 
     _MaxSize = Count * 2; 
     _Count = 0; 
    } 

    int Resize(int newSize) 
    { 
     aType *temp = new aType[newSize*2]; 
     for(int i=0;i<_Count;i++) 
     { 
      temp[i] = Array[i]; 
     } 
     delete[] Array; 
     Array = new aType[newSize*2]; 
     for(int i=0;i<_Count;i++) 
     { 
      Array[i] = temp[i]; 
     } 
     delete [] temp; 
     _Size = newSize; 
     _MaxSize = newSize*2; 
     return 0; 
    } 
    int Push_Back(aType Item) 
    { 
     if(_Count+1 >= _Size) 
     { 
      Resize(_MaxSize); 
     } 
     Array[_Count] = Item; 
     _Count++; 
     return _Count - 1; 
    } 
    aType GetAt(int Index, int &ret) 
    { 
     if(Index > _Size-1) { 
      ret = 1; 
      return aType(); 
     } 
     ret = 0; 
     return Array[Index]; 
    } 
private: 
    int _Size; 
    int _Count; 
    int _MaxSize; 
    aType * Array; 
}; 

#include <string> 
#include <iostream> 
using namespace std; 

int main() 
{ 
    nArray<string> ca = nArray<string>(5); 
    ca.Push_Back("asdf"); 
    ca.Push_Back("asdf2"); 
    int intret = 0; 
    cout << ca.GetAt(1,intret); 
}