Перевод арабских чисел в римские

#include<stdio.h> 
#include<conio.h> 
#include<ctype.h> 
#include<stdlib.h> 
#include<string.h> 
#define    NUMS    13
 
char* to_roman( int num, char* buff )
{
    int p = NUMS;
    unsigned int a_num[NUMS] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};
    char* r_num[NUMS] = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
    char* roman;
 
    *buff = '\0';
    while (p--)
        while (num >= a_num[p])
        {
            num -= a_num[p];
            strcat( buff, r_num[p] );
        }
 
    return buff;
}
 
int main( void)
{
    char* roman;
 
int arabian;
 
printf("vvedite chislo\n");
 
scanf("%d",&arabian);
 
    roman = (char*)malloc(256);
    printf( "%i: %s\n", arabian, to_roman( arabian, roman ));
    free( roman );
    getch();
    return 0;
}

//Написать код, который арабские числа преобразовывал бы в римские, 
//и потом можно было бы с ними делать простые математические действия, 
//например, V + X, и чтоб выдавало бы результат, тут он будет XV. 
//И так же с умножением и т.д.
#include <string> 
#include <iostream> 
#include <map> 
#include <algorithm> 
 
typedef std::string  T_str;
 
struct  T_rom_dig_compare
{
    bool  operator()
        (
            const  T_str&  key1,
            const  T_str&  key2
        )
    {
        char key1_front_symb = key1[0];
        char key2_front_symb = key2[0];
        if(key1_front_symb == key2_front_symb)
        {
            return  key1 < key2;
        }
 
        switch(key1_front_symb)
        {
        case 'I':
            return    key2_front_symb == 'X'
                   || key2_front_symb == 'C';
        case 'X':
            return key2_front_symb == 'C';
        default:
            return false;            
        }//switch(key1_front_symb)
    }//bool  operator()
};//struct T_rom_dig_compare
////////////////////////////////////////////////////////////////////////////////
 
void  find_in_str_substr_and_replace_to
    (
        T_str&        str,
        const T_str&  substr,
        const T_str&  new_substr
    )
{
    T_str::size_type  find_pos;
    while((find_pos = str.find(substr)) != T_str::npos)
    {
        str.replace(find_pos, substr.length(), new_substr);
    }            
}
////////////////////////////////////////////////////////////////////////////////
template<class T_elem>
class  T_find_and_replace_first_to_second
{    
    bool   replace_first_to_second_;
    T_str  target_str_;
public:
    T_find_and_replace_first_to_second
        (
            bool   replace_first_to_second,
            T_str  target_str
        ) : replace_first_to_second_(replace_first_to_second), target_str_(target_str)
    {}
 
    void operator() (const T_elem&  otobr_elem)
    {
        T_str  substr      = otobr_elem.first;
        T_str  new_substr  = otobr_elem.second;
 
        if(!replace_first_to_second_) std::swap(substr, new_substr);
        find_in_str_substr_and_replace_to(target_str_, substr, new_substr);    
    }
 
    operator T_str()
    {
        return  target_str_;
    }
};
 
////////////////////////////////////////////////////////////////////////////////
 
