FMX - convertendo numeral em cardinal II

OBS: Esta versão veio para melhorar 

alguns detalhes na interface gráfica.

Para definir um valor a objetos ou seres de qualquer espécie,

ou ainda qualquer coisa física que se encontra em nosso contexto,

utilizamos a palavra Numeral.

Podemos dizer que os numerais são os mesmos cardinais

porém quando se escreve são escritos

através de algarismos arábicos ou o menos usados romanos.

Os números cardinais expressam quantidade ou contagem exatas

de objetos, seres de qualquer espécie ou coisas físicas

existente em nosso contexto diário,

mas quando precisamos escrevê-los,

são escritos pelo seu nome propriamente dito,

ou como muitos dizem por ( extenso ).

A primeira versão deste programa, foi criada 

por mim mesmo em linguagem C, com os resultados

imprimidos na tela do CMD do windows.

Depois criamos uma versão em Java (texto),

e outra em JavaFx.

Agora criamos uma versão para rodar numa interface

gráfica do C++ builder, e se manteve bem fiel

a primeira versão criada em C, as poucas alterações

foram aplicadas somente nos comandos utilizados

pelos componentes da janela gráfica.

O interessante deste programa é que ele não utiliza

nenhum recurso avançado nem do C e nem do C++,

mesmo assim, eu me lembro que na criação da primeira versão,

me deu bastante trabalho na organização dos códigos. 

Limitamos o programa a imprimir resultados de até,

9999 (Nove Mil Novecentos e Noventa e Nove),

mas nada impede isto ser expandido para valores

muito acima disto, sem nenhuma dificuldade.

Assista agora o programa funcionando no vídeo:

 //---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click ( TObject *Sender ) {;

   Close ( );

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

   Text2 -> Visible = false;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 50, 35, 500, 20, 17, true, 3, "FMX - CONVERTENDO NUMERAL EM CARDINAL II" );

T_Rect_2 ( 60, 280, 165, 20 );

T_Text ( 40, 280, 200, 20, 13, true, 0, "Número entre 0 e 10000" );

}

//---------------------------------------------------------------------------

FMX - convertendo numeral em cardinal

Para definir um valor a objetos ou seres de qualquer espécie,

ou ainda qualquer coisa física que se encontra em nosso contexto,

utilizamos a palavra Numeral.

Podemos dizer que os numerais são os mesmos cardinais

porém quando se escreve são escritos

através de algarismos arábicos ou o menos usados romanos.

Os números cardinais expressam quantidade ou contagem exatas

de objetos, seres de qualquer espécie ou coisas físicas

existente em nosso contexto diário,

mas quando precisamos escrevê-los,

são escritos pelo seu nome propriamente dito,

ou como muitos dizem por ( extenso ).

A primeira versão deste programa, foi criada 

por mim mesmo em linguagem C, com os resultados

imprimidos na tela do CMD do windows.

Depois criamos uma versão em Java (texto),

e outra em JavaFx.

Agora criamos uma versão para rodar numa interface

gráfica do C++ builder, e se manteve bem fiel

a primeira versão criada em C, as poucas alterações

foram aplicadas somente nos comandos utilizados

pelos componentes da janela gráfica.

O interessante deste programa é que ele não utiliza

nenhum recurso avançado nem do C e nem do C++,

mesmo assim, eu me lembro que na criação da primeira versão,

me deu bastante trabalho na organização dos códigos. 

Limitamos o programa a imprimir resultados de até,

9999 (Nove Mil Novecentos e Noventa e Nove),

mas nada impede isto ser expandido para valores

muito acima disto, sem nenhuma dificuldade.

Assista agora o programa funcionando no vídeo:

//----------------------------------------------------------------------------

  if ( mi == 9000 ) {

   if ( de == 0 && un == 0 ) {

str_1 = "Nove Mil";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   } else {

str_1 = "Nove Mil e ";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   }

              }

  if ( mi == 8000 ) {

   if ( de == 0 && un == 0 ) {

str_1 = "Oito Mil";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   } else {

str_1 = "Oito Mil e ";

Button3 -> Text = Form1 -> Button3 -> Text + str_1;

   }

              }

//---------------------------------------------------------------------------

FMX - conversor de unidades métricas

Quando declaramos uma classe em C++,

por definição ela é privada,

isto significa que não podemos acessar,

nem suas variáveis membros,

nem suas funções membros através de outras

funções que não seja também membro da classe.

Uma classe pode possuir tantos membros privados

como públicos, isto é um modo de conseguirmos

encapsular os seus membros e funções,

para que determinados itens não sejam acessados

por outras funções que não convém.

Para tornar partes de uma classe públicas,

isto é, acessíveis a outras partes do seu programa,

você deve declará-las após a palavra reservada public.

Todas as variáveis ou funções definidas depois de public

estão disponíveis a todas as outras funções no programa.

Para mostrar na prática o uso de classes em C++,

declarei uma classe e dei-lhe o nome de: Conversor_Metrico,

esta classe possui várias funções membros públicas

e com retorno para serem utilizados nas chamadas

