Как запретить ввод пробела и букв?

#include <stdio.h>
#include <iomanip>
#include <iostream>
 
using namespace std;
 
int main()
{int n, m, i, j;
cout<<"kl-vo strok: ";cin>>n;
while(n<=0)
{
cout<<"net, >0"<< endl;
cin>>n;
}
 
cout<<"kl-vo stolbcov: ";cin>>m;
while(m<=0)
{
cout<<"net, >0"<< endl;
cin>>m;
}
 int a[n][m];
       for(i = 0 ; i < n; i++)
 for(j = 0 ; j < m; j++)  {
       cout<<"iliment"<<i<<"."<<j<<": ";cin>>a[i][j];
    }
cout<<endl;
 
 
for(i = 0 ; i < n; i++)
{
for(j = 0 ; j < m; j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
 
for(j = 0 ; j < m; j++)
{
int maxs=a[0][j];
    for(i = 0 ; i < n; i++)
 {
       if (maxs<a[i][j]) maxs=a[i][j];
    }
cout<<"max "<<j<<": "<<maxs<<endl;
}
 
}

// в строке ввода только целое число, перед которым могут быть пробельные символы, + или -.
int a;
while (!(cin >> a) || (cin.peek() != '\n'))
{
    cin.clear();
    while (cin.get() != '\n');
    cout << "Input error! Retry input" << endl;
}

    int n;
    cout<<"Количество строк: ";
    do
    {
        char tmp[20];
        cin.getline(tmp,20);
        n=atoi(tmp);
        if(n<=0)
            cout<<"Нужно ввести число >0: "<< endl;
    }while(n<=0);

//Собственно тут если вводятся буквы, то программа
//творит что то страшное... Да и через пробел вытворяет
//что то неадекватное. Нельзя ли их запретить дабы
//любой ввод был корректным?
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < int       >   T_row;
typedef std::vector     < T_row     >   T_matr;
///////////////////////////////////////////////////////////////////////////////
bool    successfully_set_int_val
    (
        T_str   const   &   val_str,
        int             &   val
    )
{
    try
    {
        size_t  ind{};
        val     =   std::stoi( val_str,     &ind );
        return  ind     ==  val_str.size();
    }
    catch(...)
    {
        return  false;
    }
}
///////////////////////////////////////////////////////////////////////////////
void    with_prompt_input_int_val
    (
        T_str   const   &   prompt,
        int             &   val
    )
{
    T_str   val_str;
 
    do
    {
        std::cout   <<  prompt;
        getline( std::cin,  val_str );
    }
    while   (
                !successfully_set_int_val
                    (
                        val_str,
                        val
                    )
            );
}
///////////////////////////////////////////////////////////////////////////////
void    with_prompt_input_natural_int_val
    (
        T_str   const   &   prompt,
        int             &   val
    )
{
    do
    {
        with_prompt_input_int_val
            (
                prompt,
                val
            );
    }
    while   (
                val     <=  0
            );
}
///////////////////////////////////////////////////////////////////////////////
void    input_matr( T_matr  &   matr )
{
    std::cout   <<  std::endl;
 
    for( size_t  i{}; i < matr.size(); ++i )
    {
        for( size_t  j{}; j < matr.front().size(); ++j )
        {
            with_prompt_input_int_val
                (
                        "matr["
                    +   std::to_string(i + 1)
                    +   "]["
                    +   std::to_string(j + 1)
                    +   "] = ",
 
                    matr[i][j]
                );
        }//for
    }//for
}
///////////////////////////////////////////////////////////////////////////////
void    print_matr( T_matr  const   &   matr )
{
    std::cout   <<  std::endl;
 
    for( auto   const   &   row     :   matr )
    {
        for( auto   elem    :   row )
        {
            std::cout   <<  elem    <<  '\t';
        }
 
        std::cout   <<  std::endl;
    }
}
///////////////////////////////////////////////////////////////////////////////
void    set_max_elements_of_cols
    (
        T_matr  const   &   matr,
        T_row           &   max_elements_of_cols
    )
{
    for( size_t  j{}; j < matr.front().size(); ++j )
    {
        T_row   col_cur;
 
        for( size_t  i{}; i < matr.size(); ++i )
        {
            col_cur.emplace_back( matr[i][j] );
        }
 
        max_elements_of_cols[j]
            =   *std::max_element   (
                                        col_cur.begin   (),
                                        col_cur.end     ()
                                    );
    }//for
}
///////////////////////////////////////////////////////////////////////////////
void    print_max_elements_of_cols( T_row   const   &   max_elements_of_cols )
{
    std::cout   <<  std::endl;
 
    for( size_t  j{}; j < max_elements_of_cols.size(); ++j )
    {
        std::cout   <<  "max element of col "
                    <<  j + 1
                    <<  "\t= "
                    <<  max_elements_of_cols[j]
                    <<  std::endl;
    }//for
}
///////////////////////////////////////////////////////////////////////////////
int main()
{
    int     rows_total{};
    int     cols_total{};
 
    with_prompt_input_natural_int_val( "rows total = ",     rows_total  );
    with_prompt_input_natural_int_val( "cols total = ",     cols_total  );
 
    T_matr  matr    (
                        rows_total,
                        T_row( cols_total )
                    );
 
    input_matr( matr );
    print_matr( matr );
 
    T_row   max_elements_of_cols( cols_total );
 
    set_max_elements_of_cols
        (
            matr,
            max_elements_of_cols
        );
 
    print_max_elements_of_cols( max_elements_of_cols );
}