Question

我已创建了一个函数，并希望此函数返回一个二维指针数组。但是我尝试了很多方法，编译器只是给了我错误。这是我的功能，cell是我定义的类。现在我只给出函数void type。

 void CreatePuzzle (int nRows, int nColumns, int minVal, int maxVal)
{
    //initialize the puzzle
    cell *Puzzle[nRows][nColumns];

    for (int i = 0; i < nRows; i++)
    {
         for(int j=0; j < nColumns; j++)
         {
            Puzzle[i][j] = new cell(i,j);

         }
    }
}

Answer 1

这不是您问题的直接答案，但它可能会有所帮助：请考虑使用现代C ++。

请考虑以下代码：

#include <iostream>                                                                                       
#include <vector>                                                                                         

class Cell {                                                                                              
 public:                                                                                                  
  Cell(int value = 0)                                                                                     
      : m_value(value) { }                                                                                
  int value() const {                                                                                     
    return m_value;                                                                                       
  }                                                                                                       
  void value(int value) {                                                                                 
    m_value = value;                                                                                      
  }                                                                                                       
 private:                                                                                                 
  int m_value;                                                                                            
};                                                                                                        

class Puzzle {                                                                                            
 public:                                                                                                  
  Puzzle(int rows, int cols)                                                                              
      : m_cells(rows * cols),                                                                             
        m_rows(rows),                                                                                     
        m_cols(cols) {                                                                                    
    // for now let's assume we just give them a sequential value                                          
    int value = 0;                                                                                        
    for(auto & cell : m_cells) {                                                                          
      cell.value(value++);                                                                                
    }                                                                                                     
  }                                                                                                       

  Cell& cell(int row, int col) {                                                                          
    return m_cells[row * m_cols + col];                                                                   
  }                                                                                                       

 private:                                                                                                 

  std::vector<Cell> m_cells;                                                                              
  int m_rows;                                                                                             
  int m_cols;                                                                                             
};                                                                                                        

int main(int argc, char* argv[]) {                                                                        
  if(argc != 3) {                                                                                         
    std::cerr << "usage: " << argv[0] << " rows cols" << std::endl;                                       
    return 1;                                                                                             
  }                                                                                                       

  int rows = std::stoi(argv[1]);                                                                          
  int cols = std::stoi(argv[2]);                                                                          

  Puzzle puzzle(rows, cols);                                                                              

  for(int row = 0; row < rows; ++row) {                                                                   
    for(int col = 0; col < cols; ++col) {                                                                 
      std::cout << puzzle.cell(row, col).value() << " ";                                                  
    }                                                                                                     
    std::cout << std::endl;                                                                               
  }                                                                                                       
}

这是一个过度简化，但你（希望）得到了这个想法：我有一个Cell类，其唯一目的是保存一个值（在本例中是一个整数）。然后我创建了一个由N-by-M单元组成的游戏。

游戏的构造函数明确声明：*创建一个游戏，我需要你提供行数和列数。“在内部，它将所有单元格放在std::vector中，并提供一个以（行，列）方式访问该线性排列的公共方法。您只需自己“跨步”数组。

希望它可以向您展示一个更加惯用的C ++会是什么样子。它无论如何都不是完美的代码，但它是一个开始。

我在OS X 10.7.4上使用GCC 4.8.1编译了代码：

g++ game.cpp -std=c++11

示例会话：

./a.out 3 5
0 1 2 3 4 
5 6 7 8 9 
10 11 12 13 14

另一场会议：

./a.out 2 10
0 1 2 3 4 5 6 7 8 9 
10 11 12 13 14 15 16 17 18 19

请注意，我从不必担心分配/释放或内存泄漏：它全部由std::vector管理。

Answer 2

这是一个带有2d矢量的替代方案：

vector<vector<cell>> CreatePuzzle(int nRows, int nColumns, int minVal, int maxVal)
{
    //initialize the puzzle
    vector<vector<cell>> Puzzle(nRows, vector<cell>(nColumns));

    for (int i = 0; i < nRows; i++)
    {
        for (int j = 0; j < nColumns; j++)
        {
            Puzzle[i][j] = cell (i,j);
        }
    }
    return Puzzle; 
}

如何在c ++中返回一个2d指针数组

2 个答案: