#include <iostream>
#include <string>
#include <sstream>
using namespace std;

const string SYMBOLES = "MDCLXVI";
const int NOMBRES_SYMBOLES = 7;
const int VALEURS_SYMBOLES[NOMBRES_SYMBOLES] = {1000, 500, 100, 50, 10, 5, 1};

string arabToRoman(int arabe)
{
    //On commence par tester si le nombre est valide
    if (arabe < 1 || arabe > 4999)
        throw string("Le nombre doit être compris entre 1 et 4999");

    //La chaine que l'on va renvoyer
    string romain;

    for (int j=0; j<NOMBRES_SYMBOLES; j+=2)
    {
        int i=0;

        //On compte le nombre de symboles d'un type donné à écrire
        for (i = 0; i<arabe/VALEURS_SYMBOLES[j]; ++i)
            romain += SYMBOLES[j];

        //On supprime ce qu'on a ajouté du nombre arabe
        arabe -= i*VALEURS_SYMBOLES[j];
    }

    //Simplifcation---------------------------------------------------

    for (int j=2; j<NOMBRES_SYMBOLES; j+=2)
    {
        //On crée une flux sur une chaine de caractère pour pouvoir écrire des nombres dedans.
        ostringstream flux;

        //On remplace les symboles repetes par les chaines raccourcies
        switch (romain.rfind(SYMBOLES[j]) - romain.find(SYMBOLES[j]) + 1)
        {
        case 9:
            flux << SYMBOLES[j] << SYMBOLES[j-2];
            romain.replace(romain.find(SYMBOLES[j]), 9, flux.str());
            break;
        case 8:
            flux << SYMBOLES[j-1] << SYMBOLES[j] << SYMBOLES[j] << SYMBOLES[j];
            romain.replace(romain.find(SYMBOLES[j]), 8, flux.str());
            break;
        case 7:
            flux << SYMBOLES[j-1] << SYMBOLES[j] << SYMBOLES[j];
            romain.replace(romain.find(SYMBOLES[j]), 7, flux.str());
            break;
        case 6:
            flux << SYMBOLES[j-1] << SYMBOLES[j];
            romain.replace(romain.find(SYMBOLES[j]), 6, flux.str());
            break;
        case 5:
            flux << SYMBOLES[j-1];
            romain.replace(romain.find(SYMBOLES[j]), 5, flux.str());
            break;
        case 4:
            flux << SYMBOLES[j] << SYMBOLES[j-1];
            romain.replace(romain.find(SYMBOLES[j]), 4, flux.str());
            break;
        default:
            break;
        }
    }

    //On renvoit la chaine
    return romain;
}

int romanToArab(const string& roman)
{
    //On verifie que la chaine ne contient que des symboles autorises
    if (roman.find_first_not_of(SYMBOLES) != string::npos)
        throw string("Symbole incorrect dans le nombre (Règle 0)");

    int arabe = 0;
    int derniereValeur = 0;
    int plusGrandeValeur = 0;

    //On parcourt la chaine a l'envers
    for (int pos = roman.size()-1; pos>=0; --pos)
    {
        //On cherche la valeur du symbole actuel
        const int valeur = VALEURS_SYMBOLES[SYMBOLES.find(roman[pos])];

        //Si le symbole actuel est plus grand que celui a sa droite on additione le symbole
        if (valeur >= derniereValeur)
        {
            //Si le symbole est plus petit que un de ceux à sa droite, c'est une erreur
            if(valeur < plusGrandeValeur)
                throw string("Ordre des symboles incorrects (Règle 1)");

            //Sinon, c'est bon. On additionne donc
            arabe += valeur;
        }
        //Sinon on est dans le cas d'une "soustraction"
        else
        {
            //On verifie que la soustraction est valable
            if (derniereValeur != 5*valeur && derniereValeur != 10*valeur)
                throw string("Soustraction invalide (Règle 3)");

            //Si c'est bon on retranche
            arabe -= valeur;
        }

        derniereValeur = valeur;
        if(valeur > plusGrandeValeur)
            plusGrandeValeur = valeur;
    }

    //On verifie que le nombre que l'utilisateur a entre n'était en fait pas trop grand
    if (arabe < 1 || arabe > 4999)
        throw string("Le nombre doit être compris entre 1 et 4999 (Règle 4)");

    //On vérifie si c'était bien la version la plus courte
    if (roman != arabToRoman(arabe))
    {
        ostringstream flux;
        flux << "Le nombre doit être écrit dans sa forme la plus courte (Règle 5)\nLa version correcte est: " <<arabToRoman(arabe);
        flux << ". Ce qui donne " << arabe << " en chiffres arabes.";

        throw flux.str();
    }

    return arabe;
}

int main()
{
    try
    {
        cout << "Conversion de 3593: " << flush;
        cout << arabToRoman(3593) << endl;
        cout << "Conversion de MMDCCM: " << flush;
        cout << romanToArab("MMDCCM") << endl;
    }
    catch (string& e)
    {
        cerr << "\nERREUR: " << e << endl;
    }
    return 0;
}

#include <iostream>

/*****************************************************************************/
/* Template utilitaire
/*****************************************************************************/

// Classe représentant un entier
template <int _Number>
struct Integer
{
	enum { Value = _Number };
};

// Classe représentant une liste
template <class _Data, class _Next>
struct List
{
	typedef _Data Data;
	typedef _Next Next;
};

// Converti une liste de caractères en chaîne de caractères
template <class _List>
struct String
{
	String(): m_data(_List::Data::Value) {};

	const char m_data;
	String<typename _List::Next> m_next;

private:
	String<_List> & operator =(const String<_List> &);
};

template <>
struct String<void>
{
	String(): m_data('\0') {};

	const char m_data;

private:
	String<void> & operator =(const String<void> &);
};

// Macros pour faciliter l'écriture de chaînes de caractères
#define EXPAND(args)			args
#define METASTRINGNULL			void
#define METASTRING1(c)			List<Integer<c>, METASTRINGNULL>
#define METASTRING2(c, ...)		List<Integer<c>, EXPAND(METASTRING1(__VA_ARGS__))>
#define METASTRING3(c, ...)		List<Integer<c>, EXPAND(METASTRING2(__VA_ARGS__))>
#define METASTRING4(c, ...)		List<Integer<c>, EXPAND(METASTRING3(__VA_ARGS__))>
#define METASTRING5(c, ...)		List<Integer<c>, EXPAND(METASTRING4(__VA_ARGS__))>
#define METASTRING6(c, ...)		List<Integer<c>, EXPAND(METASTRING5(__VA_ARGS__))>
#define METASTRING7(c, ...)		List<Integer<c>, EXPAND(METASTRING6(__VA_ARGS__))>
#define METASTRING8(c, ...)		List<Integer<c>, EXPAND(METASTRING7(__VA_ARGS__))>
#define METASTRING9(c, ...)		List<Integer<c>, EXPAND(METASTRING8(__VA_ARGS__))>
#define METASTRING10(c, ...)	List<Integer<c>, EXPAND(METASTRING9(__VA_ARGS__))>
#define METASTRING11(c, ...)	List<Integer<c>, EXPAND(METASTRING10(__VA_ARGS__))>
#define METASTRING12(c, ...)	List<Integer<c>, EXPAND(METASTRING11(__VA_ARGS__))>
#define METASTRING13(c, ...)	List<Integer<c>, EXPAND(METASTRING12(__VA_ARGS__))>
#define METASTRING14(c, ...)	List<Integer<c>, EXPAND(METASTRING13(__VA_ARGS__))>
#define METASTRING15(c, ...)	List<Integer<c>, EXPAND(METASTRING14(__VA_ARGS__))>
#define METASTRING16(c, ...)	List<Integer<c>, EXPAND(METASTRING15(__VA_ARGS__))>

/*****************************************************************************/
/* Définitions pour les chiffres romains
/*****************************************************************************/

// Structure contenant les informations d'un symbole romain
template <char _Letter, unsigned _Number, class _Subtract = void >
struct RomanSymbol
{
	typedef Integer<_Letter> Letter;
	typedef Integer<_Number> Number;
	typedef _Subtract Subtract;
};

