Tutoriais - Programação Orientada a ObjetosDesenvolva 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.
/*************************************************************************
* Copyright (C) 2009/2024 - 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());
}
}/*************************************************************************
* Copyright (C) 2009/2024 - 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 ";
}
}/*************************************************************************
* Copyright (C) 2009/2024 - 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 " ";
}
}/*************************************************************************
* Copyright (C) 2009/2024 - 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 "";
}
}/*************************************************************************
* Copyright (C) 2009/2024 - 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);
}
}
/*************************************************************************
* Copyright (C) 2009/2024 - 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/*************************************************************************
* Copyright (C) 2009/2024 - 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());
}/*************************************************************************
* Copyright (C) 2009/2024 - 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/*************************************************************************
* Copyright (C) 2009/2024 - 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 ";
}/*************************************************************************
* Copyright (C) 2009/2024 - 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/*************************************************************************
* Copyright (C) 2009/2024 - 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 " ";
}/*************************************************************************
* Copyright (C) 2009/2024 - 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/*************************************************************************
* Copyright (C) 2009/2024 - 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 "";
}/*************************************************************************
* Copyright (C) 2009/2024 - 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;
}##########################################################################
# Copyright (C) 2009/2024 - 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.oYbadoo - Soluções em Software Livre • Copyright 2009/2024 • 