Ybadoo - Soluções em Software Livre
Tutoriais
Programação Orientada a Objetos

Desenvolva um conversor de números arábicos, no intervalo de 1 a 999, para números romanos, números arábicos por extenso e números ordinais por extenso.

 

Diagrama de Classes
Diagrama de Classes na Linguagem de Programação Java

Arquivo Number.java

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * OpenJDK Version "1.8.0_121"                                           *
 * OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)               *
 *************************************************************************/

package com.ybadoo.tutoriais.poo.tutorial04.exercicio10;

/**
 * Representação de um número
 */
public abstract class Number
{
  /**
   * Valor do número
   */
  private final int value;

  /**
   * Inicializar o número
   *
   * @param value valor do número
   */
  protected Number(int value)
  {
    if ((value > 0) && (value < 1000))
    {
      this.value = value;
    }
    else if (value < 1)
    {
      this.value = 1;
    }
    else
    {
      this.value = 999;
    }
  }

  /**
   * Retornar o valor da primeira ordem - classe das unidades - ordem das
   * unidades do número
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades do número
   */
  protected int getFirstOrder()
  {
    return value % 10;
  }

  /**
   * Retornar o valor da segunda ordem - classe das unidades - ordem das
   * dezenas do número
   *
   * @return valor da segunda ordem - classe das unidades - ordem das
   * dezenas do número
   */
  protected int getSecondOrder()
  {
    return (value % 100) / 10;
  }

  /**
   * Retornar o valor da terceira ordem - classe das unidades - ordem das
   * centenas do número
   *
   * @return valor da terceira ordem - classe das unidades - ordem das
   * centenas do número
   */
  protected int getThirdOrder()
  {
    return (value % 1000) / 100;
  }

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  protected abstract String[] getFirstOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  protected abstract String[] getSecondOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  protected abstract String[] getThirdOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  protected String convertFirstOrderToString()
  {
    return getFirstOrderWords()[getFirstOrder()];
  }

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  protected String convertSecondOrderToString()
  {
    return getSecondOrderWords()[getSecondOrder()];
  }

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  protected String convertThirdOrderToString()
  {
    return getThirdOrderWords()[getThirdOrder()];
  }

  /**
   * Retornar o separador textual utilizado para separar as ordens numéricas
   *
   * @return separador textual utilizado para separar as ordens numéricas
   */
  protected abstract String getSeparator();

  /**
   * Juntar duas ordens numéricas no formato texto
   *
   * @param biggerOrder ordem numérica maior
   * @param smallerOrder ordem numérica menor
   * @return união de duas ordens numéricas no formato texto
   */
  private String joinOrders(String biggerOrder, String smallerOrder)
  {
    if (smallerOrder != null)
    {
      if (biggerOrder != null)
      {
        return biggerOrder + getSeparator() + smallerOrder;
      }

      return smallerOrder;
    }

    return biggerOrder;
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  @Override
  public String toString()
  {
    String thirdOrderString = joinOrders(null, convertThirdOrderToString());

    String secondOrderString = joinOrders(thirdOrderString,
        convertSecondOrderToString());

    return joinOrders(secondOrderString, convertFirstOrderToString());
  }
}

Arquivo NumberCardinal.java

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * OpenJDK Version "1.8.0_121"                                           *
 * OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)               *
 *************************************************************************/

package com.ybadoo.tutoriais.poo.tutorial04.exercicio10;

/**
 * Representação de um número cardinal
 */
