Сложная задача или есть ли в C++ типы с порядком в 30 цифр?

/////////////////////////////////////////////////////////////////////////////////////////
//запретили использоваться библиотеки для обработки больших чисел, а стандартные типы
//(численные) и средства C++ не позволяют это сделать:
//Смоделировать операцию деления двух действительных чисел в форме +/- m.n Е K, где 
//суммарная длина мантиссы (m+n) - до 30 значащих цифр, а величина порядка K - до 5 цифр. 
//Результат выдать в форме +/- 0.m1 Е K1.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_big_float
{
    //-----------------------------------------------------------------------------------
    static  const   char    PLUS_SYMB       =   '+';
    static  const   char    MINUS_SYMB      =   '-';
    static  const   char    POINT_SYMB      =   '.';
    static  const   char    ZERO_SYMB       =   '0';
    static  const   char    EXPONENT_SYMB   =   'E';
    static  const   char    SPACE_SYMB      =   ' ';
    static  const   int     DIGITS_10       =   30;
    static  const   int     HEAD_TAIL_SIZE  =   DIGITS_10 / 2;
    //-----------------------------------------------------------------------------------
    typedef long long   T_big_int;
    //-----------------------------------------------------------------------------------
    bool        is_correct_;
    bool        is_NaN_;
    bool        is_inf_;
    bool        is_zero_;
    bool        is_positive_;
    T_str       significand_;
    T_big_int   exponent_;
    T_big_int   head_;
    T_big_int   tail_;
    T_big_int   head_tail_mod_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_big_float( T_str  s   =   "" )
        :
        is_NaN_         ( false     ),
        is_inf_         ( false     ),
        exponent_       (),
        head_tail_mod_  ( 1 )
    {
        for( int  i = 0; i < HEAD_TAIL_SIZE; ++i )
        {
            head_tail_mod_  *=  10;
        }
 
        remove_spaces(s);
 
        is_correct_     =       successfully_read_sign          (s)
                            &&  successfully_read_significand   (s)
                            &&  successfully_read_exponent      (s);
 
        if( is_correct_ )
        {
            trim_front_significand();
 
            is_zero_    =       significand_.size   ()  ==  1
                            &&  significand_.front  ()  ==  ZERO_SYMB;
 
            if( !is_zero_ )
            {
                set_head_and_tail();
            }
        }//if
    }
    //-----------------------------------------------------------------------------------
    bool    is_correct()
    {
        return  is_correct_;
    }
    //-----------------------------------------------------------------------------------
    T_big_float     operator/=  ( T_big_float   const   &   R )
    {
        is_NaN_     =       is_NaN_
                        ||  R.is_NaN_
 
                        ||  (
                                    is_zero_
                                &&  R.is_zero_
                            )
 
                        ||  (
                                    is_inf_
                                &&  R.is_inf_
                            );
 
        if  (
                    !is_NaN_
                &&  !is_inf_
                &&  !is_zero_
            )
        {
            is_positive_    =       is_positive_
                                ==  R.is_positive_;
 
            if( R.is_zero_ )
            {
                is_inf_     =   true;
            }
            else if( R.is_inf_ )
            {
                is_zero_    =   true;
            }
            else
            {
                exponent_   -=  R.exponent_;
                divide_head_and_tail_by( R );
                exponent_   -=  DIGITS_10   -   1;
                set_head_and_tail();
            }
        }//if
 
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    T_str   to_string()                                                             const
    {
        T_str   res_str;
 
        if( is_NaN_ )
        {
            res_str     =   "NaN";
        }
        else
        {
            std::ostringstream  sout;
 
            if( !is_positive_ )
            {
                sout    <<  MINUS_SYMB;
            }
 
            if( is_inf_ )
            {
                sout    <<  "infinity";
            }
            else
            {
                sout    <<  ZERO_SYMB;
 
                if( !is_zero_ )
                {
                    sout    <<  POINT_SYMB
                            <<  significand_.substr
                                    (
                                        0,
                                        significand_.find_last_not_of( ZERO_SYMB ) + 1
                                    );
 
                    auto    temp_exponent   =   exponent_ + DIGITS_10;
 
                    if( temp_exponent )
                    {
                        sout    <<  SPACE_SYMB
                                <<  EXPONENT_SYMB
                                <<  SPACE_SYMB
                                <<  temp_exponent;
                    }
                }//if
            }//else
 
            res_str     =   sout.str();
        }//else
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static  void    remove_spaces( T_str    &   s )
    {
        s.assign
            (
                s.begin(),
                std::remove_if
                    (
                        s.begin     (),
                        s.end       (),
                        isspace
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void    divide_head_and_tail_by( T_big_float   const   &   R )
    {
        significand_.clear();
 
        if  (
                head_and_tail_less_than( R )
            )
        {
            shift_left_head_and_tail();
            --exponent_;
        }
 
        while   (
                        significand_.size()
                    <   DIGITS_10
                )
        {
            char    cur_digit   =   0;
 
            while   (
                        !head_and_tail_less_than( R )
                    )
            {
                ++cur_digit;
                subtract_from_head_and_tail( R );
            }
 
            significand_.push_back      ( cur_digit + ZERO_SYMB );
            shift_left_head_and_tail    ();
        }//while
    }
    //-----------------------------------------------------------------------------------
    bool    head_and_tail_less_than( T_big_float   const   &   R )
    {
        return      std::make_pair( head_,      tail_       )
                <   std::make_pair( R.head_,    R.tail_     );
    }
    //-----------------------------------------------------------------------------------
    void    shift_left_head_and_tail()
    {
        head_   *=  10;
        tail_   *=  10;
        head_   +=  tail_ / head_tail_mod_;
        tail_   %=  head_tail_mod_;
    }
    //-----------------------------------------------------------------------------------

    void    subtract_from_head_and_tail( T_big_float   const   &   R )
    {
        tail_   -=  R.tail_;
        head_   -=  R.head_;
 
        if( tail_ < 0 )
        {
            --head_;
            tail_   +=  head_tail_mod_;
        }
    }
    //-----------------------------------------------------------------------------------
    void    trim_front_significand()
    {
        while   (
                        significand_.size   ()  >   1
                    &&  significand_.front  ()  ==  ZERO_SYMB
                )
        {
            significand_.erase( 0, 1 );
        }
    }
    //-----------------------------------------------------------------------------------
    void    normalize_significand_size()
    {
        while   (
                    significand_.size()     <   DIGITS_10
                )
        {
            significand_.push_back( ZERO_SYMB );
            --exponent_;
        }
 
        while   (
                    significand_.size()     >   DIGITS_10
                )
        {
            significand_.pop_back();
            ++exponent_;
        }
    }
    //-----------------------------------------------------------------------------------
    void    set_head_and_tail()
    {
        normalize_significand_size();
        head_   =   0;
        tail_   =   0;
 
        for( int  i = 0; i < HEAD_TAIL_SIZE; ++i )
        {
            in_push_back
                (
                    head_,
                    significand_[i] - ZERO_SYMB
                );
 
            in_push_back
                (
                    tail_,
                    significand_[ i + HEAD_TAIL_SIZE ] - ZERO_SYMB
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
    void    in_push_back
        (
            T_big_int   &   num,
            T_big_int       digit
        )
    {
        num     *=  10;
        num     +=  digit;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_sign( T_str   &   s )
    {
        bool    bool_res    =   !s.empty();
 
        if( bool_res )
        {
            if  (
                        s.front()   ==  PLUS_SYMB
                    ||  s.front()   ==  MINUS_SYMB
                )
            {
                is_positive_    =   s.front()   ==  PLUS_SYMB;
                s.erase( 0, 1 );
            }
            else
            {
                is_positive_    =   true;
            }
        }//if
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_significand( T_str    &   s )
    {
        while   (
                        !s.empty()
 
                    &&  isdigit
                            (
                                s.front()
                            )
                )
        {
            significand_.push_back
                (
                    s.front()
                );
 
            s.erase( 0, 1 );
        }//while
 
        if  (
                    !s.empty    ()
                &&  s.front     ()  ==  POINT_SYMB
            )
        {
            s.erase( 0, 1 );
 
            while   (
                            !s.empty()
 
                        &&  isdigit
                                (
                                    s.front()
                                )
                    )
            {
                significand_.push_back
                    (
                        s.front()
                    );
 
                s.erase( 0, 1 );
                --exponent_;
            }//while
        }//if
 
        return  !significand_.empty();
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_exponent( T_str   &   s )
    {
        bool    bool_res    =   true;
 
        if  (
                s.empty()
            )
        {
            bool_res    =   true;
        }
        else
        {
            bool_res    =       tolower (
                                            s.front()
                                        )
 
                            ==  tolower( EXPONENT_SYMB );
 
            if( bool_res )
            {
                s.erase( 0, 1 );
                bool_res    =   !s.empty();
 
                if( bool_res )
                {
                    std::istringstream  ssin(s);
                    T_big_int     exponent_delta   =   0;
                    bool_res    =       ssin    >>  exponent_delta
                                    &&  !(ssin  >>    T_str() );
 
                    if( bool_res )
                    {
                        exponent_   +=  exponent_delta;
                    }
                }//if
            }//if
        }//else
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_big_float     operator/
    (
        T_big_float     const   &   L,
        T_big_float     const   &   R
    )
{
    T_big_float     res     =   L;
    return  res     /=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
std::ostream    &   operator<<
    (
        std::ostream            &   ostr,
        T_big_float     const   &   big_float
    )
{
    ostr    <<  big_float.to_string();
    return  ostr;
}
/////////////////////////////////////////////////////////////////////////////////////////
std::istream    &   operator>>
    (
        std::istream    &   istr,
        T_big_float     &   big_float
    )
{
    T_str   str_big_float;
    getline( istr,  str_big_float );
    big_float   =   T_big_float( str_big_float );
    return  istr;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  "\n\n\n\n"
                    <<  "Введите два числа в формате +/- m.n Е K, где m и n - очень большие натуральные"
                    <<  std::endl
                    <<  "числа, а порядок K - целое число"
                    <<  std::endl
                    <<  "(пробелы, знак плюс, дробную либо целую часть и порядок можно опускать):"
                    <<  std::endl;
 
        T_big_float     x;
        do
        {
            std::cout   <<  '\t'
                        <<  "x\t= ";
            std::cin    >>  x;
        }
        while   (
                    !x.is_correct()
                );
 
        T_big_float     y;
        do
        {
            std::cout   <<  '\t'
                        <<  "y\t= ";
            std::cin    >>  y;
        }
        while   (
                    !y.is_correct()
                );
 
        std::cout   <<  "\n\t"
                    <<  "x / y\t= "
                    <<  x / y
                    <<  std::endl;
    }//for
}

significand_.erase(significand_.size()-1,1);