Поиск элементов матрицы

[bulka_v_pechali]

Дана квадратная матрица. Посчитать, сколько четных элементов в матрице, соседи которых по вертикали и по горизонтали нечетные числа. Динамически выделить необходимую память для элементов матрицы.
Заранее огромное спасибо. Вот код моей функции, не рабочий.

void searching(int **m,int n)
{
    int k=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(m[i][j]%2==0){
                if(m[i+1][j]%2==1 && m[i-1][j]%2==1 &&  m[i][j+1]%2==1 && m[i][j-1]%2==1)
                    SetColor(5);
                    k++;
            }
        }
    }
    printf("В матрице %i искомых элементов.",k);
    for ( int i=0;i<n;i++) {
            puts("");
        for (int j=0;j<n;j++) {
            printf("%6i",m[i][j]);
        }
    }
    SetColor(15);
}

[digitalis]

Что-то не вижу динамического выделения памяти под матрицу.
Не отработан вариант, когда проверяемый элемент у границы массива - у него только 1 сосед слева или справа или сверху или снизу.

    SetColor(15);

Впечатлило. Ну прямо в яблочко в этой задаче.

[bulka_v_pechali]

digitalis, Динамическое там есть, просто в другой функции! Благодарю за замечание)

[digitalis]

Вопрос с "приграничным" элементом остаётся. Вылетит на первом же шагу цикла, потому что там нет ни "соседа слева", ни "соседа сверху" . Это в лучшем случае, если отключён контроль границ массива. А в худшем - как бы работает, а результат - БСК.

    SetColor(15);

- по-прежнему оставляет в недоумении. Кого красим ?

[bulka_v_pechali]

digitalis, реализовал все проверки, работать не хочет

int searching(int **m,int n)
{
    int k=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(m[i][j]%2==0){
                if(m[i+1][j]%2==1 && m[i-1][j]%2==1 &&  m[i][j+1]%2==1 && m[i][j-1]%2==1 && j!=0 && i!=0 && j!=n-1 && i!=n-1)//для обладателей 4 соседей
                    k++;

                    else if(i==0 && m[i][j-1]%2==1 && m[i][j+1]%2==1 && m[i+1][j]%2==1) k++;//верхняя граница
                    else if(j==0 && m[i-1][j]%2==1 && m[i][j+1]%2==1 && m[i+1][j]%2==1) k++;//правая граница
                    else if(j==n-1 && m[i-1][j]%2==1 && m[i][j-1]%2==1 && m[i+1][j]%2==1) k++;//левая граница
                    else if(i==n-1 && m[i][j-1]%2==1 && m[i-1][j]%2==1 && m[i][j+1]%2==1) k++;//нижняя граница

                    else if(m[i-1][j]%2==1 && m[i][j+1]%2==1 && i==n-1 && j==0) k++;//правый нижний угол
                    else if(m[i+1][j]%2==1 && m[i][j+1]%2==1 && j==i) k++;//верхний правый угол
                    else if(m[i][j-1]%2==1 && m[i+1][j]%2==1 && j==n-1 && i==0) k++;//верхний левый угол
                    else if(m[i-1][j]%2==1 && m[i][j-1]%2==1 && i==j) k++;//нижний левый угол

            }
        }
    }
    return k;

}

[BDA]

Сначала надо проверять индекс, а только потом лезть по нему в массив. А еще, мне кажется, что "проваливание" в следующее условие может быть неверным. Допустим, что условия на индексы в первом if выполнены, но сами соседи не все нечетны, тогда будет выполнена проверка этих соседей, будто они являются верхней границей, но это неверно. Попробуйте так:

if (
    m[i][j] % 2 == 0 &&
    ((i != 0 && m[i - 1][j] % 2 == 1) || i == 0) &&
    ((j != 0 && m[i][j - 1] % 2 == 1) || j == 0) &&
    ((i != n - 1 && m[i + 1][j] % 2 == 1) || i == n - 1) &&
    ((j != n - 1 && m[i][j + 1] % 2 == 1) || j == n - 1)
) k++;

[digitalis]

Я как не сторонник длинных "многоэтажных" выражений , способствующих закипанию мозгов и воспроизведению матовых слов - ввёл бы дополнительные 4 переменные, которые бы определяли "соседей" - если не приграничные - то по общему правилу, если да, то вместо несуществующего элемента массива - нечётную константу. И уж затем if - ить однообразно. Но предварительно, чтоб не делать лишней работы , выполнил бы

if (m[i][j] % 2 != 0) continue ;

Возможно, умный компилятор так и делает, но что на него полагаться - "сам себе оптимизатор" .
Вообще разбивание монстрообразных конструкций, дающих благодатную почву для произрастания трудноуловимых ошибок, на более простые и ясные для понимания считается хорошей практикой, imho.

[bulka_v_pechali]

BDA, спасибо большое!

[bulka_v_pechali]

digitalis, спасибо огромное, разобрался

[BDA]

digitalis, согласен насчет неприятности многоэтажных условий, но в данном случае получилось достаточно однообразно, на мой взгляд. По поводу лишней работы: что в си, что в дельфи (если не включать Compiler - Complete boolean eval) логическое "и" считается лениво слева-направо.