// Symboles romains utilisés
typedef RomanSymbol<'I',    1>		I;
typedef RomanSymbol<'V',    5, I>	V;
typedef RomanSymbol<'X',   10, I>	X;
typedef RomanSymbol<'L',   50, X>	L;
typedef RomanSymbol<'C',  100, X>	C;
typedef RomanSymbol<'D',  500, C>	D;
typedef RomanSymbol<'M', 1000, C>	M;

// Liste contenant tous les symbols romains utilisés
typedef List<M, List<D, List<C, List<L, List<X, List<V, List<I, void> > > > > > > RomanSymbols;

/*****************************************************************************/
/* Conversion arabes -> romains
/*****************************************************************************/

// ConvertToRoman:
// Convertit _Number en _Symbols
template <int _Number, class _Symbols>
struct ConvertToRoman;

// ConvertToRomanSubtract:
// Essayes d'insérer une soustraction dans la conversion de _Number en _Symbols
template <int _Number, class _Symbols>
struct ConvertToRomanSubtract;

// ConvertToRomanSubtract_Test<true>
// Insérer une soustraction est possible
template <bool _Test, int _Number, class _Symbols>
struct ConvertToRomanSubtract_Test
{
	typedef
		List<
			typename _Symbols::Data::Subtract::Letter,
			List<
				typename _Symbols::Data::Letter,
				typename ConvertToRoman<
					_Number - _Symbols::Data::Number::Value + _Symbols::Data::Subtract::Number::Value,
					typename _Symbols::Next>::Result > >
		Result;
};

// ConvertToRomanSubtract_Test<false>
// Pas possible de placer une soustraction, converti le nombre avec les symboles suivants
template <int _Number, class _Symbols>
struct ConvertToRomanSubtract_Test<false, _Number, _Symbols>
{
	typedef typename ConvertToRoman<_Number, typename _Symbols::Next>::Result Result;
};

template <int _Number, class _Symbols>
struct ConvertToRomanSubtract
{
	typedef 
		typename ConvertToRomanSubtract_Test<
			(_Number >= _Symbols::Data::Number::Value - _Symbols::Data::Subtract::Number::Value),
			_Number,
			_Symbols>::Result
		Result;
};

// ConvertToRoman_Test<true>
// Le premier symbole est insérable en début de la chaîne de caractères,
// on l'insère et on converti le reste du nombre
template <bool _Test, int _Number, class _Symbols>
struct ConvertToRoman_Test
{
	typedef
		List<
			typename _Symbols::Data::Letter,
			typename ConvertToRoman<_Number - _Symbols::Data::Number::Value, _Symbols>::Result
		> Result;
};

// ConvertToRoman_Test<false>
// Le premier symbole n'est pas insérable,
// on essaye avec une soustraction
template <int _Number, class _Symbols>
struct ConvertToRoman_Test<false, _Number, _Symbols>
{
	typedef
		typename ConvertToRomanSubtract<_Number, _Symbols>::Result
		Result;
};

template <int _Number, class _Symbols>
struct ConvertToRoman
{
	typedef
		typename ConvertToRoman_Test<
			(_Number >= _Symbols::Data::Number::Value),
			_Number,
			_Symbols >::Result
		Result;
};

// Condition de fin:
// Le nombre est 0, il n'y a plus rien à convertir
template <class _Symbols>
struct ConvertToRoman<0, _Symbols>
{
	typedef void Result;
};

/*****************************************************************************/
/* Conversion romains -> arabes
/*****************************************************************************/

template <char _Symbol>
struct SymbolNotValid;

// ConvertToArabic:
// Convertit la liste de symboles _String en nombre
template <class _String, class _Symbols>
struct ConvertToArabic;

// ConvertToArabicSubtract:
// Teste si les premiers symboles de _String sont une soustraction
template <class _String, class _Symbols>
struct ConvertToArabicSubtract;

