如何通过引用 C++ 中的函数传递二维数组

Question

如何在函数dfs中传递数组b1，b1是一个二维整型数组，用于跟踪节点是否被访问过。抱歉代码可读性差。我想通过引用传递它，因为它需要由名为 recursively.Currently 的函数修改，得到这个错误。

Line 33: Char 94: error: 'b1' declared as array of references of type 'int &'
    void dfs(int i,int j,vector<vector<char>>& board,string word,int k,bool& yellow,int& b1[][]){
                                                                                             ^
1 error generated.

class Solution {
public:
    
    bool exist(vector<vector<char>>& board, string word) {
        int m = board.size();
        int n = board[0].size();
        int b1[m][n];
        list<pair<int,int>> mp;
        bool yellow=false;
        for(int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
                if(board[i][j]==word[0]){
                    mp.push_front({i,j});
                }
            }
        }
        
        for(auto itr=mp.begin();itr!=mp.end();itr++){
            int i=itr->first;
            int j=itr->second;
            
            dfs(i,j,board,word,0,yellow,b1);
            if(yellow==true){
                
                return yellow;
            }
            memset(b1,0,sizeof(b1));
           
        }
        return yellow;
    }
    void dfs(int i,int j,vector<vector<char>>& board,string word,int k,bool& yellow,int& b1[][]){
        int m = board.size()-1;
        int n = board[0].size()-1;
        b1[i][j]=1;
        if(k==word.size()-1){
            yellow=true;       
        }
        
        if(i+1<=m && board[i+1][j]==word[k+1] &&b1[i+1][j]==0){
            dfs(i+1,j,board,word,k+1,yellow,b1);
        }
        if(i-1>=0 && board[i-1][j]==word[k+1] &&b1[i-1][j]==0){
            dfs(i-1,j,board,word,k+1,yellow,b1);
        }   
        if(j+1<=n && board[i][j+1]==word[k+1]&& b1[i][j+1]==0){
            dfs(i,j+1,board,word,k+1,yellow,b1);
        }
        if(j-1>=0 && board[i][j-1]==word[k+1] && b1[i][j-1]==0){
            dfs(i,j-1,board,word,k+1,yellow,b1);
        }
        
        
    }
};

Answer 1

由于您已经使用 vector<vector<char>>& board 作为一个参数，因此修复此错误的最简单方法是使用 vector<vector<int>> b1 而不是 int b1[m][n]。

请注意像int a[n][m]这样的VLA，它不容易维护，也不推荐。在 Why aren't variable-length arrays part of the C++ standard?.

查看更多信息

这是我用 2D vector 替换 b1 的示例。

class Solution {
public:

    bool exist(vector<vector<char>> &board, string word) {
        int m = board.size();
        int n = board[0].size();
//        int b1[m][n];
        vector<vector<int>> b1(m, vector<int>(n, 0));

        list<pair<int, int>> mp;

        bool yellow = false;
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (board[i][j] == word[0]) {
                    mp.push_front({i, j});
                }
            }
        }

        for (auto itr = mp.begin(); itr != mp.end(); itr++) {
            int i = itr->first;
            int j = itr->second;

            dfs(i, j, board, word, 0, yellow, b1);
            if (yellow == true) {

                return yellow;
            }

//            memset(b1, 0, sizeof(b1));
            for (auto &row: b1) {
                std::fill(row.begin(), row.end(), 0);
            }
        }
        return yellow;
    }

//    void dfs(int i,int j,vector<vector<char>>& board,string word,int k,bool& yellow,int& b1[][]){
    void dfs(int i, int j, vector<vector<char>> &board, string word, int k, bool &yellow, vector<vector<int>> &b1) {
        int m = board.size() - 1;
        int n = board[0].size() - 1;
        b1[i][j] = 1;
        if (k == word.size() - 1) {
            yellow = true;
        }

        if (i + 1 <= m && board[i + 1][j] == word[k + 1] && b1[i + 1][j] == 0) {
            dfs(i + 1, j, board, word, k + 1, yellow, b1);
        }
        if (i - 1 >= 0 && board[i - 1][j] == word[k + 1] && b1[i - 1][j] == 0) {
            dfs(i - 1, j, board, word, k + 1, yellow, b1);
        }
        if (j + 1 <= n && board[i][j + 1] == word[k + 1] && b1[i][j + 1] == 0) {
            dfs(i, j + 1, board, word, k + 1, yellow, b1);
        }
        if (j - 1 >= 0 && board[i][j - 1] == word[k + 1] && b1[i][j - 1] == 0) {
            dfs(i, j - 1, board, word, k + 1, yellow, b1);
        }
    }

};

Answer 2

您要从 GNU 转向更严格的 C++ 编译器吗？

GNU 历史上允许传递具有 run-time 可变维度的二维数组。不记得确切的语法，您可能需要将 M、N 声明为参数，以便编译器知道维度来自哪里。

这是一个古老的 FORTRAN 技巧，很多人要求 C++ 也应该拥有它，所以 GNU 自己做了（他们也有 FORTRAN 编译器，所以这也是互操作性的问题）。 C99 standard 也更改为允许它 => C++ 现在是一只孤独的跛脚鸭。

如果您确实在使用 GNU，请深入了解如何声明它，但请记住它不会构建在其他 C++ 风格上。

哦，您不需要对 int 的引用数组。数组始终是 (implicit/hidden) 指针（也称为引用）。整个参考狂潮来自数组在历史上被“特权”为无需 * 即可访问的指针。请记住，引用是 self-dereferencing 指针 => 你刚刚声明了一个指针数组 - 隐藏:-)

当在相同范围内声明普通引用及其用法时，编译器知道如何优化隐藏指针方面，但如果您跨越函数调用边界，它们必须作为指针。如果你将它们隐藏在数组中，编译器必须放弃 - 但它有充分的权利尖叫，因为引用数组是概念上的废话，你不会初始化它们 => 如果编译器允许它们，它们将都是空炸弹。

注意：在 C++20 中，您可以“重新分配”一个引用，但不是显式的——仅作为较大对象 self-mut(il)ation 的一部分（不要在家里尝试 :-) .

如何通过引用 C++ 中的函数传递二维数组

How to pass a 2D array by Reference to a function in C++

c++

arrays

multidimensional-array