class T_10_rom_to_rom_otobr
{
    typedef std::map<T_str, T_str, T_rom_dig_compare>  T_10_rom_to_rom_map;
    T_10_rom_to_rom_map                                _10_rom_to_rom_map_;
 
public:
    T_10_rom_to_rom_otobr()
    {
        _10_rom_to_rom_map_["IIII"]       = "IV";      
        _10_rom_to_rom_map_["IIIII"]      = "V";        
        _10_rom_to_rom_map_["IIIIIIIII"]  = "IX";
 
        _10_rom_to_rom_map_["XXXX"]       = "XL";
        _10_rom_to_rom_map_["XXXXX"]      = "L";
        _10_rom_to_rom_map_["XXXXXXXXX"]  = "XC";
 
        _10_rom_to_rom_map_["CCCC"]       = "CD";
        _10_rom_to_rom_map_["CCCCC"]      = "D";
        _10_rom_to_rom_map_["CCCCCCCCC"]  = "CM";
    }
    //--------------------------------------------------------------------------------
    T_str  operator()(T_str  _10_rom_str_val) const
    {
        //Обходим отображение с конца, чтобы строку "IIIIIIIII" заменить на "IX",
        //а не на "IVIVI".
        //Заменяем first на second.
        return  std::for_each
                    (
                        _10_rom_to_rom_map_.rbegin(), 
                        _10_rom_to_rom_map_.rend(), 
                        T_find_and_replace_first_to_second
                        <T_10_rom_to_rom_map::value_type>(true, _10_rom_str_val)
                    );
    }
    //--------------------------------------------------------------------------------
    T_str  obratn(T_str  rom_str_val) const
    {
        //Обходим отображение сначала, чтобы заменить "IV" на "IIII", а не на "IIIIII".
        //Заменяем second на first.
        return  std::for_each
                    (
                        _10_rom_to_rom_map_.begin(), 
                        _10_rom_to_rom_map_.end(), 
                        T_find_and_replace_first_to_second
                        <T_10_rom_to_rom_map::value_type>(false, rom_str_val)
                    );
    }   
};//class T_10_rom_to_rom_otobr
////////////////////////////////////////////////////////////////////////////////
 
class T_primitive_to_10_rom_otobr
{
    typedef std::map<T_str, T_str, T_rom_dig_compare>  T_primitive_to_10_rom_map;
    T_primitive_to_10_rom_map                          primitive_to_10_rom_map_;
public:
    T_primitive_to_10_rom_otobr()
    {
        primitive_to_10_rom_map_["IIIIIIIIII"]   = "X";
        primitive_to_10_rom_map_["XXXXXXXXXX"]   = "C";
        primitive_to_10_rom_map_["CCCCCCCCCC"]   = "M";
    }
    //--------------------------------------------------------------------------------
    T_str  operator()(T_str  primitive_rom_str_val) const
    {
        //Обходим отображение сначала, так как изначально имеем в строке только единицы.
        //Меняем first на second.
        return  std::for_each
                    (
                        primitive_to_10_rom_map_.begin(), 
                        primitive_to_10_rom_map_.end(), 
                        T_find_and_replace_first_to_second
                        <T_primitive_to_10_rom_map::value_type>(true, primitive_rom_str_val)
                    );
    }
    //--------------------------------------------------------------------------------
    T_str  obratn(T_str  _10_rom_str_val) const
    {
        //Обходим отображение с конца, чтобы сначала заменить тысячи на сотни, 
        //сотни на десятки, а потом десятки на единицы.
        //Заменяем second на first.
        return  std::for_each
                    (
                        primitive_to_10_rom_map_.rbegin(), 
                        primitive_to_10_rom_map_.rend(), 
                        T_find_and_replace_first_to_second
                        <T_primitive_to_10_rom_map::value_type>(false, _10_rom_str_val)
                    );
    }   
};//class T_primitive_to_10_rom_otobr
////////////////////////////////////////////////////////////////////////////////
 