// ConvertToArabicSubtract_Test<true>
// Les deux premiers symboles sont une soustraction,
// on converti les symboles suivants et on l'ajoute à la soustraction
template <bool _Test, class _String, class _Symbols>
struct ConvertToArabicSubtract_Test
{
	enum {
		Value = _Symbols::Data::Number::Value - _Symbols::Data::Subtract::Number::Value +
		ConvertToArabic<typename _String::Next::Next, typename _Symbols::Next>::Value
	};
};

// ConvertToArabicSubtract_Test<false>
// Les deux premiers symboles ne sont pas une soustraction
template <class _String, class _Symbols>
struct ConvertToArabicSubtract_Test<false, _String, _Symbols>
{
	enum {
		Value = ConvertToArabic<_String, typename _Symbols::Next>::Value
	};
};

template <class _String, class _Symbols>
struct ConvertToArabicSubtract
{
	enum {
		Value = ConvertToArabicSubtract_Test<
			static_cast<int>(_String::Data::Value) == static_cast<int>(_Symbols::Data::Subtract::Letter::Value) &&
			static_cast<int>(_String::Next::Data::Value) == static_cast<int>(_Symbols::Data::Letter::Value),
			_String,
			_Symbols>::Value
	};
};

// La liste ne contient qu'un symbole, ça ne peut être une soustraction
template <class _Char, class _Symbols>
struct ConvertToArabicSubtract<List<_Char, void>, _Symbols>
{
	enum {
		Value = ConvertToArabic<List<_Char, void>, typename _Symbols::Next>::Value
	};
};

// Le symbole à tester n'accepte pas de soustraction, on passe le test
template <class _String, char _Letter, unsigned _Number, class _Next>
struct ConvertToArabicSubtract<_String, List<RomanSymbol<_Letter, _Number, void>, _Next> >
{
	enum {
		Value = ConvertToArabic<_String, _Next>::Value
	};
};

// Si on a passé tous les symboles sans succès, on signale une erreur
template <class _String>
struct ConvertToArabicSubtract<_String, void>
{
	enum { Error = sizeof(SymbolNotValid<_String::Data::Value>) };
};

// ConvertToArabic_Test<true>
// On a trouvé le premier symbole de _String, on fait la conversion,
// et on passe au suivant
template <bool _Test, class _String, class _Symbols>
struct ConvertToArabic_Test
{
	enum {
		Value = _Symbols::Data::Number::Value + ConvertToArabic<typename _String::Next, _Symbols>::Value
	};
};

// ConvertToArabic_Test<false>
// Le premier symbole de _String n'est pas le premier symbole de _Symbols,
// on vérifie que ce ne soit pas une soustraction
template <class _String, class _Symbols>
struct ConvertToArabic_Test<false, _String, _Symbols>
{
	enum {
		Value = ConvertToArabicSubtract<_String, _Symbols>::Value
	};
};

template <class _String, class _Symbols>
struct ConvertToArabic
{
	enum {
		Value = ConvertToArabic_Test<static_cast<int>(_String::Data::Value) == static_cast<int>(_Symbols::Data::Letter::Value), _String, _Symbols>::Value
	};
};

// On a parcouru toutes la liste de symbole avec succès
template <class _Symbols>
struct ConvertToArabic<void, _Symbols>
{
	enum { Value = 0 };
};

// Un symbole de la liste n'a pas pu être trouvé, on signale une erreur
template <class _String>
struct ConvertToArabic<_String, void>
{
	enum { Error = sizeof(SymbolNotValid<_String::Data::Value>) };
};

/*****************************************************************************/
/* Programme de test
/*****************************************************************************/

#define ARABIC_NUMBER 2938
#define ROMAN_NUMBER METASTRING8('M', 'C', 'M', 'L', 'X', 'I', 'X', 'V')

String<ConvertToRoman<ARABIC_NUMBER, RomanSymbols>::Result> ArabicString;
String<ROMAN_NUMBER> RomanString;

int main()
{
	std::cout << ARABIC_NUMBER << " equivaut a " << &ArabicString.m_data << std::endl;
	std::cout << &RomanString.m_data << " equivaut a " << ConvertToArabic<ROMAN_NUMBER, RomanSymbols>::Value << std::endl;

	return 0;
}