Converts a number into its litteral french translation

french_number_writer.cpp

#include <iostream>
#include <map>
#include <sstream>

/**
* Converts a number into its french representation
*
* @see http://fr.wikipedia.org/wiki/Adjectif_num%C3%A9ral
*/
class Convertisseur
{
  std::map<int,std::string> m_basis;
  std::string m_suffixe_pluriel;
  std::string m_espace;
  std::string m_vide;

  std::string traiter_inferieur_1000(int i, bool is_last_number = true) const
  {
    int centaines = i / 100;
    int reste_centaines = i % 100;
    int dizaines = reste_centaines / 10;
    int unites = reste_centaines % 10;

    std::ostringstream result_stream;
    if(0 < centaines) {
      result_stream << traiter_centaines(centaines, dizaines, unites, is_last_number);
    }
    if(1 < dizaines) {
      result_stream << traiter_dizaines(centaines, dizaines, unites, is_last_number);
    }
    if(1 == dizaines || 7 == dizaines || 9 == dizaines || 0 < unites) {
      result_stream << traiter_unites(centaines, dizaines, unites, is_last_number);
    }

    if(!is_last_number) {
      result_stream << m_espace;
    }

    return result_stream.str();
  }

  std::string traiter_centaines(int iCentaines, int iDizaines, int iUnites, bool is_last_number) const
  {
    std::ostringstream result_stream;
    if(1 < iCentaines) {
      result_stream << m_basis.find(iCentaines) -> second << m_espace;
    }
    result_stream << "cent";
    if(1 < iCentaines && 0 == iDizaines && 0 == iUnites && is_last_number) {
      result_stream << m_suffixe_pluriel;
    }

    if(0 < iDizaines || 0 < iUnites) {
      result_stream << m_espace;
    }

    return result_stream.str();
  }

  std::string traiter_dizaines(int iCentaines, int iDizaines, int iUnites, bool is_last_number) const
  {
    std::ostringstream result_stream;
    if(iDizaines < 8) {
      result_stream << m_basis.find( (7==iDizaines) ? 60 : 10*iDizaines ) -> second;
      if(1 == iUnites) {
        result_stream << " et ";
      }
      else if(1 < iUnites || 7 == iDizaines || 9 == iDizaines) {
        result_stream << "-";
      }
    }
    else {
      result_stream << m_basis.find(4)->second << "-" << m_basis.find(20)->second;
      if(8 == iDizaines && 0 == iUnites && is_last_number) {
          result_stream << m_suffixe_pluriel;
      }
      if(0 < iUnites || 9 == iDizaines) {
        result_stream << "-";
      }
    }

    return result_stream.str();
  }

  std::string traiter_unites(int iCentaines, int iDizaines, int iUnites, bool is_last_number) const
  {
    std::ostringstream result_stream;
    int offset = (1 == iDizaines || 7 == iDizaines || 9 == iDizaines) ? 10 : 0;
    result_stream << m_basis.find(offset + iUnites)->second;
    return result_stream.str();
  }

public:
  Convertisseur() : m_suffixe_pluriel("s"), m_espace(" ")
  {
    m_basis.insert(std::make_pair(0,"zero"));
    m_basis.insert(std::make_pair(1,"un"));
    m_basis.insert(std::make_pair(2,"deux"));
    m_basis.insert(std::make_pair(3,"trois"));
    m_basis.insert(std::make_pair(4,"quatre"));
    m_basis.insert(std::make_pair(5,"cinq"));
    m_basis.insert(std::make_pair(6,"six"));
    m_basis.insert(std::make_pair(7,"sept"));
    m_basis.insert(std::make_pair(8,"huit"));
    m_basis.insert(std::make_pair(9,"neuf"));
    m_basis.insert(std::make_pair(10,"dix"));
    m_basis.insert(std::make_pair(11,"onze"));
    m_basis.insert(std::make_pair(12,"douze"));
    m_basis.insert(std::make_pair(13,"treize"));
    m_basis.insert(std::make_pair(14,"quatorze"));
    m_basis.insert(std::make_pair(15,"quinze"));
    m_basis.insert(std::make_pair(16,"seize"));
    m_basis.insert(std::make_pair(17,"dix-sept"));
    m_basis.insert(std::make_pair(18,"dix-huit"));
    m_basis.insert(std::make_pair(19,"dix-neuf"));
    m_basis.insert(std::make_pair(20,"vingt")); 
    m_basis.insert(std::make_pair(30,"trente"));
    m_basis.insert(std::make_pair(40,"quarante"));
    m_basis.insert(std::make_pair(50,"cinquante"));
    m_basis.insert(std::make_pair(60,"soixante"));
  }

  virtual ~Convertisseur()
  {}

  std::string Convert(int i) const
  {
    std::ostringstream result_stream;
    if(i < 0) {
      result_stream << "moins ";
      i = -i;
    }

    int milliards = i / 1000000000;
    int reste_milliards = i % 1000000000;
    int millions = reste_milliards / 1000000;
    int reste_millions = reste_milliards % 1000000;
    int milliers = reste_millions / 1000;
    int reste_milliers = reste_millions % 1000;
    
    if(0 < milliards) {
      result_stream << traiter_inferieur_1000(milliards,false) << "milliard" << ((1 < milliards) ? m_suffixe_pluriel : m_vide) << ((millions || milliers || reste_milliers) ? m_espace : m_vide);
    }

    if(0 < millions) {
      result_stream << traiter_inferieur_1000(millions,false) << "million" << ((1 < millions) ? m_suffixe_pluriel : m_vide) << ((milliers || reste_milliers) ? m_espace : m_vide);
    }

    if(0 < milliers) {
      result_stream << (1 < milliers ? traiter_inferieur_1000(milliers,false) : m_vide) << "mille" << (reste_milliers ? m_espace : m_vide);
    }

    result_stream << traiter_inferieur_1000(reste_milliers);
    
    return result_stream.str();
  }
};
 
int main (int argc, char * argv[])
{
  Convertisseur convertisseur;
  
  int test = 1080;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 75;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 301;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 153;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 2000300016;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 1001001001;
  std::cout << convertisseur.Convert(test) << std::endl;

  test = 2120571095;
  std::cout << convertisseur.Convert(test) << std::endl;
  
	return 0;
}