C++ question regarding multidimensional array - c++

Question

My C++ skills are rusty but trying to help my son with his assignment so pardon me if its very simple.
I am trying to find all of the neighbors of an element in array and seeing if that particular element is larger than all of its neighbors.
#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;
}
}
When compiling I get an error in this line val = arr[counterx] [counter]; expected body of lambda expression
val4 = arr[val2], [val3];
Any pointers?
Thanks in advance!

Answer 1

The shown code has several bugs, and errors. Both syntax errors and logical errors.
void findit(int arr[], int sizey, int sizex)
This declares the first parameter to be a plain, garden variety array. Just a one dimensional array. Typical values in this array, that you might found would be arr[0], or arr[1], or maybe arr[x] if x was some integer variable. But then, in the this function:
val = arr[counterx] [counter];
this tries to access arr as if it was a two-dimensional array, instead: arr[something][somethingelse]. That would be a two-dimensional array, while the arr is declared as a one-dimensional array.
In your main you declare a
int arr[3][3]
which is a two-dimensional array, but then pass it to findit:
findit(arr, m,n);
However, as we've just discovered, the first parameter to findit is not a two-dimensional array, but a one dimensional array. It's clear that findit's arr should be declared as a two-dimensional array.
However there is no way, in C++, to pass a two-dimensional array to a C++ function, with unspecified first and second dimension. C++ does not work this way. In an array parameter specification, in C++, only the first array dimnension can be left unspecified. The 2nd, and all following dimensions must be specified. You could, for example, declare:
void findit(int arr[][3], int sizey, int sizex)
That would allow you to pass any two-dimensional array of ints, as long as the 2nd dimension is 3. But then passing both size parameters is meaningless. It is only necessary to explicitly pass in the size of the first dimension, since the size of the second dimension is already known.
Finally:
val4 = arr[val2], [val3];
It is unclear what this is, but this is not a valid C++ syntax. If you meant to access an element in this two-dimensional array, using the given indices, the appropriate syntax would be:
val4 = arr[val2][val3];
This addresses the fundamental compilation errors in the shown code. Unfortunately there are many, many obvious logical problems in the shown code. For example, one of the logical problems:
val = arr[counterx] [counter];
If you inspect the preceding for loops, you will discover that:
for (int counterx = -1; counter <= sizex; counter++){
So, the counterx variable will start iterating from -1, so the above will appear to try to evaluate:
val = arr[-1][counter];
In C++, no array has a value at a negative index offset, so the above logic will result in undefined behavior, and nonsensical results. If you have any kind of an array, like x[], you might find something at x[0], and at x[1], but not at x[-1]. The same applies to multi-dimensional arrays too.
This is the first logical error that was obvious to the naked eye, and there are probably a few more, here. Overall, the approach in the shown code is somewhat unclear. You might benefit from taking a step back, and redesigning the overall approach for this task, since the shown logic does not appear to be going about it correctly, in several fundamental ways.

Answer 2

expected body of lambda expression val4 = arr[val2], [val3];
Seems like a syntax error on this line val4 = arr[val2], [val3]; and not the one you mentioned in the question.
I assume you meant to write val4 = arr[val2][val3]; without the comma.
That being said, the values of val2 and val3 are being assigned the same value and may cause an index out of bounds exception if unchecked. Moreover, starting counter and counterx at -1 will cause out of bounds exceptions.
Moreover, you cannot pass a multidimensional array to a function without passing it as a double pointer or hardcoding the size.
EDIT 1:
I put together a solution for finding the max number in each row. It's not the most optimized code but it's quick and works. I assumed the row,col sizes could change, so I'm using std::vector instead of std:array or primitive array. However, you could revert back if you know you can hardcode int[3][3] into your solution.
#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);
}
EDIT 2:
If you want to check a target index against adjacent indecies, there's no need to use a forloop. There are only 4 (or 8) possible indecies to check against, just easier (and efficient) to hardcode them:
#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);
}
Example output:
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