Определить количество строк матрицы не содержащих ни одного нулевого элемента

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main()
{
    void printMatrix(int**, size_t, size_t);
    unsigned getNumOfRowsWithoutZero(int**, size_t, size_t);
    int getMaxValue(int**, size_t, size_t);
 
    unsigned row, col;
 
    std::cout << "Number of Rows:    ";
    std::cin >> row;                // ввод кол-ва строк матрицы
 
    std::cout << std::endl
              << "Number of Columns: ";
 
    std::cin >> col;                // ввод кол-ва столбцов матрицы
    std::cout << std::endl;
 
    /* Создаем матрицу */
    int **matrix = new int*[row];
    for (size_t i = 0; i < row; i++)
    {
        matrix[i] = new int[col];
    }
 
    /* Заполняем матрицу случайными числами */
    srand(time(NULL));
    for(size_t i = 0; i < row; i++)
    {
        for(size_t j = 0; j < col; j++)
        {
            matrix[i][j] = rand() % 10;
        }
    }
 
    /* Печать матрицы на экран */
    printMatrix(matrix, row, col);
 
    /* Выводим на экран количество строк, не содержащих 0 */
    std::cout << std::endl << "Number of Rows with non-zero values: "
              << getNumOfRowsWithoutZero(matrix, row, col);
 
    /* находим максимум, который встречается в матрице более 1 раза */
 
    std::cout << std::endl << "The Maximum value occurs more than once: ";
    int max = getMaxValue(matrix, row, col);
    if (max != INT_MIN)
    {
        std::cout << max << std::endl;
    }
    else
    {
        std::cout << " -" << std::endl;
    }
 
    /* освобождаем память */
    for(size_t i = 0; i < row; i++)
    {
        delete[] matrix[i];
    }
    delete[] matrix;
 
    std::cout << "\n\nPress <Enter> key to exit program";
    std::cin.get();
 
    return 0;
}
 
void printMatrix(int **matrix, const size_t row, const size_t col)
{
    for(size_t i = 0; i < row; i++)
    {
        for(size_t j = 0; j < col; j++)
        {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}
 
unsigned getNumOfRowsWithoutZero(int **matrix, const size_t row,
                                               const size_t col)
{
    unsigned row_counter = 0;  // счетчик строк, не содержащих 0
 
    for (size_t i = 0; i < row; i++)
    {
        bool is_zero = false;
        for (size_t j = 0; j < col; j++)
        {
            if (matrix[i][j] == 0) is_zero = true;
        }
        if (!is_zero) row_counter++;
        is_zero = false;
    }
 
    return row_counter;
}
 
int getMaxValue(int **matrix, const size_t row, const size_t col)
{
    int *matrix_copy = new int[row*col];
 
    // копируем двумерный массив в одномерный
    for (size_t i = 0, k=0; i < row; i++)
    {
        for (size_t j = 0; j < col; j++)
        {
            matrix_copy[k++] = matrix[i][j];
        }
    }
 
    // сортируем matrix_copy по невозрастанию
    for (size_t i = 1; i < col*row; i++)
    {
        for (size_t j = i; j > 0 && matrix_copy[j] > matrix_copy[j-1]; j--)
        {
            int buf = matrix_copy[j];
            matrix_copy[j] = matrix_copy[j-1];
            matrix_copy[j-1] = buf;
        }
    }
 
    // ищем максимум, встречающийся в массиве более 1 раза
    int max = INT_MIN;
    for (size_t i = 0; i < col*row; i++)
    {
        if(matrix_copy[i] == matrix_copy[i+1])
        {
            max = matrix_copy[i];
            break;
        }
        else
            continue;
    }
 
    delete[] matrix_copy;
 
    return max;
}

unsigned getNumOfRowsWithoutZero(int **matrix, const size_t row,
                                               const size_t col)
{
    unsigned row_counter = 0;  // счетчик строк, не содержащих 0
 
    for (size_t i = 0, j; i < row; i++)
    {
        for (j = 0; (j < col) && (matrix[i][j] != 0); j++)
            ; //nop
 
        if (j == col)
        {
            row_counter++;
        }
    }
 
    return row_counter;
}