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

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

//базовый класс ошибок переполнения 
//(результат операции не может быть записан в unsigned long long)    
    class overflow : public rational_exception
    {
    };

//переполнение, возникшее в результате сложения двух чисел типа unsigned long long
    class addition_overflow : public overflow
    {
    public:
        addition_overflow(){err_code = 0;}
        explicit addition_overflow(unsigned char err_num){err_code = err_num;}
    };

//переполнение, возникшее в результате умножения двух чисел типа unsigned long long
    class multiplication_overflow : public overflow
    {
    public:
        multiplication_overflow(){err_code = 0;}
        explicit multiplication_overflow(unsigned char err_num){err_code = err_num;}
    };

//переполнение, возникшее в результате преобразования строки в чисело типа unsigned long long
    class recognition_overflow : public overflow
    {
    public:
        recognition_overflow(){err_code = 0;}
        explicit recognition_overflow(unsigned char err_num){err_code = err_num;}
    };

//базовый клас ошибок неверного ввода    
    class invalid_in : public rational_exception
    {
    };

//в результате операции ввода была попытка присвоить знаменателю 0    
    class null_denominator : public invalid_in
    {
    public:
        null_denominator(){err_code = 0;}
        explicit null_denominator(unsigned char err_num){err_code = err_num;}
    };

//ошибка ввода - введённая строка не может быть распознана как смешанное число    
    class is_not_rational_in : public invalid_in
    {
    public:
        is_not_rational_in(){err_code = 0;}
        explicit is_not_rational_in(unsigned char err_num){err_code = err_num;}
    };

    //базовый клас ошибок конструкторов    
    class invalid_constr_arg : public rational_exception
    {
    };

    //В конструктор передан 0 для присвоения знаменателю
       class null_denominator_in_constroctor : public invalid_constr_arg
    {
    public:
        null_denominator_in_constroctor(){err_code = 0;}
        explicit null_denominator_in_constroctor(unsigned char err_num){err_code = err_num;}
    };

enum 
{
    kErrorAdditionOverflow,
    kErrorMultiplicationOwerflow,
    //.....
};

class rational_exception: public std::exception
{
public:
    explicit rational_exception(int k): code(k) {}
    int const code;
};

try {
    //....
} catch(rational_exception const& ex) {
    switch(ex.code) {
        case kErrorAdditionOverflow: //....
        case kErrorMultiplicationOwerflow: //....
        //....
    }
} catch(std::exception const &ex) {
    /* TODO: */
} catch(...) {
    /* TODO */
}

K>>try {
K>>    //....
K>>} catch(rational_exception const& ex) {
K>>    switch(ex.code) {
K>>        case kErrorAdditionOverflow: //....
K>>        case kErrorMultiplicationOwerflow: //....
K>>        //....
K>>    }
K>>} catch(std::exception const &ex) {
K>>    /* TODO: */
K>>} catch(...) {
K>>    /* TODO */
K>>}
K>>

catch(rational_exception const& ex)

rational<int> a(10,0);

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;
   };