class T_roman_num
{
    static const T_10_rom_to_rom_otobr        _10_rom_to_rom_otobr_;
    static const T_primitive_to_10_rom_otobr  primitive_to_10_rom_otobr_;    
    T_str                                     primitive_rom_str_val_;
    bool                                      is_positive_;
public:
    T_roman_num(T_str  str_rom_val) : is_positive_(true)
    {
        while(str_rom_val.find_first_of("+-") == 0)
        {
            if(str_rom_val[0] == '-')
            {
                is_positive_ = !is_positive_;                
            }
            str_rom_val.erase(0, 1);
        }
        
        primitive_rom_str_val_ 
            = primitive_to_10_rom_otobr_.obratn(_10_rom_to_rom_otobr_.obratn(str_rom_val));
    }
    //--------------------------------------------------------------------------------
    T_roman_num(int int_num = 0) : is_positive_(int_num >= 0)
    {   
        int_num = abs(int_num);
        while(int_num--)
        {
            primitive_rom_str_val_.push_back('I');
        }
    }
    //--------------------------------------------------------------------------------
    int  to_int() const
    {
        int sign = is_positive_ ? 1 : -1;
        return  primitive_rom_str_val_.length() * sign;
    }
    //--------------------------------------------------------------------------------
    T_str  to_T_str() const    
    {
        T_str  signum_str  = is_positive_ ? T_str() : T_str(1, '-');
        T_str  module_str  
            = _10_rom_to_rom_otobr_(primitive_to_10_rom_otobr_(primitive_rom_str_val_)); 
        return empty() ? "EMPTY" : signum_str + module_str;
    }
    //--------------------------------------------------------------------------------
    T_roman_num  add_modules(T_roman_num  roman_num)
    {
        return primitive_rom_str_val_ + roman_num.primitive_rom_str_val_;              
    }
    //--------------------------------------------------------------------------------
    T_roman_num  subtraction_modules(T_roman_num  vychitaemoe)
    {
        T_roman_num  res_roman_num(primitive_rom_str_val_);        
        while(   !res_roman_num.primitive_rom_str_val_.empty() 
              && !vychitaemoe.primitive_rom_str_val_  .empty())
        {
            res_roman_num.primitive_rom_str_val_.erase(0, 1);
            vychitaemoe  .primitive_rom_str_val_.erase(0, 1);
        }
        if(!vychitaemoe.primitive_rom_str_val_.empty())
        {
            res_roman_num.primitive_rom_str_val_ = vychitaemoe.primitive_rom_str_val_;
            res_roman_num.is_positive_           = !is_positive_;            
        } 
        return  res_roman_num;
    }
    //--------------------------------------------------------------------------------
    T_roman_num  operator+ (T_roman_num  roman_num)
    {
        T_roman_num  res_roman_num;
        if(is_positive_ == roman_num.is_positive_)
        {
            res_roman_num = add_modules(roman_num);
        }
        else
        {
            res_roman_num = subtraction_modules(roman_num);
        }
 
        if(!is_positive_)
        {
            res_roman_num.is_positive_ = !res_roman_num.is_positive_;
        }
        return  res_roman_num;          
    }
    //--------------------------------------------------------------------------------
    T_roman_num  operator- (T_roman_num  roman_num)
    {
        T_roman_num  res_roman_num;
        if(is_positive_ == roman_num.is_positive_)
        {
            res_roman_num = subtraction_modules(roman_num);
        }
        else
        {
            res_roman_num = add_modules(roman_num);
        }
 
        if(!is_positive_)
        {
            res_roman_num.is_positive_ = !res_roman_num.is_positive_;
        }
        return  res_roman_num;
    }
    //--------------------------------------------------------------------------------
    T_roman_num  multiply_modules(T_roman_num  mnozhitel)
    {
        T_roman_num  res_roman_num;        
        while(!mnozhitel.primitive_rom_str_val_.empty())
        {            
            res_roman_num = res_roman_num.add_modules(*this);
            mnozhitel.primitive_rom_str_val_.erase(0, 1);            
        }
        return  res_roman_num;
    }
    //--------------------------------------------------------------------------------
    T_roman_num  operator* (T_roman_num  mnozhitel)
    {
        T_roman_num  res_roman_num = multiply_modules(mnozhitel);
        if(is_positive_ && !mnozhitel.is_positive_
           || !is_positive_ && mnozhitel.is_positive_)
        {
            res_roman_num.is_positive_ = !res_roman_num.is_positive_;   
        }
        return  res_roman_num;       
    }
    //--------------------------------------------------------------------------------    
    T_roman_num  div_modules(T_roman_num  delitel)
    {        
        T_roman_num  delimoe(primitive_rom_str_val_);        
        T_roman_num  res_roman_num;        
        if(!delitel.empty())
        {
            while(delimoe.primitive_rom_str_val_.length() 
                  >= delitel.primitive_rom_str_val_.length())
            {
                delimoe = delimoe.subtraction_modules(delitel);                
                res_roman_num.primitive_rom_str_val_.push_back('I');
            }        
        }
        return  res_roman_num;
    }   
    //--------------------------------------------------------------------------------
    T_roman_num  operator/ (T_roman_num  delitel)
    {
        T_roman_num  res_roman_num = div_modules(delitel);
        if(is_positive_ && !delitel.is_positive_
           || !is_positive_ && delitel.is_positive_)
        {
            res_roman_num.is_positive_ = !res_roman_num.is_positive_;   
        }
        return  res_roman_num;       
    }
    //--------------------------------------------------------------------------------
    bool empty() const
    {
        return primitive_rom_str_val_.empty();
    }
    
};//class T_roman_num
////////////////////////////////////////////////////////////////////////////////
 
