Класс для работы со скалярным типом данных в стиле языка Перл

/////////////////////////////////////////////////////////////////////////////////////////
//Создать класс для работы со скалярным типом данных в стиле языка Перл. Класс должен быть прозрачен 
//с точки зрения число, строка. Т.е. работа методов класса не зависела бы от того, что в данный момент
//хранится в нем число или строка. В класс должны быть включены методы для присваивания и получения
//значений setValue и getValue, а также для методы и операторы для выполнения операций сложения или
//склейки, вычитания, деления и умножения plus, minus, div, mult. Следует обратить внимание на
//возвращаемые значения. Все операции не имеющие смысла для содержащегося в нем значения должны
//генерировать исключительную ситуацию и не оказывать воздействия на данные. Также должны быть
//перегружены операторы ввода вывода в поток.
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_scalar
{
    T_str   str_val_;
    //-----------------------------------------------------------------------------------
    friend  std::ostream    &   operator<<
        (
            std::ostream            &   outs,
            T_scalar        const   &   scalar
        )
    {
        outs    <<  scalar.str_val_;
        return  outs;
    }
    //-----------------------------------------------------------------------------------
    friend  T_scalar    operator,
        (
            T_scalar    L,
            T_scalar    R
        );
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_scalar( T_str const   &   str =   T_str() )
        :
        str_val_( str )
    {}
    //-----------------------------------------------------------------------------------
    T_scalar( int n )
        :
        str_val_    (
                        num_to_str( n )
                    )
    {}
    //-----------------------------------------------------------------------------------
    T_scalar    operator+= ( T_scalar   scalsr )
    {
        int     L;
        int     R;
        bool    bool_res    =       successfully_get_num_from_str(  str_val_,           L   )
                                &&  successfully_get_num_from_str(  scalsr.str_val_,    R   );
 
        if( !bool_res )
        {
            throw   std::invalid_argument("нечисловой аргумент в числовой операции");
        }
 
        str_val_    =   num_to_str( L += R );
        return  *this;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool  successfully_get_num_from_str
        (
            T_str   const   &   str,
            int             &   n
        )
    {
        T_str    const   FINISH_STR     =   "$$$";
        std::istringstream  ssin( str + FINISH_STR );
        ssin    >>  n;
        T_str   s;
        ssin    >>  s;
        return  s == FINISH_STR;
    }
    //-----------------------------------------------------------------------------------
    T_str   num_to_str( int  n )
    {
        std::ostringstream  sout;
        sout    <<  n;
        return  sout.str();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_scalar    operator+
    (
        T_scalar    L,
        T_scalar    R
    )
{
    return  L += R;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_scalar    operator,
    (
        T_scalar    L,
        T_scalar    R
    )
{
    return  T_scalar( L.str_val_ + R.str_val_ );
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
    try
    {
        T_scalar    A = "5555";
        T_scalar    B = 4;
 
        std::cout   <<  ( A, B, A )
                    <<  std::endl;
 
        std::cout   <<  ( A, B )
                    <<  std::endl;
 
        std::cout   <<  T_str("101") + B
                    <<  std::endl;
 
        std::cout   <<  B   +   T_str("101")
                    <<  std::endl;
 
        std::cout   <<  1000   +   T_str("101")
                    <<  std::endl;
 
        std::cout   <<  T_str("101")    +   1000
                    <<  std::endl;
 
        std::cout   <<  T_str("101") + T_str("101")
                    <<  std::endl;
 
        std::cout   <<  ( T_str("101") , T_str("101") )
                    <<  std::endl;
 
        std::cout   <<  ( T_str("101") , 15 )
                    <<  std::endl;
 
        std::cout   <<  20 + B
                    <<  std::endl;
 
        std::cout   <<  B + 20
                    <<  std::endl;
 
        std::cout   <<  5 + T_str("1000") + 10
                    <<  std::endl;
 
        std::cout   <<  T_str("abba") + 4
                    <<  std::endl;
    }
    catch( std::exception&  e )
    {
        std::cout   <<  e.what()
                    <<  std::endl;
    }
 
    system( "pause" );
}