关于多维数组的 C++ 问题

Question

我的 C++ 技能生疏了，但我试图帮助我儿子完成作业，如果很简单，请原谅我。

我正在尝试查找数组中某个元素的所有邻居，并查看该特定元素是否大于其所有邻居。

 #include <iostream>
using namespace std;
 
int row2(int arr[][3], int n){
  cout << "row2";
    if (arr[1][n] > arr[0][n] && arr[1][n] > arr[0][1] && arr[1][n] > arr[1][1] && arr[1][n] > arr[2][1] && arr[1][n] > arr[2][n]){
      return true;
    }
    else 
      return false;


}
int row3(int arr[][3], int n){
  cout << "row3==n";
  cout << n;
  if (n == 0 || n == 2){
    
    if (arr[3][n] > arr[1][n] && arr[3][n] > arr[3][1] && arr[3][n] > arr[1][1]){
      cout << "row3 if";
      return true;
    }
    else 
     cout << "row3 else";
      return false;
  }
  else{
    if (arr[3][1] > arr[3][2] && arr[3][1] > arr[3][0] && arr[3][1] > arr[1][2] && arr[3][1] > arr[1][0] && arr[3][1] > arr[1][1]){
      return true;
    }
    else 
      return false;

  }
}

编译时我在这行 val = arr[counterx] [counter];预期的 lambda 表达式主体 val4 = arr[val2], [val3];

任何指针？

提前致谢！

Answer 1

显示的代码有几个错误和错误。语法错误和逻辑错误。

void findit(int arr[], int sizey, int sizex)

这将第一个参数声明为普通的花园品种数组。只是一个一维数组。此数组中的典型值可能是arr[0]，或arr[1]，或者如果x 是某个整数变量，则可能是arr[x]。但是，在这个函数中：

 val = arr[counterx] [counter];

这会尝试访问arr，就像它是一个二维数组一样，而不是：arr[something][somethingelse]。那将是一个二维数组，而 arr 被声明为一维数组。

在您的main 中声明一个

  int arr[3][3] 

这是一个二维数组，但随后将其传递给findit：

   findit(arr, m,n);

然而，正如我们刚刚发现的，findit 的第一个参数不是二维数组，而是一维数组。很明显findit的arr应该声明为二维数组。

但是，在 C++ 中，无法将二维数组传递给 C++ 函数，其中未指定第一维和第二维。 C++ 不能以这种方式工作。在数组参数规范中，在 C++ 中，只有 first 数组维度可以不指定。必须指定第二个和 all 以下维度。例如，您可以声明：

 void findit(int arr[][3], int sizey, int sizex)

这将允许您传递ints 的任何二维数组，只要第二维为 3。但是传递两个 size 参数是没有意义的。只需要显式传入第一个维度的大小，因为第二个维度的大小是已知的。

最后：

 val4 = arr[val2], [val3];

不清楚这是什么，但这不是有效的 C++ 语法。如果您打算使用给定的索引访问此二维数组中的元素，则适当的语法为：

 val4 = arr[val2][val3];

这解决了所示代码中的基本编译错误。不幸的是，显示的代码中有很多很多明显的逻辑问题。比如其中一个逻辑问题：

 val = arr[counterx] [counter];