//Определение статических переменных класса.
const T_10_rom_to_rom_otobr        T_roman_num::_10_rom_to_rom_otobr_;
const T_primitive_to_10_rom_otobr  T_roman_num::primitive_to_10_rom_otobr_;
 
////////////////////////////////////////////////////////////////////////////////
std::ostream& operator<<(std::ostream& os, const T_roman_num&  roman_num)
{   
    os << roman_num.to_T_str();
    return os;
}
////////////////////////////////////////////////////////////////////////////////
 
int main()
{
    std::locale::global(std::locale("rus"));
    for(;;)
    {       
        std::cout << "Введите первое число: ";
        int num1;
        std::cin >> num1;
        std::cout << "Введите второе число: ";
        int num2;
        std::cin >> num2;
 
        T_roman_num  rom_from_int1(num1);
        T_roman_num  rom_from_int2(num2);
        std::cout << rom_from_int1
                  << " ("
                  << rom_from_int1.to_int()
                  << ")"
                  << std::endl
                  << rom_from_int2
                  << " ("
                  << rom_from_int2.to_int()
                  << ")"
                  << std::endl            
                  << rom_from_int1
                  << " + " 
                  << rom_from_int2
                  << " = " << rom_from_int1 + rom_from_int2 
                  << std::endl 
                  << std::endl
 
                  << rom_from_int1
                  << " - " 
                  << rom_from_int2
                  << " = " << rom_from_int1 - rom_from_int2
                  << std::endl 
                  << std::endl 
 
                  << rom_from_int1
                  << " * " 
                  << rom_from_int2
                  << " = " << rom_from_int1 * rom_from_int2
                  << std::endl 
                  << std::endl
 
                  << rom_from_int1
                  << " / " 
                  << rom_from_int2
                  << " = " << rom_from_int1 / rom_from_int2
                  << std::endl 
                  << std::endl;       
        
        std::cout << "Введите первое римское число (можно со знаком): ";
        T_str rim1;
        std::cin >> rim1;
        std::cout << "Введите второе римское число (можно со знаком): ";
        T_str rim2;
        std::cin >> rim2;
 
        T_roman_num  rom_from_rim1(rim1);
        T_roman_num  rom_from_rim2(rim2);
        std::cout << rom_from_rim1
                  << " ("
                  << rom_from_rim1.to_int()
                  << ")"
                  << std::endl
                  << rom_from_rim2
                  << " ("
                  << rom_from_rim2.to_int()
                  << ")"
                  << std::endl            
                  << rom_from_rim1
                  << " + " 
                  << rom_from_rim2
                  << " = " << rom_from_rim1 + rom_from_rim2 
                  << std::endl 
                  << std::endl
 
                  << rom_from_rim1
                  << " - " 
                  << rom_from_rim2
                  << " = " << rom_from_rim1 - rom_from_rim2
                  << std::endl 
                  << std::endl 
 
                  << rom_from_rim1
                  << " * " 
                  << rom_from_rim2
                  << " = " << rom_from_rim1 * rom_from_rim2
                  << std::endl 
                  << std::endl
 
                  << rom_from_rim1
                  << " / " 
                  << rom_from_rim2
                  << " = " << rom_from_rim1 / rom_from_rim2
                  << std::endl 
                  << std::endl;        
    }
    return 0;
}