C++ 在模式的函数搜索中引用二维数组时出错 #包括 #包括 #包括 #包括 #包括 使用名称空间std； 模板 int搜索模式（int（&grid）[num\u rows][num\u cols]，int indexR，int indexC，int（&pattern）[patR][patC]）{ 对于（int m=0，i=indexR；mR>>C； 字符串*arry=新字符串[R]； int**int_arry=新int*[R]； 对于（int i=0；iws，arry[i]）；//cin>>ws去掉前导空格 //首先让getline不会认为它已经 //到达终点 //它似乎不接受上面的输入字符串 } 对于（int i=0；i

int\u arry

不是

int

s的二维数组。它是

int*

s的数组

这不是一回事

int[x][y]：

#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
#include <sstream>


using namespace std;

template <int num_rows, int num_cols, int patR, int patC>
int search_for_pattern(int (&grid)[num_rows][num_cols], int indexR, int indexC, int (&pattern)[patR][patC]){
    for(int m = 0, i = indexR; m < patR && i < num_rows; m++, i++){
        for(int n = 0, j = indexC; n < patC && j < num_cols; n++, j++){
            if(grid[i][j] != pattern[m][n]){
                return 0;
            }
        }
    }
    return 1;
}

int main(){


  int T;
        cin>>T;
    while(T--){
        int R, C;
        cin>>R>>C;
        string* arry = new string[R];
        int** int_arry = new int*[R];
        for(int i = 0; i < R; ++i)
            int_arry[i] = new int[C];

        for(int i = 0; i < R; i++){
           getline(cin>>ws, arry[i]); //cin >> ws gets rid of leading whitespace
                                       //first so that getline won't think that it's already
                                       //reached the end of the line
                                      //It doesn't seem to take the above input string
        }
       for(int i = 0; i < R; i++){
        for(int j = 0; j < arry[i].length(); j++){
            int_arry[i][j] = (int)(arry[i][j] - '0');
            //cout<<int_arry[i][j]<<" ";
        }
        //cout<<endl;
       }

        //Pattern Array input 
        int pattern_R, pattern_C;
        cin>>pattern_R>>pattern_C;

        string* pattern_arry = new string[pattern_R];
        int** int_pattern_arry = new int*[pattern_R];
        for(int i = 0; i < pattern_R; ++i)
            int_pattern_arry[i] = new int[pattern_C];

        for(int i = 0; i < pattern_R; i++){
           getline(cin>>ws, pattern_arry[i]); 
        }

        for(int i = 0; i < pattern_R; i++){
        for(int j = 0; j < pattern_arry[i].length(); j++){
            int_pattern_arry[i][j] = (int)(pattern_arry[i][j] - '0');
           // cout<<int_pattern_arry[i][j]<<" ";
        }
        //cout<<endl;
       }

        int flag = 0, patternTrue = 0;
        for(int i = 0; i <= R - pattern_R; i++){
            for(int j = 0; j <= C - pattern_C; j++){
                if(int_arry[i][j] == int_pattern_arry[i][j]){
                        flag = 1;
                        patternTrue = search_for_pattern(int_arry, i, j, int_pattern_arry);
                        if(patternTrue){
                            cout<<"YES";
                            break;
                        }
                    }
                }
            if(patternTrue) break;
            cout<<endl;

        }

        if(flag == 0){
            cout<<"NO";
        }

       //Delete Grid 
       for(int i = 0; i < R; ++i) {
        delete [] int_arry[i];
    }
    delete [] int_arry;
    delete [] arry;

        //Delete Pattern
        for(int i = 0; i < pattern_R; ++i) {
        delete [] int_pattern_arry[i];
    }
    delete [] int_pattern_arry;
    delete [] pattern_arry;
        cout<<endl;
   }
  return 0;
}

int（*）[y]

：

+-----+-----+-----+-----+-----+-----+
| int | int | int | int | int | int |
+-----+-----+-----+-----+-----+-----+
\___________/
 \    x
  \_________________________________/
                 y*x

正如你所看到的，这两者是完全不同的

---

如果您真的想要一个动态分配的“二维数组”，我建议使用一个大小为x×y的

std:：vector

，并将二维访问包裹在其周围。这会容易得多。

问题是您试图使用编译时未知的非常量值来初始化模板函数

模板总是在编译时创建的，所有必需的数据都必须在编译时可用

按以下方式调整搜索功能：

/                    \
+------+------+------+
| int* | int* | int* |
+------+------+------+
    |     |       ↓
    |     | +-----+-----+
    |     | | int | int |
    |     | +-----+-----+
    |     ↓
    | +-----+-----+
    | | int | int |
    | +-----+-----+
    ↓
+-----+-----+
| int | int |
+-----+-----+

int search_for_pattern(int** grid, int grid_rows, int grid_cols, int** pattern, int pat_rows, int pat_cols, int indexR, int indexC) {
    for (int m = 0, i = indexR; m < pat_rows && i < grid_rows; m++, i++) {
        for (int n = 0, j = indexC; n < pat_cols && j < grid_cols; n++, j++) {
            if (grid[i][j] != pattern[m][n]) {
                return 0;
            }
        }
    }
    return 1;
}

---

是的，但我想使用分配2d动态数组并取消分配它的概念。@Sitansu:您不能分配2d动态数组；至少，在运行时两个维度都确定的情况下是这样的。我知道在这里使用向量会更好。.我正在使用向量再次尝试这一点。谢谢！这一推理并不是问题的答案尽管如此，提议的准则是有效的（如果不是最优的）。

patternTrue = search_for_pattern(int_arry, R, C, int_pattern_arry, pattern_R, pattern_C, i, j);