Question

如何将Dynamic Safe 2D数组类修改为Dynamic Safe 2D锯齿状数组类？我读过一篇文章，最好使用动态安全或动态安全2D数组，以避免初始化小于0的数组或大于其原始大小的数组。大多数时候，我们会遇到过度递归这样的问题，例如使用回溯来找到迷宫的路径。因此，我试图实现动态安全的2D锯齿状数组类，但我不知道该如何实现？

//Dynamic Safe 2D array class 
template <class T> 

class DS2DA 
{ 
  private: 
    T **Data; 
    int nRow; 
    int nCol; 

public: 

DS2DA () 
{ 
    nRow=0; 
    nCol=0;
    Data=nullptr; 
} 

DS2DA (int nRow,int nCol) 
{ 
    this->nRow=nRow; 
    this->nCol=nCol; 
    Data=new T * [nRow]; 

    for (int i=0;i<nRow;i++) 
    { 
        Data[i]=new T [nCol];
    }

    for (int i=0;i<nRow;i++) 
    { 
        for (int j=0;j<nCol;j++) 
        { 
            Data[i][j]=0; 
        }
    }
} 

T & operator () (int n1,int n2)   
{ 
    if ((n1<0 or n1>this->nRow) or (n2<0 or n2>this->nCol)) 
    { 
        cout<<"Array out of bound";
        exit (1); 
    } 

    else 
        return (Data[n1][n2]); 
 } 

};

//Driver Program 

int main () 
{
  DS2DA <double> obj1 (3,3); 
  int input; 

  for (int i=0;i<3;i++) 
  { 
    cout<<"Row "<<i+1<<endl; 

    for (int j=0;j<3;j++)
    { 
        cout<<"Enter Element "<<j+1<<":";
        cin>>input;
        obj1 (i,j)=input; 
    }
  } 
}

Answer 1

我非常确定我会遗漏这点，但是正如Swordfish在他的评论中所写，包含std::vector的{{1}}应该可以解决问题。

如果您想要一个二维数组，其宽度和高度限制会动态增长，请尝试以下代码：

std::vector

数组始终以没有任何行或列开始，但有行/列限制（在默认构造函数中设置为0）。

两个（）运算符基本上都执行相同的操作：检查行和列索引并返回相应的单元格。但是，虽然非const operator（）调整锯齿状数组的大小以容纳给定元素，但const operator（）只是返回对空（默认构造）项目的引用。因此，在遍历数组时，您不必不必要地构造所有丢失的项。

根据使用情况，也许以坐标对作为索引的unordered_map会给您带来更好的结果。您可以使用template<class T> class DynamicArray { public: DynamicArray() : rowCount(0), colCount(0) {} DynamicArray(size_t rowCount_, size_t colCount_) : rowCount(rowCount_), colCount(colCount_) {} const T& operator()(size_t row, size_t col) const { if (row >= rowCount || col >= colCount) throw std::out_of_range("Row or column index out of range in " __FUNCTION__); static const T empty; if (data.size() <= row) return empty; const auto& rowData = data[row]; if (rowData.size() <= col) return empty; return rowData[col]; } T& operator()(size_t row, size_t col) { if (row >= rowCount || col >= colCount) throw std::out_of_range("Row or column index out of range in " __FUNCTION__); if (data.size() <= row) data.resize(row + 1); auto& rowData = data[row]; if (rowData.size() <= col) rowData.resize(col + 1); return rowData[col]; } public: std::vector<std::vector<T>> data; size_t rowCount, colCount; };进行声明。一对整数应该产生非常快速的哈希函数。如果阵列非常稀疏，这将是我的首选解决方案。

请注意，如果您不使用Visual Studio，则可能需要调整std::unordered_map<std::pair<int, int>, T>的使用。（在gcc __FUNCTION__中扩展为一个返回函数名称的函数，而Visual Studio将其扩展为包含当前函数名称的字符串）。

C ++中的动态安全2D锯齿状阵列

1 个答案: