Умножение двух больших чисел - C++ - Ответ 9282450

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//дано два 40 значных числа,нужно перемножить их
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
template < typename TT_base_int >
class   T_big_int
{
    //-------------------------------------------------------------------------
    using   T_values    =   std::vector< TT_base_int >;
    //-------------------------------------------------------------------------
    constexpr   static  const   TT_base_int
    BASE_VAL_MAX        =   std::numeric_limits< TT_base_int >::max();
 
    constexpr   static  const   TT_base_int
    ORDER_OF_FACTOR     =   log( BASE_VAL_MAX ) / log(10) / 2;
 
    constexpr   static  const   TT_base_int
    FACTOR              =   pow( 10,    ORDER_OF_FACTOR );
    //-------------------------------------------------------------------------
    T_values    values_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_big_int( T_str    const   &   digits )
    {
        set_values( digits );
    }
    //-------------------------------------------------------------------------
    T_big_int( TT_base_int  num     =   0 )
    {
        add_to_ind
            (
                num,
                0
            );
    }
    //-------------------------------------------------------------------------
    T_big_int   &   operator*=( T_big_int   const   &   big_num )
    {
        T_big_int   res;
 
        for( size_t  i{}; i < values_.size(); ++i )
        {
            for( size_t  j{}; j < big_num.values_.size(); ++j )
            {
                res.add_to_ind
                    (
                            values_             [i]
                        *   big_num.values_     [j],
 
                        i + j
                    );
            }//for
        }//for
 
        std::swap   (
                        res,
                        *this
                    );
 
        return  *this;
    }
    //-------------------------------------------------------------------------
    T_str   to_string()                                                     const
    {
        T_str   res;
 
        for (
                auto
                it  =   values_.begin   ();
                it  !=  values_.end     ();
                ++it
            )
        {
            auto    elem_str    =   std::to_string( *it );
 
            while   (
                            elem_str.size()
                        <   ORDER_OF_FACTOR
                    )
            {
                elem_str    =   '0' +   elem_str;
            }
 
            res     =   elem_str    +   res;
        }//for
 
        while   (
                        res.size    ()  >   1
                    &&  res.front   ()  ==  '0'
                )
        {
            res.erase( 0, 1 );
        }
 
        return  res;
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    void    add_to_ind
        (
            TT_base_int     num,
            size_t          ind
        )
    {
        if  (
                    ind + 1
                >   values_.size()
            )
        {
            values_.resize( ind + 1 );
        }
 
        values_[ ind ]  +=  num;
        auto    head    =   values_[ ind ]  /   FACTOR;
        values_[ ind ]  %=  FACTOR;
 
        if( head )
        {
            add_to_ind
                (
                    head,
                    ind + 1
                );
        }//if
    }
    //-------------------------------------------------------------------------
    void    set_values( T_str    digits )
    {
        while   (
                    digits.size()   >   ORDER_OF_FACTOR
                )
        {
            auto    new_digits_size     =       digits.size()
                                            -   ORDER_OF_FACTOR;
 
            auto    tail    =   digits.substr( new_digits_size                  );
            digits          =   digits.substr( 0,               new_digits_size );
 
            values_.push_back
                (
                    std::stoll( tail )
                );
        }//while
 
        values_.push_back
            (
                std::stoll( digits )
            );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
template< typename  U >
std::ostream    &   operator<<
    (
        std::ostream            &   ostr,
        T_big_int< U >  const   &   big_int
    )
{
    ostr    <<  big_int.to_string();
    return  ostr;
}
///////////////////////////////////////////////////////////////////////////////
template< typename  U >
T_big_int< U >   operator*
    (
        T_big_int< U >  const   &   L,
        T_big_int< U >  const   &   R
    )
{
    return  T_big_int< U >(L)   *=  R;
}
///////////////////////////////////////////////////////////////////////////////
template
    <
        typename    T,
        typename    U
    >
T_big_int< T >   operator*
    (
        U                           L,
        T_big_int< T >  const   &   R
    )
{
    return      T_big_int< T >(L)
            *   R;
}
///////////////////////////////////////////////////////////////////////////////
template
    <
        typename    T,
        typename    U
    >
T_big_int< T >   operator*
    (
        T_big_int< T >  const   &   L,
        U                           R
    )
{
    return      L
            *   T_big_int< T >(R);
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::ios::sync_with_stdio(false);
 
    using   T_int   =   T_big_int< long long >;
 
    T_int   a   (
                    "70000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                );
 
    T_int   b   (
                    "80000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                    "00000000000000000000000000000000000000000000000000000000000"
                );
 
    std::cout   <<  a   *   b
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  50  *   a
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  "50"    *   a
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  a   *   50
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  a   *   "50"
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  '!'     *   b
                <<  std::endl
                <<  std::endl;
 
    std::cout   <<  b   *   '!'
                <<  std::endl
                <<  std::endl;
 
    a   *=  a;
    a   *=  a;
    a   *=  a;
    a   *=  a;
 
    std::cout   <<  a
                <<  std::endl;
}