Qual é o objectivo de pedirem um programa para fazer conversões se nem as contas fazes?, já agora..., usa uma variável do tipo "String" para guardares os resultados das conversões..., senão vais ter problemas
Por isso é que dizem que c++ é muito poderosa 
ya ya, de facto isso faz-te a papinha toda..., mas suponho que o pretendido seja mesmo ele estudar a forma de converter os numeros..., tal como o Alph referiu a unica que é capaz de trazer um pouco mais de complicação é decimal para romana..., de resto são apenas divisõesScOrpion-boy disse:
): 
; decimal->roman : integer -> string
; format the integer num using roman numerals
(define (decimal->roman num)
(let ((decimal-numbers (list 1000 900 500 400 100 90 50 40 10 9 5 4 1))
(roman-numbers (list "M" "CM" "D" "CD" "C" "XC" "L"
"XL" "X" "IX" "V" "IV" "I")))
(decimal->roman-aux num "" decimal-numbers roman-numbers)))
; decimal->roman-aux : integer string (list number) (list string) -> string
; append the numbers num formatted as roman numerals to the string s,
; using the roman numerals in roman-numbers with corresponding
; decimal values in decimal-values
(define (decimal->roman-aux num s decimal-numbers roman-numbers)
(if (null? decimal-numbers)
s
(if (>= num (car decimal-numbers))
(decimal->roman-aux (- num (car decimal-numbers))
(string-append s (car roman-numbers))
decimal-numbers roman-numbers)
(decimal->roman-aux num s
(cdr decimal-numbers) (cdr roman-numbers)))))
Dava para simplificares isso BEM MAIS e alargares facilmente para mil..., ou mais.../* to_roman.c -- convert a value to a roman string */
/* $Id$ */
/* Carlos Duarte, 950816/980104 */
/*
* int to_roman(unsigned int rval, char *str, size_t max);
* converts `rval', into a string that represents that value in
* roman, and write results on `str', but no more than `max' chars
* (including the final \0)
*
* The above is all that is necessary to use this file: just compile it,
* with no special options, to get code for `to_roman()' function
*
* --
*
* But, to go further:
*
* . there are 3 != implementations, each can be obtained by defining ROMAN
* to a number (1 for first, 2 for second and 3 for third)
*
* . the first is the default
*
* . also, a test is provided, define -DTEST to get it
*
* . and a demo, which is obtained with -DDEMO
*
* . and finally, a PROF, that measure time performance of the three routines,
* this is obtained with -DPROF.
* Also, with -DPROF, also -DTOP_ROMAN will be recognized as 1 .. TOP_ROMAN
* values to convert
*
* --
*
* As for the algorithms: the first, use a table with all possible
* combinations of roman digits or pairs, and keep removing
* the biggest value, while it can. This is the faster.
*
* The other two, use the same algorithm, but implemented
* on a diferent way. The roman value, is parsed from lowest
* to greatest digit (as oposed above). But, while `to_roman2'
* does a base of 10, then base of 5 way of convert, `to_roman3'
* use only a base of 10 parser and convert all possible
* 10 digits directly. `to_roman2' use symmetry to convert 6-9
* into 1-5, and then convert only 1-5.
*
* As for time speed, #1 > #3 > #2.
*/
#ifndef ROMAN
#define ROMAN 1
#endif
#if ROMAN == 1
/*=======================================================================*/
#include <stddef.h>
const static struct roman_table {
int val;
char *sym;
} r_tab[] = {
{ 1000, "M" },
{ 900, "CM" },
{ 500, "D" },
{ 400, "CD" },
{ 100, "C" },
{ 90, "XC" },
{ 50, "L" },
{ 40, "XL" },
{ 10, "X" },
{ 9, "IX" },
{ 5, "V" },
{ 4, "IV" },
{ 1, "I" }
};
int
to_roman(unsigned int rval, char *str, size_t max)
{
const struct roman_table *t;
char *s, *top;
if (max < 3)
return 0;
s = str;
top = s+(max-3); /* save space for 3 chars write */
t = r_tab;
while (rval) {
while (rval >= t->val) {
if (s > top)
return (*s=0)-1;
rval -= t->val;
*s++ = t->sym[0];
if (t->sym[1])
*s++ = t->sym[1];
}
t++;
}
*s = 0;
return s-str;
}
#endif /* ROMAN == 1 */
#if ROMAN == 2
/*=======================================================================*/
#include <stddef.h>
static const char rr_dig[] = "IVXLCDM";
int
to_roman(unsigned int rval, char *str, size_t max)
{
const char *r, *top;
char *s;
int dig;
if (max < 5)
return 0;
r = rr_dig;
s = str;
top = s+(max-5); /* ensure space for 5 chars write */
while (rval) {
if (s > top)
return (*s=0)-1;
dig = rval%10;
rval /= 10;
if (dig != 0) {
int c0, c1, c2;
c1 = r[0];
c0 = 0;
c2 = r[1];
if (dig > 5) {
dig -= 5;
c0 = r[1];
c2 = r[2];
}
switch (dig) {
case 3: *s++ = c1;
case 2: *s++ = c1;
case 1: *s++ = c1; if (c0) *s++ = c0; break;
case 4: *s++ = c2; *s++ = c1; break;
case 5: *s++ = c2; break;
}
}
if (*++r == 0 || *++r == 0 || r[1] == 0) {
top += 3; /* ensure space for 2 (5-3) chars */
if (rval) do {
if (s > top)
return (*s=0)-1;
*s++ = 'M';
} while (--rval > 0);
}
}
*s = 0;
/* reverse str */
{char*t=s-1;char*tt=str;while(t>tt){int c= *t;*t-- = *tt;*tt++ =c;}}
return s-str;
}
#endif /* ROMAN == 2 */
#if ROMAN == 3
/*=======================================================================*/
#include <stddef.h>
static const char r_dig[] = "IVXLCDM";
int
to_roman(unsigned int rval, char *str, size_t max)
{
const char *r, *top;
char *s;
int dig;
if (max < 5)
return 0;
r = r_dig;
s = str;
top = s+(max-5); /* ensure space for 5 chars write */
while (rval) {
if (s > top)
return (*s=0)-1;
dig = rval%10;
rval /= 10;
switch (dig) {
default:
case 0: break;
case 3: *s++ = r[0];
case 2: *s++ = r[0];
case 1: *s++ = r[0]; break;
case 4: *s++ = r[1]; *s++ = r[0]; break;
case 5: *s++ = r[1]; break;
case 8: *s++ = r[0];
case 7: *s++ = r[0];
case 6: *s++ = r[0]; *s++ = r[1]; break;
case 9: *s++ = r[2]; *s++ = r[0]; break;
}
if (*++r == 0 || *++r == 0 || r[1] == 0) {
top += 3; /* ensure space for 2 (5-3) chars */
if (rval) do {
if (s > top)
return (*s=0)-1;
*s++ = 'M';
} while (--rval > 0);
}
}
*s = 0;
/* reverse str */
{char*t=s-1;char*tt=str;while(t>tt){int c= *t;*t-- = *tt;*tt++ =c;}}
return s-str;
}
#endif /* ROMAN == 3 *//* fr_roman.c -- from roman string to integer */
/* $Id$ */
/* Carlos Duarte, 971226 */
/*
* int fr_roman(const char *str);
*
* converts `str', that should represent a valid
* roman number, to its value
*
* returns the value, or -1, in case the string
* is not valid
*/
int
fr_roman(const char *str)
{
int sum, v, v0;
sum = 0;
v0 = 1001;
for (;;) {
switch (str[0]) {
case 'M': v = 1000; break;
case 'D': v = 500; break;
case 'C': switch (str[1]) {
case 'M': v = 900; str++; break;
case 'D': v = 400; str++; break;
default: v = 100; break;
}
break;
case 'L': v = 50; break;
case 'X': switch (str[1]) {
case 'C': v = 90; str++; break;
case 'L': v = 40; str++; break;
default: v = 10; break;
}
break;
case 'V': v = 5; break;
case 'I': switch (str[1]) {
case 'X': v = 9; str++; break;
case 'V': v = 4; str++; break;
default: v = 1; break;
}
break;
case 0: return sum;
default: return -1;
}
if (v > v0)
break;
v0 = v;
sum += v;
++str;
}
return -1;
}