如果您检查前面的 for 循环，您会发现：

 for (int counterx = -1; counter <= sizex; counter++){

所以，counterx 变量将从 -1 开始迭代，所以上面似乎会尝试评估：

 val = arr[-1][counter];

在 C++ 中，没有数组在负索引偏移处具有值，因此上述逻辑将导致未定义的行为和无意义的结果。如果您有任何类型的数组，例如x[]，您可能会在x[0] 和x[1] 找到一些东西，但在x[-1] 找不到。这同样适用于多维数组。

这是第一个肉眼明显的逻辑错误，这里可能还有更多。总体而言，所示代码中的方法有些不清楚。您可能会从退后一步重新设计此任务的整体方法中受益，因为显示的逻辑在几个基本方面似乎并没有正确地处理它。

Answer 2

lambda 表达式的预期主体 val4 = arr[val2], [val3];

这行val4 = arr[val2], [val3]; 似乎有语法错误，而不是您在问题中提到的那个。

我假设你的意思是写 val4 = arr[val2][val3]; 不带逗号。

话虽如此，val2 和 val3 的值被分配了相同的值，如果未选中，可能会导致索引越界异常。此外，从 -1 开始 counter 和 counterx 会导致越界异常。

此外，如果不将多维数组作为双指针传递或对大小进行硬编码，则无法将多维数组传递给函数。

---

编辑 1： 我整理了一个解决方案来查找每行中的最大数量。它不是最优化的代码，但它快速且有效。我假设行，列大小可能会改变，所以我使用 std::vector 而不是 std:array 或原始数组。但是，如果您知道可以将 int[3][3] 硬编码到您的解决方案中，则可以恢复。

#include <iostream>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>
 
void findit(std::vector<std::vector<int>> arr){  
  for (size_t rowsIndex = 0; rowsIndex <= arr.size(); rowsIndex++){
    std::vector<int> row = arr[rowsIndex];
    int maxNum = *std::max_element(row.begin(), row.end());

    std::cout<< "largest num in row " << rowsIndex << ": " << maxNum << std::endl;
  }
}

int main(){
  std::vector<std::vector<int>> arr;
  arr.push_back({0, 1, 2 });
  arr.push_back({4, 5, 6 });
  arr.push_back({8, 9, 10});
  
  findit(arr);
}

---

编辑 2：

如果你想检查一个目标索引与相邻的索引，没有必要使用 forloop。只有 4（或 8）个可能的缺陷需要检查，只是更容易（和有效）对它们进行硬编码：

#include <iostream>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>

void checkIfIndexIsLargestInItsAdjacency(std::vector<std::vector<int>> arr, size_t targetRow, size_t targetColumn){
    int targetNumber = arr[targetRow][targetColumn];
    int numberToTheLeft = targetColumn > 0 ? arr[targetRow][targetColumn-1] : 0;
    int numberToTheRight = targetColumn + 1 < arr[targetRow].size() ? arr[targetRow][targetColumn+1] : 0;
    int numberToTheUp = targetRow > 0 ? arr[targetRow-1][targetColumn] : 0;
    int numberToTheDown = targetRow + 1 < arr.size() ? arr[targetRow+1][targetColumn] : 0;
    std::cout<< "targetNumber: " << targetNumber << std::endl;
    std::cout<< "Number to the left: " << numberToTheLeft << std::endl;
    std::cout<< "Number to the right: " << numberToTheRight << std::endl;
    std::cout<< "Number to the up: " << numberToTheUp << std::endl;
    std::cout<< "Number to the down: " << numberToTheDown << std::endl;
    
    std::array<int, 4> adjacentNumbers = {numberToTheLeft, numberToTheRight, numberToTheUp, numberToTheDown};
    int maxAdjacentNum = *std::max_element(adjacentNumbers.begin(), adjacentNumbers.end());
    
    std::cout << "Target number is " << (maxAdjacentNum >= targetNumber? "smaller" : "bigger") << " than adjacent numbers" << std::endl;
}

int main(){
  std::vector<std::vector<int>> arr;
  arr.push_back({0, 1, 2 });
  arr.push_back({4, 5, 6 });
  arr.push_back({8, 9, 10});
  
  checkIfIndexIsLargestInItsAdjacency(arr, 1, 1);
  checkIfIndexIsLargestInItsAdjacency(arr, 2, 2);
}

示例输出：

targetNumber: 5
Number to the left: 4
Number to the right: 6
Number to the up: 1
Number to the down: 9
Target number is smaller than adjacent numbers
targetNumber: 10
Number to the left: 9
Number to the right: 0
Number to the up: 6
Number to the down: 0
Target number is bigger than adjacent numbers