dos eventos dos botões correspondente.

Nossos conhecimentos e habilidades em C++, 

e no C++ Builder, nos permite criar dezenas de conversões,

em variadas áreas, isto seria dividido em várias janelas

com menus bem organizados, dando um estilo bem profissional,

mas como isto aqui é didático, não precisamos perder

muito tempo com isto, porque o caminho à percorrer é longo,

e o tempo é muito curto, quase não temos tempo para programar.

Se alguém tiver interesse no projeto basta nos solicitar,

porque disponibilizamos apenas algumas partes dos códigos,

para poder obter algum feedback positivo de preferência,

mas críticas, quando feitas com sinceridade e conhecimento

também são aceitas.

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click ( TObject *Sender ) {;

Conversor_Metrico conv;

//METRO

if ( a == 1 ) {

   T_Rect_2 ( 160, 220, 320, 20 );

   T_Rect ( 160, 220, 200, 20 );

   //pos X, pos Y, Width, Height, Size, Bool, Color,String

   T_Text ( 170, 220, 200, 20, 16, false, 0, "De metro para metro" );

double conversor = conv.converter_0 ( x, conv.CENTIMETRO );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 1 );

}

//CENTÍMETRO

if ( a == 2 ) {

   T_Rect_2 ( 160, 220, 320, 20 );

   T_Rect ( 160, 220, 250, 20 );

   //pos X, pos Y, Width, Height, Size, Bool, Color,String

   T_Text ( 170, 220, 250, 20, 16, false, 0, "De centímetro para metro" );

double conversor = conv.converter_3 ( x, conv.METRO );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 2 );

}

//POLEGADAS

if ( a == 3 ) {

T_Rect_2 ( 160, 220, 320, 20 );

T_Rect ( 160, 220, 250, 20 );

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 170, 220, 250, 20, 16, false, 0, "De polegadas para metro" );

double conversor = conv.converter_6 ( x, conv.POLEGADAS_2 );

Edit2 -> Text = FloatToStrF ( conversor, ffFixed, 8, 4 );

}

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 60, 15, 500, 20, 17, true, 3, "FMX - CONVERSOR DE UNIDADES MÉTRICAS" );

T_Text ( 50, 240, 300, 40, 14, true, 3,  "Por: " );

T_Text ( 120, 240, 300, 40, 14, true, 2,  "Samuel Lima" );

T_Text ( 100, 255, 300, 40, 14, true, 0,  "sa_sp10@otmail.com" );

}

//---------------------------------------------------------------------------

FMX - gerando e comparando dois arrays de caracteres

Este programa utiliza três dos seis operadores

relacionais da linguagem C, e a finalidade,

é comparar dois vetores de caracteres do C.

Isto não traz nenhuma novidade para nós,

mas a forma estratégica na qual organizamos 

os códigos para fazer as comparações,

foi perfeita e pode ser utilizada até em outras

comparações, como por exemplo, saber se dois vetores

são iguais ou distinto ou se seus elementos são comuns.

Assista o vídeo e comprove o programa funcionando:

//---------------------------------------------------------------------------

void Cria_Array_Embaralhado ( char *A, char *B ) {

             TObject *Sender;

int i;

Mix_Int ( A );

Mix_Int ( B );

if ( a == 1 ) {

T_Rect ( 160, 75, 150, 20 );

Rectangle3 -> Fill -> Color = claYellow;

Rectangle3 -> Stroke -> Color = claYellow;

Rectangle3 -> XRadius = 10;

Rectangle3 -> YRadius = 10;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 55, 50, 400, 20, 16, false, 0, "Imprimindo abaixo o array A" );

for ( i = 0; i < 5; i++ ) {

T_Text ( 24 + i * 30, 75, 300, 20, 16, true, 0,  A [ i ] );

C [ i ] = A [ i ];

}

Button1 -> Text = "Gerar o array B";

}

if ( a == 2 ) {

T_Rect ( 160, 125, 150, 20 );

Rectangle3 -> Fill -> Color = claTurquoise;

Rectangle3 -> Stroke -> Color = claTurquoise;

Rectangle3 -> XRadius = 10;

Rectangle3 -> YRadius = 10;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 55, 100, 400, 20, 16, false, 0, "Imprimindo abaixo o array B" );

for ( i = 0; i < 5; i++ ) {

T_Text ( 24 + i * 30, 125, 300, 20, 16, true, 0, B [ i ] );

D [ i ] = B [ i ];

}

Button1 -> Width = 150;

Button1 -> Text = "Comparar os dois arrays";

}

if ( a == 3 ) {

Compara_Array ( );

Button1 -> Width = 100;

Button1 -> Text = " Sobre ";

}

if ( a == 4 ) {

  Informe ( );

  Button1 -> Width = 100;

  Button1 -> Text = "Nova operação";

  }

  if ( a == 5 ) {

Form1 -> FormCreate ( Sender );

T_Rect ( 30, 35, 550, 240 );

Rectangle3 -> Fill -> Color = claWhite;

Rectangle3 -> Stroke -> Color = claWhite;

a = 0;

for ( i = 0; i < 27; i++ ) {

A [ i ] = ' ';

B [ i ] = ' ';

C [ i ] = ' ';

D [ i ] = ' ';

}

T_Rect ( 320, 280, 260, 50 );

Rectangle3 -> Fill -> Color = claWhite;

Rectangle3 -> Stroke -> Color = claWhite;

  }

}

