Código da Unit1.h
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include <vcl\Buttons.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TGroupBox *GroupBox1;
TGroupBox *GroupBox2;
TSpeedButton *SpeedButton1;
TSpeedButton *SpeedButton2;
TSpeedButton *SpeedButton3;
TSpeedButton *SpeedButton4;
TSpeedButton *SpeedButton5;
TSpeedButton *SpeedButton6;
TSpeedButton *SpeedButton7;
TSpeedButton *SpeedButton8;
TSpeedButton *SpeedButton9;
TSpeedButton *SpeedButton10;
TSpeedButton *SpeedButton11;
TSpeedButton *SpeedButton12;
TSpeedButton *SpeedButton13;
TSpeedButton *SpeedButton14;
TSpeedButton *SpeedButton15;
TSpeedButton *SpeedButton16;
TSpeedButton *SpeedButton17;
TSpeedButton *SpeedButton18;
TSpeedButton *SpeedButton19;
TSpeedButton *SpeedButton20;
TGroupBox *GroupBox3;
TSpeedButton *SpeedButton21;
TSpeedButton *SpeedButton22;
TSpeedButton *SpeedButton23;
TSpeedButton *SpeedButton24;
TGroupBox *GroupBox4;
TRadioButton *RadioButton1;
TRadioButton *RadioButton2;
TRadioButton *RadioButton3;
TRadioButton *RadioButton4;
TRadioButton *RadioButton5;
TRadioButton *RadioButton6;
TLabel *Label1;
TGroupBox *GroupBox5;
TSpeedButton *SpeedButton25;
TSpeedButton *SpeedButton26;
TSpeedButton *SpeedButton27;
TSpeedButton *SpeedButton28;
TListBox *ListBox1;
void __fastcall SpeedButton1Click(TObject *Sender);
void __fastcall SpeedButton2Click(TObject *Sender);
void __fastcall SpeedButton3Click(TObject *Sender);
void __fastcall SpeedButton4Click(TObject *Sender);
void __fastcall SpeedButton5Click(TObject *Sender);
void __fastcall SpeedButton6Click(TObject *Sender);
void __fastcall SpeedButton7Click(TObject *Sender);
void __fastcall SpeedButton8Click(TObject *Sender);
void __fastcall SpeedButton9Click(TObject *Sender);
void __fastcall SpeedButton10Click(TObject *Sender);
void __fastcall SpeedButton12Click(TObject *Sender);
void __fastcall SpeedButton13Click(TObject *Sender);
void __fastcall SpeedButton14Click(TObject *Sender);
void __fastcall SpeedButton15Click(TObject *Sender);
void __fastcall SpeedButton16Click(TObject *Sender);
void __fastcall SpeedButton20Click(TObject *Sender);
void __fastcall SpeedButton26Click(TObject *Sender);
void __fastcall SpeedButton27Click(TObject *Sender);
void __fastcall SpeedButton17Click(TObject *Sender);
void __fastcall SpeedButton11Click(TObject *Sender);
void __fastcall SpeedButton18Click(TObject *Sender);
void __fastcall SpeedButton24Click(TObject *Sender);
void __fastcall SpeedButton22Click(TObject *Sender);
void __fastcall SpeedButton23Click(TObject *Sender);
void __fastcall SpeedButton21Click(TObject *Sender);
void __fastcall SpeedButton19Click(TObject *Sender);
void __fastcall RadioButton3Click(TObject *Sender);
void __fastcall SpeedButton1KeyPress(TObject *Sender, char &Key);
void __fastcall RadioButton4Click(TObject *Sender);
void __fastcall SpeedButton25Click(TObject *Sender);
void __fastcall RadioButton5Click(TObject *Sender);
void __fastcall SpeedButton1MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton10MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton2MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton3MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton6MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton5MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton4MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton9MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton8MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton7MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y);
void __fastcall SpeedButton28Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
Código da Unit1.cpp
//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include <math.h> /* incluímos esta biblioteca para usar a função 'sqrt', cuja
utilidade será a de calcular a raiz quadrada dos valores*/
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
/******************* DECLARAÇÃO DAS VARIÁVEIS GLOBAIS **************/
char operador; /* variável que informará qual o tipo de operação que se trata.*/
bool resultado = false, virgula = 1; /*a variável 'resultado' será usada para
limpar o Label, evitando a concatenação dos números digitados após a execução
de alguma operação e a variável 'virgula' será usada para evitar que mais de
uma vírgula seja digitada em um mesmo número.*/
float primeiro, segundo; /*a variável primeiro guardará o primeiro valor digitado
para a maioria das operações (adição, subtração, multiplicação, divisão etc) e a
variável segundo receberá o segundo valor. Após isso, bastará realizar as
devidas operações*/
float memoriamaismais, memoriamais, memoriamenos; /*Como o nome já diz, essas
variáveis serão usadas para trabalhar com valores na memória da calculadora. A
variável 'memoriamaismais' guardará o resultado das operações na memória; a
variável 'memoriamais', o valor a ser adicionado ao resultado; e a variável
'memoriamenos', o valor a ser subtraído.*/
float prim; /*Esta variável global tem a função de capturar o valor digitado
nas contas de adição e subtração. Ela é basicamente voltada para aquelas
situações onde nós pressionamos várias vezes o botão de + ou de -, sem, contudo,
pressionarmos, imediatamente o botão de igual (ex.: 2+2+2+2+2+2+2=...). Ou seja,
ela captura o valor e, imediatamente, o transfere para a variável 'primeiro'.
Nas contas de adição, o processo é bem simples, sendo que a variável 'primeiro'
vai recebendo, armazenando e somando os valores recebidos desta variável e,
por fim, repassa todo o valor acumulado para a função encarregada de realizar
o cálculo (o botão de igual).
Já nas contas de subtração, o processo não é tão simples. O motivo é porque
existe um conflito entre os valores. Por exemplo, numa subtração normal
(A - B), "A" é interpretado como um valor positivo pelo compilador. O problema
é que "B" também é um valor positivo. O que faz com que o cálculo dê certo é
justamente o código "A" - "B". Agora imagine a seguinte situação:
(A-B-C-D = ...). Ou seja, o compilador tem de entender que "A" é um valor
positivo, e que "B", "C", e "D" são valores negativos. Então não será possível
fazer o cálculo da mesma forma que fizemos nas contas de adição, onde todos os
valores são positivos. Teremos de declarar mais uma variável (que poderá ser
local) e usar os comandos de decisão switch ... case() para solucionar o
problema. teremos de declarar um valor booleano (logo abaixo - subtracao)
para trabalhar com o comando de decisão mencionado.*/
bool subtracao = false; /* Essa variável booleana foi criada para trabalhar
com os valores positivo e negativos no armazenamento de vários valores na
conta de subtração, quando pressionamos várias vezes o botão de menos (-)
sem pressionar o botão de igual(=). ela será usada para tornar funcional
o comando de decisão switch ...case(). */
char buffer[256]; /*variável para vírgulas(casas decimais) e RadioButtons*/
char buf; /*variável para vírgulas (casas decimais) e RadioButtons*/
/**************** FIM DA DECLARAÇÃO DAS VARIÁVEIS GLOBAIS ************/
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
/***** EXPLICAÇÃO GERAL DO PORQUÊ DA NECESSIDADE DAVARIÁVEL RESULTADO*****/
/* Se para todos os botões para inserção de números (1, 2, 3, 4, 5, 6, 7, 8, 9,
e 0 - daqui prá frente chamaremos esses números de n) nós houvéssemos digitado
apenas o código:
Label1 -> Caption = n;
então não adinataria você clicar mais de uma vez porque o Label capturaria
apenas um número, não formando as dezenas, centenas etc. Então por isso a
forma correta de se codificar é mandando o programa, primeiro capturar o que
já está no Label, e depois capturar o número do botão pressionado:
Label1 -> Caption = Label1 -> Caption + n;
Neste caso, porém, ainda restará um problema: após realizar uma operação
(adição, por exemplo) o Label não será limpado automaticamente para a próxima
operação. O resultado é que haverá uma concatenação dos valores das duas
operações. Para resolver esse tipo de problema, nós declaramos a variável
booleana (aceita apenas dois valores: verdadeiro ou falso) 'resultado' que será
usada várias vezes para informar ao programa a hora certa de limpar o Label*/
/*** DAQUI PRÁ FRENTE SEMPRE QUE HOUVER ALGUMA NOVIDADE, NOS A ESTUDAREMOS***/
switch (resultado)/*comando que avalia o código para uma tomada de decisão, no
caso em tela para a variável 'resultado'*/
{
case false:/* se a variável 'resultado' estiver marcada 'false', o programa
executará o código abaixo:*/
Label1 -> Caption = Label1 -> Caption + 1; /*Captura o que já está em
Label mais o número 1*/
break; // sai do comando switch.
case true: /*se 'resultado' estiver 'true' rodará o bloco abaixo:*/
Label1 -> Caption = 1; /* Label1 captura o número 1, mas antes limpa o
Label, ou seja, apaga todos os números contidos em label*/
resultado = false; /* a seguir muda o valor da variável 'resultado'
para false, a fim de que o programa passe a executar o 'case false'
de 'switch'*/
break; // sai de switch.
} // fim do bloco switch
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton2Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 2;
break;
case true:
Label1 -> Caption = 2;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton3Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 3;
break;
case true:
Label1 -> Caption = 3;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton4Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 4;
break;
case true:
Label1 -> Caption = 4;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton5Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 5;
break;
case true:
Label1 -> Caption = 5;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton6Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 6;
break;
case true:
Label1 -> Caption = 6;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton7Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 7;
break;
case true:
Label1 -> Caption = 7;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton8Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 8;
break;
case true:
Label1 -> Caption = 8;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton9Click(TObject *Sender)
{
switch (resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 9;
break;
case true:
Label1 -> Caption = 9;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton10Click(TObject *Sender)
{
switch(resultado)
{
case false:
Label1 -> Caption = Label1 -> Caption + 0;
break;
case true:
Label1 -> Caption = 0;
resultado = false;
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton12Click(TObject *Sender)
{
/************* BOTÃO PARA CAPTURAR A VIRGULA ********************/
switch (virgula)/* tomada de decisão para a variável ´virgula*/
{
case 1: //o mesmo que 'case true' -> equivale a caso: 'virgula = true'
{
Label1 -> Caption = Label1 -> Caption + ","; /* Label1 captura
os números contidos em Label1, mais a vírgula*/
virgula = 0;// muda a variável virgula para 'false'
break; // comando para sair de switch
}
case 0: //o mesmo que 'case false' -> equivale a 'caso: virgula = false'
{
Label1 -> Caption = Label1 -> Caption; /* Label1 captura apenas
aquilo que já está em Label1, ou seja, não haverá alteração e não capturará
a vírgula, porque já há uma vírgula em Label1.*/
break; // sai de switch
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton13Click(TObject *Sender)
{
/*********** BOTÃO PARA CALCULAR UMA ADIÇÃO *******************/
ListBox1 -> Items -> Add (Label1 -> Caption + " +"); /* Como estamos na
função que trata da adição, este código diz para o componente ListBox1
adicionar o conteúdo de Label1 (quando o botão de + é pressionado) mais o
sinal de + . Isso, além de mostrar o valor que é trabalhado, também
informa que se trata de uma adição. */
operador = '+'; /* atribui à variável 'operador' o caracter + . Essa atribuição
informará ao 'Button 20' ( o do sinal de igual) que pressionamos o 'Button 13'
e que, portanto, se trata de uma operação de adição, e não outra. Observe bem
que 'operador' é uma variável do tipo 'char'. O caracter '+' foi usado apenas
para fins didáticos e poderia ser substituído por qualquer outro, sem qualquer
problema, como por exemplo: 'h' */
prim = StrToFloat(Label1 -> Caption);/*O conteúdo de Label1 é tratado
pelo compilador um uma string (um texto) donde decorre que não podemos usar
seu conteúdo para realizar uma operação matemática. Temos, então, que converter
esse texto em um número. A função StrToFloat() converte o conteúdo texto
daquilo que estiver entre seus parênteses para ponto flutuante (float).
Com isso, o conteúdo de Label1 passa a ser encarado pelo programa como um
número, podendo ser usado em operações aritméticas. Feito isso, o número
resultante da atribuição é atribuído à variável 'prim'*/
/*NOTA: ANTES A VARIÁVEL ACIMA CHAMAVA 'primeiro'. PARA RESOLVER O PROBLEMA DE
SOMAS SEGUIDAS [EX.: 2 + 2 + 2 + 2 + 2 (O RESULTADO DESSA SOMA SERIA QUATRO,
E NÃO DEZ)] ALTEREI O PROGRAMA. A VARIÁVEL 'primeiro' JÁ ERA LIDA POR OUTRAS
FUNÇÕES DO PROGRAMA, POR ISSO RESOLVI MANTÊ-LA COMO VARIÁVEL DE RETORNO. COM
ISSO FOI MAIS RAZOÁVEL, DECLARAR UMA NOVA VARIÁVEL, A: 'prim' QUE AGORA
RECEBE O VALOR DE Caption, E O ENVIA PARA SER ACUMULADO NA VARIÁVEL 'primeiro'
(MAIS OU MENOS COMO OCORRE NAS VARIÁVEIS: 'memoriamais', 'memoriamenos' e
'memoriamaismais' DOS BOTÕES QUE ACUMULAM OS VALORES ARMAZENADOS NA MEMÓRIA
DA CALCULADORA).
MAS A SOLUÇÃO ACIMA GERA UM NOVO PROBLEMA - A VARIÁVEL 'primeiro', AGORA JÁ
É INICIADA COM ALGUM VALOR, RESULTANTE DA ÚLTIMA OPERAÇÃO ARITIMÉTICA. POR
ISSO ELA DEVE SER IGUALADA A ZERO, NO BOTÃO RESPONSÁVEL PELO RESULTADO DA
OPERAÇÃO, OU SEJA, NO BOTÃO DE IGUAL.*/
primeiro = primeiro + prim; /* atribui à variável primeiro o seu próprio
valor, somado ao valor que foi capturado de Caption (ao pressionar o botão +*/
Label1 -> Caption = ""; /* Após a conversão numérica, Label1 deve ser esvaziado
para receber o próximo valor da da operação matemática*/
virgula = 1;/* caso a variável 'virgula' esteja com valor igual a zero (false),
esse valor será alterado para true. Assim uma vírgula poderá ser usada no
próximo número da operação matemática*/
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton14Click(TObject *Sender)
{
/************* BOTÃO PARA CALCULAR UMA SUBTRAÇÃO ******************/
switch (subtracao) /*Esse bloco é para determinar o que o ListBox1 adicionará.*/
{
case false: // Caso subtracao seja falsa
ListBox1 -> Items -> Add (Label1 -> Caption); /* ListBox1 adcionará
simplesmente o conteúdo de Label1 - É para o primeiro número (positivo)
capturado em uma subtração.*/
break;
case true: //Caso subtracao seja verdadeira
ListBox1 -> Items -> Add (Label1 -> Caption + " -");/* ListBox
adicionará o conteúdo de Label, precedido do sinal - .*/
break;
} // fim de switch case(...)
operador = '-';
float primdois; /* variável ponto flutuante para trabalhar com os valores
capturados de Label. Porem essa variável trabalhará apenas com os valores
negativos, ou seja, do segundo valor em diante até que o botão com o sinal
de igual (=) seja pressionado. Por exemplo, "A" - "B" - "C" - "D" - "E" = ...
Nesse caso, "A" seria trabalhado pela variável 'prim' e "B", "C", "D" e "E"
seriam trabalhados por 'primdois'*/
switch (subtracao) /* comando para avaliar qual variável armazenará o valor
capturado de Label*/
{
case false: /* Se subtracao for false. subtracao é false por default*/
prim = StrToFloat(Label1 -> Caption); /* 'prim' armazena conteúdo de Label*/
primeiro = prim; /* Iguala 'primeiro' a 'prim' por dois motivos. 1º. Para
passar o conteúdo de Label ao comando responsável pela execução do
cálculo (pois 'primeiro é a variável global usada naquele lugar. 2º. Para,
no caso abaixo, poder passar o valor de 'prim', através de 'primeiro', ao
cálculo das situações em que o botão de igual (=) não é pressionado de
imediato. */
subtracao = true; /* se não for início de cálculo, subtracao sempre deverá
possuir o valor igual a true. */
break;
case true: // caso subtracao seja true
primdois = StrToFloat(Label1 -> Caption);/* 'primdois' captura o conteúdo
de Label.*/
primdois = primdois * (-1);/* transforma 'primdois' em negativo.*/
primeiro = primeiro + primdois;/* armazena o valor de 'primdois' em
'primeiro', para que esse valor possa ser enviádo para a área de
cálculo - Botão de igual (=). */
break;
} // fim de switch
Label1 -> Caption = "";
virgula = 1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton15Click(TObject *Sender)
{
/************ BOTÃO PARA CALCULAR UMA MULTIPLICAÇÃO ***************/
// veja comentário no 'Button 13'
ListBox1 -> Items -> Add (Label1 -> Caption + " x"); /* para que ListBox1
possa mostrar que se trata de uma multiplicação.*/
operador = 'x';
primeiro = StrToFloat(Label1 -> Caption);
Label1 -> Caption = "";
virgula = 1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton16Click(TObject *Sender)
{
/************* BOTÃO PARA CALCULAR UMA DIVISÃO ***************/
// veja comentário no 'Button 13'
ListBox1 -> Items -> Add (Label1 -> Caption + " :"); /**/
operador = ':';
primeiro = StrToFloat(Label1 -> Caption);
Label1 -> Caption = "";
virgula = 1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton20Click(TObject *Sender)
{
/******* BOTÃO DE IGUAL - DÁ O RESULTADO DA OPERAÇÃO MATEMÁTICA *****/
segundo = StrToFloat(Label1 -> Caption); /* Converte o conteúdo de Label1 para
ponto flutuante. Em seguida atribui esse valor para a variável 'segundo'*/
////////////////////////////////////////////////////////////////////////////////
//double(segundo);
////////////////////////////////////////////////////////////////////////////////
//double(primeiro);
////////////////////////////////////////////////////////////////////////////////
virgula = 1; //caso vírgula esteja com valor igual a zero, o altera para 1
switch (operador) /*comando de decisão para avaliar a atribuição da variável
operador. Quando nós digitamos o primeiro valor da operação aritmética e
pressionamos um botão para efetuar um cálculo (adição, subtração, divisão,
multiplicação), foi atribuído um determinado valor para a variável 'operador'
(+, -, x ou :). Agora o comando switch avalia qual é o valor (caracter) que
está atribuído à variável 'operador' para, com base nisso tomar a decisão
correta da tarefa a realizar. */
{
case '+': /* caso o caracter + esteja atribuído à variável 'operador':*/
ListBox1 -> Items -> Add ( Label1 -> Caption + " +"); /* ListBox1 adicionará
o valor da variável 'segundo', informando, ainda, tratar-se de uma adição. */
Label1 -> Caption = primeiro + segundo; /*Label1 capturará a adição
entre primeiro e segundo - exibirá o resultado da adição */
primeiro = '\0'; /* Zera o conteúdo de primeiro, para que os cálculos não
sejam reiniciados com algum valor residual de outra conta acabada. */
break; // sai de switch
case '-': /* caso o caracter - esteja atribuído à variável 'operador':*/
ListBox1 -> Items -> Add ( Label1 -> Caption + " -"); /* ListBox1
adicionará o valor da variável 'segundo', informando, ainda, tratar-se de
uma subtração. */
Label1 -> Caption = primeiro - segundo; /*Label1 capturará a
subtração do primeiro pelo segundo - exibirá o resultado da subtração */
primeiro = '\0'; /* Zera o conteúdo de primeiro, para que os cálculos não
sejam reiniciados com algum valor residual de outra conta acabada. */
break; // sai de switch
case 'x':/* caso o caracter x esteja atribuído à variável 'operador':*/
ListBox1 -> Items -> Add ( Label1 -> Caption); /* ListBox1 adicionará
o valor da variável 'segundo'. */
Label1 -> Caption = primeiro * segundo; /*Label1 capturará a
multiplicação do primeiro e segundo - exibirá o resultado da multiplicação*/
break; // sai de switch
case ':':/* caso o caracter : esteja atribuído à variável 'operador':*/
ListBox1 -> Items -> Add ( Label1 -> Caption); /* ListBox1 adicionará
o valor da variável 'segundo'. */
Label1 -> Caption = primeiro / segundo; /*Label1 capturará a
divisão do primeiro pelo segundo - exibirá o resultado da divisão */
break; // sai de switch
}
resultado = true; /* fará com que Label1 seja esvaziada, evitando a
concatenação dos valores entre diversas operações*/
ListBox1 -> Items -> Add ( Label1 -> Caption + " ="); /* ListBox1, após
adicionar o valor do resultado da operação, mostrará o sinal de igual. */
ListBox1 -> Items -> Add (""); // linha vazia para espaço em ListBox.
subtracao = false; // só funcionou neste lugar - para acumular subtração
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton26Click(TObject *Sender)
{
/********** BOTÃO PARA LIMPAR TODA A OPERAÇÃO ****************/
virgula = 1;
Label1 -> Caption = ""; // esvazia o conteúdo de Label1
primeiro = '\0'; // descarrega o conteúdo da variável 'primeiro'
ListBox1 -> Items -> Add ("operação cancelada...");
ListBox1 -> Items -> Add ("");/*acrescenta uma linha vazia no ListBox1.*/
operador = '+'; /*previne um bug com a multiplicação num próximo cálculo.
Por exemplo, se após pressionarmos um número qualquer, nós pressionarmos o
Botão de igual, com essa declaração, o valor pressionado permanecerá na
tela. Seria algo como: 1 = 1. Sem essa declaração, não importa o número,
o resultado será zero. Ex: 7 = 0. */
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton27Click(TObject *Sender)
{
/********* BOTÃO PARA LIMPAR APENAS OS ÚLTIMOS DADOS *********/
virgula = 1;
Label1 -> Caption = ""; /* esvazia o Label1, mas não altera o conteúdo
da variável primeiro*/
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton17Click(TObject *Sender)
{
////////////////////////////////////////////////////////////////////////////////
ListBox1 -> Items -> Add ( Label1 -> Caption);
////////////////////////////////////////////////////////////////////////////////
/*********** BOTÃO PARA CALCULAR A RAIZ QUADRADA *************/
primeiro = StrToFloat(Label1 -> Caption); /*Converte o conteúdo de Label1
para ponto flutuante e o atribui à variável primeiro*/
Label1 -> Caption = sqrt(primeiro);/*Label1 capturará a raiz quadrada do
valor atribuído à variável 'primeiro'. sqrt() é a função responsável por
esse cálculo. Ela pertence à biblioteca math.h, que foi incluída na área
dos arquivos de cabeçalho*/
////////////////////////////////////////////////////////////////////////////////
primeiro = '\0';
///////////////////////////////////////////////////////////////////////////////
virgula = 1;
resultado = true;
///////////////////////////////////////////////////////////////////////////////
ListBox1 -> Items -> Add ( Label1 -> Caption + " (raiz)");
ListBox1 -> Items -> Add ( "");
///////////////////////////////////////////////////////////////////////////////
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton11Click(TObject *Sender)
{
/**** BOTÃO PARA ALTERNAR OS VALORES ENTRE POSITIVO E NEGATIVO *****/
float alterasinal; /*variável ponto flutuante*/
alterasinal = StrToFloat(Label1 -> Caption); /*Converte o conteúdo de
Label1 e o atribui à variável 'alterasinal'*/
Label1 -> Caption = "";/*esvazia Label1 para receber o novo valor, após a
mudança ser realizada por 'alterasinal'*/
alterasinal = alterasinal * (-1);/*multiplica 'alterasinal' por -1 (menos um)
com isso alternamos seu valor entre positivo e negativo*/
Label1 -> Caption = alterasinal; /*Agora Label1 captura o conteúdo de
'alterasinal' (já com o sinal (+ ou -)trocado */
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton18Click(TObject *Sender)
{
////////////////////////////////////////////////////////////////////////////////
ListBox1 -> Items -> Add ( Label1 -> Caption + " %");
////////////////////////////////////////////////////////////////////////////////
/*********** BOTÃO PARA CALCULAR A PORCENTAGEM ***************/
// NOTA: se quero achar 20% de 50, faço: (50 * 20) / 100
/* Partindo dessa observação acima, usaremos a variável primeiro e segundo
para calcular as porcentagens*/
virgula = 1;
segundo = StrToFloat(Label1 -> Caption);
float terceiro; // variável ponto flutuante
terceiro = (primeiro * segundo) / 100;/* Inicializamos a variável 'terceiro'
com a fórmula do cálculo de valores percentuais, usando os valores que foram
capturados da tela pelas variáveis 'primeiro' e 'segundo'*/
switch (operador)/*estrutura de decisão, já estudada. Veja os comentários de
'Button 20', pois o princípio é idêntico */
{
case '+':
Label1 -> Caption = primeiro + terceiro;
break;
case '-':
Label1 -> Caption = primeiro - terceiro;
break;
case 'x':
Label1 -> Caption = primeiro * terceiro;
break;
case ':':
Label1 -> Caption = primeiro / terceiro;
break;
}
resultado = true;
///////////////////////////////////////////////////////////////////////////////
ListBox1 -> Items -> Add ( Label1 -> Caption);
ListBox1 -> Items -> Add ( "");
///////////////////////////////////////////////////////////////////////////////
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton24Click(TObject *Sender)
{
/*** BOTÃO PARA INSERIR VALORES POSITIVOS MA MEMÓRIA DA CALCULADORA ***/
memoriamais = StrToFloat(Label1 -> Caption); /*Converte o conteúdo de
Label1 e atribui à variável 'memoriamais'. 'memoriamais' é a variável que
armazenará os valores positivos*/
memoriamaismais = memoriamaismais + memoriamais;/*inicializa 'memoriamaismais'
com seu próprio valor somado com o valor de 'memoriamais' -> aquele capturado
de Label1. 'memoriamaismais' é a variável que armazenará o resultado de todas
as operações realizadas a nível de memória da calculadora. Ou seja, ela tanto
trabalha com seus próprios valores, como trabalha com os valores de
'memoriamais', como com os de 'memoriamenos'.*/
resultado = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton22Click(TObject *Sender)
{
/**** BOTÃO QUE APRESENTA O CONTEÚDO DA MEMÓRIA ****/
Label1 -> Caption = ""; // esvazia o Conteúdo de Label1
Label1 -> Caption = memoriamaismais;/* Label1 captura o conteúdo da variável
'memoriamaismais', ou seja, o resultado das operações na memória*/
resultado = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton23Click(TObject *Sender)
{
/*********** BOTÃO PARA INSERIR VALORES NEGATIVOS NA MEMÓRIA *******/
memoriamenos = StrToFloat(Label1 -> Caption);/*Converte o conteúdo de
Label1 e atribui à variável 'memoriamenos'. 'memoriamenos' é a variável que
armazenará os valores negativos*/
memoriamaismais = memoriamaismais - memoriamenos;/*inicializa 'memoriamaismais'
com seu próprio valor somado com o valor de 'memoriamenos' -> aquele capturado
de Label1. 'memoriamaismais' é a variável que armazenará o resultado de todas
as operações realizadas a nível de memória da calculadora. Ou seja, ela tanto
trabalha com seus próprios valores, como trabalha com os valores de
'memoriamais', como com os de 'memoriamenos'.*/
resultado = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton21Click(TObject *Sender)
{
/***** BOTÃO QUE ESVAZIA O CONTEÚDO ARMAZENADO NA MEMÓRIA *******/
memoriamaismais = '\0'; /*atribui a 'memoriamaismais' o valor nulo*/
resultado = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton19Click(TObject *Sender)
{
/**************** BOTÃO 1/n (1 DIVIDIDO POR n) ************/
float porcentagem; // variável ponto flutuante
porcentagem = StrToFloat(Label1 -> Caption); /* converte conteúdo de
Label1 para ponto flutuante e atribui a 'porcentagem' */
Label1 -> Caption = ""; // esvazia conteúdo de Label1
if(porcentagem == 0) // se for atribuído valor zero para 'porcentagem'
ShowMessage("Erro na execução do programa..."); /* apresente uma
caixa de mensagem comunicando erro (pois não há divisão por zero)*/
else // ou então
{
porcentagem = 1 / porcentagem; /* divida 1 pelo valor atribuído
à variável 'porcentagem'. */
Label1 -> Caption = porcentagem; /* exiba o novo valor de
'porcentagem' em Label1. */
resultado = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton3Click(TObject *Sender)
{
//Label1 -> Caption = Label1 -> Caption + "," + "" + "";
//ESTUDAR ESSE CÓDIGO ABAIXO
/*
double numero = StrToFloat(Label1 -> Caption);
numero = double(int(numero*100.0+.5))/100.0;
Label1 -> Caption = FloatToStr(numero);
*/
//double numero=21.125656;
//numero=double(int(numero*100.0+.5))/100.0;
//ShowMessage(numero);
//Label1 -> Caption = numero;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1KeyPress(TObject *Sender, char &Key)
{
Label1 -> Caption = 1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton4Click(TObject *Sender)
{
/*o código abaixo coloca uma vírgula a quatro casas do final da string*/
if(virgula == true)
{
char buffer[100];
strcpy (buffer, Label1->Caption.c_str()); // converte Text de AnsiString para char*
buffer[((int)Label1->Caption.Length()) + 1] = buffer[((int)Label1->Caption.Length())];
buffer[((int)Label1->Caption.Length())] = buffer[((int)Label1->Caption.Length())- 1];
buffer[((int)Label1->Caption.Length()) - 1] = buffer[((int)Label1->Caption.Length())- 2];
buffer[((int)Label1->Caption.Length()) - 2] = buffer[((int)Label1->Caption.Length())- 3];
buffer[((int)Label1->Caption.Length()) - 3] = buffer[((int)Label1->Caption.Length())- 4];
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
virgula = false;
}
else
return;
//Label1 -> Caption = Label1 -> Caption + "," + "0" + "0" + "0" + "0";
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton25Click(TObject *Sender)
{
/********** BOTÃO PARA INICIAR NOVA OPERAÇÃO ****************/
virgula = 1;
Label1 -> Caption = ""; // esvazia o conteúdo de Label1
primeiro = '\0'; // descarrega o conteúdo da variável 'primeiro'
operador = '+'; /*previne um bug com a multiplicação num próximo cálculo.
Por exemplo, se após pressionarmos um número qualquer, nós pressionarmos o
Botão de igual, com essa declaração, o valor pressionado permanecerá na
tela. Seria algo como: 1 = 1. Sem essa declaração, não importa o número,
o resultado será zero. Ex: 7 = 0. */
ListBox1->Items->Clear(); // esvazia o conteúdo de ListBox1
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton5Click(TObject *Sender)
{
//ESTUDAR O CÓDIGO ABAIXO
/*
double numero=21.125656;
numero=double(int(numero*100.0+.5))/100.0;
//ShowMessage(numero);
Label1 -> Caption = numero;
*/
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton10MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton2MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton3MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton6MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton5MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton4MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton9MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton8MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton7MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
/*O código abaixo é usado para manter a vírgula a quatro casas do final da
string quando o usuário, após checkar o RadioButton4, continuar introduzindo
números no Label1*/
if(RadioButton4->Checked == true)
{
// if(virgula == true)
{ // converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buf = buffer[((int)Label1->Caption.Length()) - 4];
buffer[((int)Label1->Caption.Length()) - 5] = buf;
buffer[((int)Label1->Caption.Length()) - 4] = ',';
Label1->Caption = buffer;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton28Click(TObject *Sender)
{
/*O código abaixo é usado para apagar o último
número colocado no Caption do Label1*/
// converte Text de AnsiString para char*
strcpy (buffer, Label1->Caption.c_str());
buffer[((int)Label1->Caption.Length())-1] = '\0';
Label1->Caption = buffer;
}
//---------------------------------------------------------------------------
voltar
|
HOME || MAPA DO SITE || CURSOS || TUTORIAIS || LINKS || FORUM || CONTATO |