public class NumberCardinal extends Number
{
  /**
   * Inicializar o número cardinal
   *
   * @param value valor do cardinal
   */
  public NumberCardinal(int value)
  {
    super(value);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getFirstOrderWords()
   */
  @Override
  protected String[] getFirstOrderWords()
  {
    return new String[] {null,
                         "um",
                         "dois",
                         "três",
                         "quatro",
                         "cinco",
                         "seis",
                         "sete",
                         "oito",
                         "nove"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSecondOrderWords()
   */
  @Override
  protected String[] getSecondOrderWords()
  {
    return new String[] {null,
                         "dez",
                         "vinte",
                         "trinta",
                         "quarenta",
                         "cinquenta",
                         "sessenta",
                         "setenta",
                         "oitenta",
                         "noventa"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getThirdOrderWords()
   */
  @Override
  protected String[] getThirdOrderWords()
  {
    return new String[] {null,
                         "cento",
                         "duzentos",
                         "trezentos",
                         "quatrocentos",
                         "quinhentos",
                         "seiscentos",
                         "setecentos",
                         "oitocentos",
                         "novecentos"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#convertFirstOrderToString()
   */
  @Override
  protected String convertFirstOrderToString()
  {
    if (getSecondOrder() == 1)
    {
      return null;
    }

    return super.convertFirstOrderToString();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#convertSecondOrderToString()
   */
  @Override
  protected String convertSecondOrderToString()
  {
    if (getSecondOrder() == 1)
    {
      String[] secondOrderSpecial = {"dez",
                                     "onze",
                                     "doze",
                                     "treze",
                                     "catorze",
                                     "quinze",
                                     "dezesseis",
                                     "dezessete",
                                     "dezoito",
                                     "dezenove"};

      return secondOrderSpecial[getFirstOrder()];
    }

    return super.convertSecondOrderToString();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#convertThirdOrderToString()
   */
  @Override
  protected String convertThirdOrderToString()
  {
    if ((getThirdOrder() == 1) &&
        (getSecondOrder() == 0) &&
        (getFirstOrder() == 0))
    {
      return "cem";
    }

    return super.convertThirdOrderToString();
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSeparator()
   */
  @Override
  protected String getSeparator()
  {
    return " e ";
  }
}

Arquivo NumberOrdinal.java

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * OpenJDK Version "1.8.0_121"                                           *
 * OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)               *
 *************************************************************************/

package com.ybadoo.tutoriais.poo.tutorial04.exercicio10;

/**
 * Representação de um número ordinal
 */
public class NumberOrdinal extends Number
{
  /**
   * Inicializar o número ordinal
   *
   * @param value valor do número
   */
  public NumberOrdinal(int value)
  {
    super(value);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getFirstOrderWords()
   */
  @Override
  protected String[] getFirstOrderWords()
  {
    return new String[] {null,
                         "primeiro",
                         "segundo",
                         "terceiro",
                         "quarto",
                         "quinto",
                         "sexto",
                         "sétimo",
                         "oitavo",
                         "nono"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSecondOrderWords()
   */
  @Override
  protected String[] getSecondOrderWords()
  {
    return new String[] {null,
                         "décimo",
                         "vigésimo",
                         "trigésimo",
                         "quadragésimo",
                         "quinquagésimo",
                         "sexagésimo",
                         "septuagésimo",
                         "octogésimo",
                         "nonagésimo"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getThirdOrderWords()
   */
  @Override
  protected String[] getThirdOrderWords()
  {
    return new String[] {null,
                         "centésimo",
                         "ducentésimo",
                         "trecentésimo",
                         "quadringentésimo",
                         "quingentésimo",
                         "sexcentésimo",
                         "septingentésimo",
                         "octingentésimo",
                         "noningentésimo"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSeparator()
   */
  @Override
  protected String getSeparator()
  {
    return " ";
  }
}

Arquivo NumberRoman.java

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * OpenJDK Version "1.8.0_121"                                           *
 * OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)               *
 *************************************************************************/

package com.ybadoo.tutoriais.poo.tutorial04.exercicio10;

/**
 * Representação de um número romano
 */
public class NumberRoman extends Number
{
  /**
   * Inicializar o número romano
   *
   * @param value valor do número romano
   */
  public NumberRoman(int value)
  {
    super(value);
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getFirstOrderWords()
   */
  @Override
  protected String[] getFirstOrderWords()
  {
    return new String[] {null,
                         "I",
                         "II",
                         "III",
                         "IV",
                         "V",
                         "VI",
                         "VII",
                         "VIII",
                         "IX"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSecondOrderWords()
   */
  @Override
  protected String[] getSecondOrderWords()
  {
    return new String[] {null,
                         "X",
                         "XX",
                         "XXX",
                         "XL",
                         "L",
                         "LX",
                         "LXX",
                         "LXXX",
                         "XC"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getThirdOrderWords()
   */
  @Override
  protected String[] getThirdOrderWords()
  {
    return new String[] {null,
                         "C",
                         "CC",
                         "CCC",
                         "CD",
                         "D",
                         "DC",
                         "DCC",
                         "DCCC",
                         "CM"};
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.tutorial04.exercicio10.Number#getSeparator()
   */
  @Override
  protected String getSeparator()
  {
    return "";
  }
}

Arquivo Application.java

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * OpenJDK Version "1.8.0_121"                                           *
 * OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode)               *
 *************************************************************************/

package com.ybadoo.tutoriais.poo.tutorial04.exercicio10;

/**
 * Classe responsavel pela execucao da aplicacao
 */
public class Application
{
  /**
   * Construtor padrao
   */
  private Application()
  {

  }

  /**
   * Metodo principal da linguagem de programacao Java
   *
   * @param args argumentos da linha de comando (nao utilizado)
   */
  public static void main(String[] args)
  {
    Number numberCardinal = new NumberCardinal(123);
    System.out.println(numberCardinal);
    
    Number numberOrdinal = new NumberOrdinal(123);
    System.out.println(numberOrdinal);

    Number numberRoman = new NumberRoman(123);
    System.out.println(numberRoman);
  }
}

Saída da Implementação na Linguagem de Programação Java

cento e vinte e três
centésimo vigésimo terceiro
CXXIII
Diagrama de Classes
Diagrama de Classes na Linguagem de Programação C++

Arquivo Number.hpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include <string>

#ifndef NUMBER_HPP
#define NUMBER_HPP

class Number
{
  public:

  /**
   * Retornar o valor do número por extenso
   *
   * @return valor do número por extenso
   */
  std::string toString();


  protected:

  /**
   * Inicializar o número
   *
   * @param value valor do número
   */
  Number(const int value);

  /**
   * Retornar o valor da primeira ordem - classe das unidades - ordem das
   * unidades do número
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades do número
   */
  int getFirstOrder() const;

  /**
   * Retornar o valor da segunda ordem - classe das unidades - ordem das
   * dezenas do número
   *
   * @return valor da segunda ordem - classe das unidades - ordem das
   * dezenas do número
   */
  int getSecondOrder() const;

  /**
   * Retornar o valor da terceira ordem - classe das unidades - ordem das
   * centenas do número
   *
   * @return valor da terceira ordem - classe das unidades - ordem das
   * centenas do número
   */
  int getThirdOrder() const;

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  virtual std::string* getFirstOrderWords() = 0;

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  virtual std::string* getSecondOrderWords() = 0;

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  virtual std::string* getThirdOrderWords() = 0;

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  virtual std::string convertFirstOrderToString();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  virtual std::string convertSecondOrderToString();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  virtual std::string convertThirdOrderToString();

  /**
   * Retornar o separador textual utilizado para separar as ordens numéricas
   *
   * @return separador textual utilizado para separar as ordens numéricas
   */
  virtual std::string getSeparator() = 0;


  private:

  /**
   * Valor do número
   */
  int value;

  /**
   * Juntar duas ordens numéricas no formato texto
   *
   * @param biggerOrder ordem numérica maior
   * @param smallerOrder ordem numérica menor
   * @return união de duas ordens numéricas no formato texto
   */
  std::string joinOrders(std::string biggerOrder, std::string smallerOrder);
};

#endif

Arquivo Number.cpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include <iomanip>
#include <sstream>
#include "Number.hpp"

/**
 * Inicializar o número
 *
 * @param value valor do número
 */
Number::Number(const int value)
{
  if ((value > 0) && (value < 1000))
  {
    Number::value = value;
  }
  else if (value < 1)
  {
    Number::value = 1;
  }
  else
  {
    Number::value = 999;
  }
}

/**
 * Retornar o valor da primeira ordem - classe das unidades - ordem das
 * unidades do número
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades do número
 */
int Number::getFirstOrder() const
{
  return value % 10;
}

/**
 * Retornar o valor da segunda ordem - classe das unidades - ordem das
 * dezenas do número
 *
 * @return valor da segunda ordem - classe das unidades - ordem das
 * dezenas do número
 */
int Number::getSecondOrder() const
{
  return (value % 100) / 10;
}

/**
 * Retornar o valor da terceira ordem - classe das unidades - ordem das
 * centenas do número
 *
 * @return valor da terceira ordem - classe das unidades - ordem das
 * centenas do número
 */
int Number::getThirdOrder() const
{
  return (value % 1000) / 100;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 */
std::string Number::convertFirstOrderToString()
{
  return getFirstOrderWords()[getFirstOrder()];
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 */
std::string Number::convertSecondOrderToString()
{
  return getSecondOrderWords()[getSecondOrder()];
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 */
std::string Number::convertThirdOrderToString()
{
  return getThirdOrderWords()[getThirdOrder()];
}

/**
 * Juntar duas ordens numéricas no formato texto
 *
 * @param biggerOrder ordem numérica maior
 * @param smallerOrder ordem numérica menor
 * @return união de duas ordens numéricas no formato texto
 */
std::string Number::joinOrders(std::string biggerOrder,
                               std::string smallerOrder)
{
  if (!smallerOrder.empty())
  {
    if (!biggerOrder.empty())
    {
      using namespace std;

      stringstream buffer;

      buffer << biggerOrder << getSeparator() << smallerOrder;

      return buffer.str();
    }

    return smallerOrder;
  }

  return biggerOrder;
}

/**
 * Retornar o valor do número por extenso
 *
 * @return valor do número por extenso
 */
std::string Number::toString()
{
  std::string thirdOrderString = joinOrders("", convertThirdOrderToString());

  std::string secondOrderString = joinOrders(thirdOrderString,
        convertSecondOrderToString());

  return joinOrders(secondOrderString, convertFirstOrderToString());
}

Arquivo NumberCardinal.hpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "Number.hpp"

#ifndef NUMBERCARDINAL_HPP
#define NUMBERCARDINAL_HPP

/**
 * Representação de um número cardinal
 */
class NumberCardinal : public Number
{
  public:

  /**
   * Inicializar o número cardinal
   *
   * @param value valor do número cardinal
   */
  NumberCardinal(const int value);


  protected:

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  std::string* getFirstOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  std::string* getSecondOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  std::string* getThirdOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  std::string convertFirstOrderToString();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  std::string convertSecondOrderToString();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  std::string convertThirdOrderToString();

  /**
   * Retornar o separador textual utilizado para separar as ordens numéricas
   *
   * @return separador textual utilizado para separar as ordens numéricas
   */
  std::string getSeparator();
};

#endif

Arquivo NumberCardinal.cpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "NumberCardinal.hpp"

/**
 * Inicializar o número cardinal
 *
 * @param value valor do número cardinal
 */
NumberCardinal::NumberCardinal(const int value) : Number(value)
{

}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 */
std::string* NumberCardinal::getFirstOrderWords()
{
  std::string* firstOrderWords = new std::string[10];

  firstOrderWords[0] = "";
  firstOrderWords[1] = "um";
  firstOrderWords[2] = "dois";
  firstOrderWords[3] = "três";
  firstOrderWords[4] = "quatro";
  firstOrderWords[5] = "cinco";
  firstOrderWords[6] = "seis";
  firstOrderWords[7] = "sete";
  firstOrderWords[8] = "oito";
  firstOrderWords[9] = "nove";

  return firstOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 */
std::string* NumberCardinal::getSecondOrderWords()
{
  std::string* secondOrderWords = new std::string[10];

  secondOrderWords[0] = "";
  secondOrderWords[1] = "dez";
  secondOrderWords[2] = "vinte";
  secondOrderWords[3] = "trinta";
  secondOrderWords[4] = "quarenta";
  secondOrderWords[5] = "cinquenta";
  secondOrderWords[6] = "sessenta";
  secondOrderWords[7] = "setenta";
  secondOrderWords[8] = "oitenta";
  secondOrderWords[9] = "noventa";

  return secondOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 */
std::string* NumberCardinal::getThirdOrderWords()
{
  std::string* thirdOrderWords = new std::string[10];

  thirdOrderWords[0] = "";
  thirdOrderWords[1] = "cento";
  thirdOrderWords[2] = "duzentos";
  thirdOrderWords[3] = "trezentos";
  thirdOrderWords[4] = "quatrocentos";
  thirdOrderWords[5] = "quinhentos";
  thirdOrderWords[6] = "seiscentos";
  thirdOrderWords[7] = "setecentos";
  thirdOrderWords[8] = "oitocentos";
  thirdOrderWords[9] = "novecentos";

  return thirdOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 */
std::string NumberCardinal::convertFirstOrderToString()
{
  if (getSecondOrder() == 1)
  {
    return "";
  }

  return Number::convertFirstOrderToString();
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 */
std::string NumberCardinal::convertSecondOrderToString()
{
  if (getSecondOrder() == 1)
  {
    std::string* secondOrderSpecial = new std::string[10];

    secondOrderSpecial[0] = "dez";
    secondOrderSpecial[1] = "onze";
    secondOrderSpecial[2] = "doze";
    secondOrderSpecial[3] = "treze";
    secondOrderSpecial[4] = "catorze";
    secondOrderSpecial[5] = "quinze";
    secondOrderSpecial[6] = "dezesseis";
    secondOrderSpecial[7] = "dezessete";
    secondOrderSpecial[8] = "dezoito";
    secondOrderSpecial[9] = "dezenove";

    return secondOrderSpecial[getFirstOrder()];
  }

  return Number::convertSecondOrderToString();
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 */
std::string NumberCardinal::convertThirdOrderToString()
{
  if ((getThirdOrder() == 1) &&
      (getSecondOrder() == 0) &&
      (getFirstOrder() == 0))
  {
    return "cem";
  }

  return Number::convertThirdOrderToString();
}

/**
 * Retornar o separador textual utilizado para separar as ordens numéricas
 *
 * @return separador textual utilizado para separar as ordens numéricas
 */
std::string NumberCardinal::getSeparator()
{
  return " e ";
}

Arquivo NumberOrdinal.hpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "Number.hpp"

#ifndef NUMBERORDINAL_HPP
#define NUMBERORDINAL_HPP

/**
 * Representação de um número ordinal
 */
class NumberOrdinal : public Number
{
  public:

  /**
   * Inicializar o número ordinal
   *
   * @param value valor do número ordinal
   */
  NumberOrdinal(const int value);


  protected:

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  std::string* getFirstOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  std::string* getSecondOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  std::string* getThirdOrderWords();

  /**
   * Retornar o separador textual utilizado para separar as ordens numéricas
   *
   * @return separador textual utilizado para separar as ordens numéricas
   */
  std::string getSeparator();
};

#endif

Arquivo NumberOrdinal.cpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "NumberOrdinal.hpp"

/**
 * Inicializar o número ordinal
 *
 * @param value valor do número ordinal
 */
NumberOrdinal::NumberOrdinal(const int value) : Number(value)
{

}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 */
std::string* NumberOrdinal::getFirstOrderWords()
{
  std::string* firstOrderWords = new std::string[10];

  firstOrderWords[0] = "";
  firstOrderWords[1] = "primeiro";
  firstOrderWords[2] = "segundo";
  firstOrderWords[3] = "terceiro";
  firstOrderWords[4] = "quarto";
  firstOrderWords[5] = "quinto";
  firstOrderWords[6] = "sexto";
  firstOrderWords[7] = "sétimo";
  firstOrderWords[8] = "oitavo";
  firstOrderWords[9] = "nono";

  return firstOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 */
std::string* NumberOrdinal::getSecondOrderWords()
{
  std::string* secondOrderWords = new std::string[10];

  secondOrderWords[0] = "";
  secondOrderWords[1] = "décimo";
  secondOrderWords[2] = "vigésimo";
  secondOrderWords[3] = "trigésimo";
  secondOrderWords[4] = "quadragésimo";
  secondOrderWords[5] = "quinquagésimo";
  secondOrderWords[6] = "sexagésimo";
  secondOrderWords[7] = "septuagésimo";
  secondOrderWords[8] = "octogésimo";
  secondOrderWords[9] = "nonagésimo";

  return secondOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 */
std::string* NumberOrdinal::getThirdOrderWords()
{
  std::string* thirdOrderWords = new std::string[10];

  thirdOrderWords[0] = "";
  thirdOrderWords[1] = "centésimo";
  thirdOrderWords[2] = "ducentésimo";
  thirdOrderWords[3] = "trecentésimo";
  thirdOrderWords[4] = "quadringentésimo";
  thirdOrderWords[5] = "quingentésimo";
  thirdOrderWords[6] = "sexcentésimo";
  thirdOrderWords[7] = "septingentésimo";
  thirdOrderWords[8] = "octingentésimo";
  thirdOrderWords[9] = "noningentésimo";

  return thirdOrderWords;
}

/**
 * Retornar o separador textual utilizado para separar as ordens numéricas
 *
 * @return separador textual utilizado para separar as ordens numéricas
 */
std::string NumberOrdinal::getSeparator()
{
  return " ";
}

Arquivo NumberRoman.hpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "Number.hpp"

#ifndef NUMBERROMAN_HPP
#define NUMBERROMAN_HPP

/**
 * Representação de um número romano
 */
class NumberRoman : public Number
{
  public:

  /**
   * Inicializar o número romano
   *
   * @param value valor do número romano
   */
  NumberRoman(const int value);


  protected:

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * unidades para texto
   */
  std::string* getFirstOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * dezenas para texto
   */
  std::string* getSecondOrderWords();

  /**
   * Converter o valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   *
   * @return valor da primeira ordem - classe das unidades - ordem das
   * centenas para texto
   */
  std::string* getThirdOrderWords();

  /**
   * Retornar o separador textual utilizado para separar as ordens numéricas
   *
   * @return separador textual utilizado para separar as ordens numéricas
   */
  std::string getSeparator();
};

#endif

Arquivo NumberRoman.cpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include "NumberRoman.hpp"

/**
 * Inicializar o número romano
 *
 * @param value valor do número romano
 */
NumberRoman::NumberRoman(const int value) : Number(value)
{

}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * unidades para texto
 */
std::string* NumberRoman::getFirstOrderWords()
{
  std::string* firstOrderWords = new std::string[10];

  firstOrderWords[0] = "";
  firstOrderWords[1] = "I";
  firstOrderWords[2] = "II";
  firstOrderWords[3] = "III";
  firstOrderWords[4] = "IV";
  firstOrderWords[5] = "V";
  firstOrderWords[6] = "VI";
  firstOrderWords[7] = "VII";
  firstOrderWords[8] = "VIII";
  firstOrderWords[9] = "IX";

  return firstOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * dezenas para texto
 */
std::string* NumberRoman::getSecondOrderWords()
{
  std::string* secondOrderWords = new std::string[10];

  secondOrderWords[0] = "";
  secondOrderWords[1] = "X";
  secondOrderWords[2] = "XX";
  secondOrderWords[3] = "XXX";
  secondOrderWords[4] = "XL";
  secondOrderWords[5] = "L";
  secondOrderWords[6] = "LX";
  secondOrderWords[7] = "LXX";
  secondOrderWords[8] = "LXXX";
  secondOrderWords[9] = "XC";

  return secondOrderWords;
}

/**
 * Converter o valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 *
 * @return valor da primeira ordem - classe das unidades - ordem das
 * centenas para texto
 */
std::string* NumberRoman::getThirdOrderWords()
{
  std::string* thirdOrderWords = new std::string[10];

  thirdOrderWords[0] = "";
  thirdOrderWords[1] = "C";
  thirdOrderWords[2] = "CC";
  thirdOrderWords[3] = "CCC";
  thirdOrderWords[4] = "CD";
  thirdOrderWords[5] = "D";
  thirdOrderWords[6] = "DC";
  thirdOrderWords[7] = "DCC";
  thirdOrderWords[8] = "DCCC";
  thirdOrderWords[9] = "CM";

  return thirdOrderWords;
}

/**
 * Retornar o separador textual utilizado para separar as ordens numéricas
 *
 * @return separador textual utilizado para separar as ordens numéricas
 */
std::string NumberRoman::getSeparator()
{
  return "";
}

Arquivo Application.cpp

/*************************************************************************
 * Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  *
 *                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  *
 *                                                                       *
 * Permission is granted to copy, distribute and/or modify this document *
 * under the terms of the GNU Free Documentation License, Version 1.3 or *
 * any later version published by the  Free Software Foundation; with no *
 * Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A *
 * A copy of the  license is included in  the section entitled "GNU Free *
 * Documentation License".                                               *
 *                                                                       *
 * Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             *
 * g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                           *
 *************************************************************************/

#include <iostream>
#include "Number.hpp"
#include "NumberCardinal.hpp"
#include "NumberOrdinal.hpp"
#include "NumberRoman.hpp"

using namespace std;

/**
 * Metodo principal da linguagem de programacao C++
 *
 * @param argc quantidade de argumentos na linha de comando (nao utilizado)
 * @param argv argumentos da linha de comando (nao utilizado)
 */
int main(int argc, char** argv)
{
  Number* numberCardinal = new NumberCardinal(123);
  cout << numberCardinal->toString() << endl;
  delete numberCardinal;

  Number* numberOrdinal = new NumberOrdinal(123);
  cout << numberOrdinal->toString() << endl;
  delete numberOrdinal;

  Number* numberRoman = new NumberRoman(123);
  cout << numberRoman->toString() << endl;
  delete numberRoman;

  return 0;
}

Arquivo makefile

##########################################################################
 # Copyright (C) 2009/2021 - Cristiano Lehrer (cristiano@ybadoo.com.br)  #
 #                  Ybadoo - Solucoes em Software Livre (ybadoo.com.br)  #
 #                                                                       #
 # Permission is granted to copy, distribute and/or modify this document #
 # under the terms of the GNU Free Documentation License, Version 1.3 or #
 # any later version published by the  Free Software Foundation; with no #
 # Invariant Sections,  no Front-Cover Texts, and no Back-Cover Texts. A #
 # A copy of the  license is included in  the section entitled "GNU Free #
 # Documentation License".                                               #
 #                                                                       #
 # Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic)                             #
 # gcc/g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005                       #
 ##########################################################################

g++ -o Number.o -c Number.cpp

g++ -o NumberCardinal.o -c NumberCardinal.cpp

g++ -o NumberOrdinal.o -c NumberOrdinal.cpp

g++ -o NumberRoman.o -c NumberRoman.cpp

g++ -o Application.o -c Application.cpp

g++ -o application Number.o NumberCardinal.o NumberOrdinal.o NumberRoman.o Application.o

Saída da Implementação na Linguagem de Programação C++

cento e vinte e três
centésimo vigésimo terceiro
CXXIII