//------------------------------------------------------------------------

FMX - gerando e comparando dois arrays

Este programa utiliza três dos seis operadores

relacionais da linguagem C, e a finalidade,

é comparar dois vetores de inteiros do C.

Isto não traz nenhuma novidade para nós,

mas a forma estratégica na qual organizamos 

os códigos para fazer as comparações,

foi perfeita e pode ser utilizada até em outras

comparações, como por exemplo, saber se dois vetores

são iguais ou distinto ou se seus elementos são comuns.

Assista o vídeo e comprove o programa funcionando:

//------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

Label_Manual ( Sender );

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 100, 15, 400, 20, 16, true, 3, "FMX - GERANDO E COMPARANDO DOIS ARRAYS II" );

   b++;

  T_Rect ( 39, 300, 30, 20 );

  T_Text_2 ( 40, 300, 30, 20, 20, true, 3, String ( b ) + "°" );

  T_Text_2 ( 60, 300, 70, 20, 20, true, 0, "Teste" );

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click ( TObject *Sender ) {

int A [ 10 ];

int B [ 10 ];

a++;

Cria_Array_Embaralhado ( A, B );

}

//---------------------------------------------------------------------------

C++ builder - gerando array e sorteando

 

Este programa preenche um array de inteiro 

com os 10 primeiros números naturais,

mas embaralha-os em seguida e assim temos a

primeira impressão por um componente TText

do C++ builder.

pressionando o botão uma única vez, 

uma caixa de mensagem é ativada,

e o programa passa a ser executado por ela,

e a cada clique no botão desta caixa,

um número de dentro do vetor é sorteado

numa escolha totalmente aleatória.

Confira isto funcionando por favor:

//---------------------------------------------------------------------------

int Sorteia ( int *vet ) {

int i, r, temp;

for ( i = 0; i < tam; i++ )

vet [ i ] = i;

srand ( time ( NULL ) );

for ( i = 0; i < tam; i++ ) {

r = rand ( ) % tam;

temp = vet [ i ];

vet [ i ] = vet [ r ];

vet [ r ] = temp;

}

return 0;

}

//---------------------------------------------------------------------------

void Cria_Array_Embaralhado ( int *vet ) {

int i;

Sorteia ( vet );

T_Rect_2 ( 120, 55, 380, 20 );

Rectangle2 -> Fill -> Color = claYellow;

Rectangle2 -> Stroke -> Color = claYellow;

//pos X, pos Y, Width, Height, Size, Bool, Color,String

T_Text ( 100, 55, 400, 20, 16, false, 0, "Imprimindo abaixo o array aleatório" );

for ( i = 0; i < tam; i++ ) {

T_Text ( 20 + i * 30, 80, 300, 20, 16, false, 0, String ( vet [ i ] ) );

Text1 -> TextSettings -> Font -> Family = "alarm clock";

}

}

//---------------------------------------------------------------------------

C++ builder - botão para dois estados II

 

Em computação que é a nossa área,

os números binários 0 e 1 significam: False e True,

que foram padronizados em C++ como o tipo de dado

primitivo bool, sendo que em C eles são armazenados

em um simples tipo inteiro.

Em outras áreas da tecnologia, estes dois valores

booleanos, que receberam este nome em homenagem

George Boole, assumem outros nomes como: Low and Right,

"Baixo e Alto", Off and On, "Desligado e Ligado".

Em um post passado mostramos um exemplo de um botão,

de um único estado, o programa só realizava uma única ação, 

e por mais que se pressionasse o botão, nada mais acontecia.

Um exemplo de aplicação para isto seria um joguinho da velha,

onde os jogadores não podem pressionar um botão que já foi acionado.

O exemplo sugerido aqui mostra um botão de dois estados,

ele acende e apaga dois leds de modo alternado,

indicando em um label o número binário respectivo a seu estado.

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate ( TObject *Sender ) {

   Label_Manual ( Sender );

  Image1 = new TImage ( this );

  Image1 -> Bitmap -> LoadFromFile ("One led vermelho aceso.bmp");

  Image1 -> Parent = Form1;

  Image1 -> Height = 50;

  Image1 -> Width = 35;

  Image1 -> Position -> X = 198;

  Image1 -> Position -> Y = 130;

  Label1 -> Text = IntToStr ( 1 );

  Image2 = new TImage ( this );

  Image2 -> Bitmap -> LoadFromFile ("Led_verde_apagado.png");

  Image2 -> Parent = Form1;

  Image2 -> Height = 50;

  Image2 -> Width = 35;

  Image2 -> Position -> X = 396;

  Image2 -> Position -> Y = 132;

  Label2 -> Text = IntToStr ( 0 );

}

//---------------------------------------------------------------------------