S>rational<int> a(10,0);
S>

    int mynull  = 0;
    int notnull = 5;
    int result  = notnull / mynull;

         cout << "Введите знак: '+' или '-': ";
            cin >> sign;
            switch (sign)
            {
            case '+':
                s = rational::plus;
                break;
            case '-':
                s = rational::minus;
                break;
            default:
                cout << "Вы ввели знак неверно!" << endl;
                continue;
            }

            cout << "Введите первое число: ";
            cin >> a;
            cout << "Введите второе число: ";
            cin >> b;
            cout << "Введите третье число: ";
            cin >> c;
            rational r3(s, a, b, c);
            cout << "Результат вызова второго конструктора: " << r3 << endl;

try{ some code}
catch(const addition_overflow&){
    действие 1
}
catch(const multiplication_overflow&){
    действие 2
}

//Классы ошибок

//базовый класс для всех ошибок при действиях со смешанными числами
    class rational_exception
    {
    protected:
        unsigned short err_code;
    public:
        unsigned short get_err_code(){return err_code;}
    };

//переполнение, возникшее в результате сложения двух чисел типа unsigned long long
    class clrational_addition_overflow: public std::overflow_error, 
                                        public rational_exception
    {
    public:
        clrational_addition_overflow(unsigned int errnum, 
                                     const std::string& message):
                std::overflow_error(message){err_code = errnum;}
    };

//переполнение, возникшее в результате умножения двух чисел типа unsigned long long
    class clrational_multiplication_overflow: public std::overflow_error, 
                                              public rational_exception
    {
    public:
        clrational_multiplication_overflow(unsigned int errnum, 
                                           const std::string& message):
                        std::overflow_error(message){err_code = errnum;}
    };
    
//переполнение, возникшее в результате преобразования строки в чисело типа
//unsigned long long (результат операции не может быть записан в unsigned long long)    
    class clrational_recognition_overflow: public std::overflow_error, 
                                           public rational_exception
    {
    public:
        clrational_recognition_overflow(unsigned int errnum, 
                                           const std::string& message):
                        std::overflow_error(message){err_code = errnum;}
    };
    
//в результате операции ввода была попытка присвоить знаменателю 0    
    class clrational_null_denominator: public std::runtime_error, 
                                       public rational_exception
    {
    public:
        clrational_null_denominator(unsigned int errnum, 
                                    const std::string& message):
                  std::runtime_error(message){err_code = errnum;}
    };

//ошибка ввода - введённая строка не может быть распознана как смешанное число
    class clrational_not_rational: public std::runtime_error, 
                                   public rational_exception
    {
    public:
        clrational_not_rational(unsigned int errnum, 
                                const std::string& message):
           std::runtime_error(message){err_code = errnum;}
    };

    //в конструктор передан 0 для присвоения знаменателю
    class clrational_constructor_null_denominator: public std::invalid_argument, 
                                                   public rational_exception
    {
    public:
        clrational_constructor_null_denominator(unsigned int errnum, 
                                                const std::string& message):
                           std::invalid_argument(message){err_code = errnum;}
    };

 catch ( rational_exception &e ) 
   {
      cerr << "Перехвачено исключение: " << e.what( ) << endl;
      cerr << "Тип исключения: " << typeid( e ).name( ) << endl;
   };