Estrutura Condicional - eisnt.org+/manuais/07_Estruturas_condic... · Estrutura Condicional 83 7.2...

Estrutura

Condicional

Neste capítulo, são apresentados problemas onde a resolução pode depender de uma resposta a uma dada pergunta, ou uma avaliação de uma determinada situação ou expressão, direcionando a execução para um caminho ou outro.

Toda linguagem oferece a Estrutura Condicional (ou de seleção). No livro Algoritmos: Fundamento e Prática, que trabalha a implementação utilizando Pseudocódigo, essa estrutura é representada através das ins-truções Se... Então..., Senão, Então..., FimSe e Escolha... Caso.

7.1 Conceitualização: If... Else If... Else

A sintaxe para a implementação da estrutura condicional é deta-lhada na seqüência, veja:

Sintaxeif (<condição_simples_ou_composta>) [{]

<instruções>;

[>]else if (<condição_simples_ou_composta>) [{]

<instruções>;

[>]else [{]

<instruções>;

[>]

Onde:<condição_simples_ou_composta>: Refere-se às verificações, por exemplo: if (Valor > 1000)

if (Operação == "Crédito" && Valor >= 0)

<instruções>: Refere-se ao que deve ser feito no caso de a condi-ção avaliada ser verdadeira, por exemplo:

if (Valor > 1000)

ShowMessage("Valor maior que mil");

else if (Valor < 1000)

ShowMessage("Valor menor que mil");

else

82 C++ Builder: Implementação de Algoritmos e Técnicas para Ambientes Visuais

ShowMessage("Valor igual a mil");

if (Operação == "Crédito" && Valor >= 0) {

Saldo += Valor;

ShowMessage("Valor creditado em conta");

>

Esclarecimentos:É possível avaliar a resposta sobre um conjunto definido previamente.

Dessa forma, o valor pode ser posto em verificação por mais de uma vez, até que o informado seja identificado como pertencente ao con-junto.

if (N > 0)

ShowMessage(" Maior");

if (N < 0)

ShowMessage(” Menor");

if (N == 0)

ShowMessage("Igual");

No exemplo acima, cada if é um bloco individual, fazendo o tempo de processamento ser maior. Para refinar a programação, podem ser utilizados na estrutura o else e else if, sendo chamada também de estru-tura aninhada ou encadeada (exemplo abaixo), visto possuir vários níveis de condição. Note que, ao ser satisfeita a condição (verdadeira), as condições posteriores serão automaticamente descartadas, fazendo com que, em algumas situações, haja uma redução de processamento (comparações). Tanto else como else if são opcionais e relevantes a cada situação, porém não é possível a existência de else ou else if sem antes um if.

if (N > 0)

ShowMessage("Maior");

else if (N < 0)

ShowMessage(" Menor");

else

ShowMessage('Tgual");

Algumas Regras:1. Cada condição deve estar entre parênteses.

2. Em caso de mais de uma instrução ser processada (chamada, então, de conjunto ou bloco de instruções), quando o if retornar verdadeiro (true) ou falso (false), elas devem estar delimitadas por (...) (tanto para o if quanto para o else ou else if).

3. As condições utilizadas no i fe else if devem estar obrigatoriamen-te entre parênteses, não sendo permitido ter os operadores lógi-cos && e | | fora dos parênteses, pois o C++ Builder trabalha com funções.

Estrutura Condicional 83

7.2 Problemas com Resolução através

do If

7.2.1 Problema 1: Seleção de Categoria Baseado

em uma Idade

Enunciado 7.1

Elabore um programa que solicite ao usuário sua idade e exiba a categoria a qual este se enquadra, considerando a tabela a seguir.

Infantil A 5 a 7 anos

Infantil B 8 a 10 anos

Juvenil A 11 a 13 anos

Juvenil B 14 a 17 anos

Adulto Maiores de 18 anos

7.2.1.1 Uma Análise sobre o Problema

Baseado em apenas um valor que será informado pelo usuário (uma idade), o programa deverá informar em qual categoria existente ele, em relação à natação, se enquadra. A resolução, nesse caso, baseia-se em comparações da idade informada com os valores limites de cada categoria definida pelo enunciado.

Veja que valores inferiores a 0 (zero) não foram considerados no enunciado, assumindo, dessa forma, que, para um valor ser informa-do, deve ser igual ou superior a 5. Fica a sugestão para que você implemente algo que resolva esse problema, não deixando para o usu-ário essa responsabilidade. Vale reforçar que a regra de negócio (o pro-blema) deve ser clara e, caso não seja, você deverá se informar sobre todas as possibilidades.

7.2.1.2 A Interface Gráfica com o Usuário (GUI) e seu

Funcionamento

A figura 7.1 representa a interface gráfica, com a idade já infor-mada pelo usuário e o processamento também já feito, exibindo a sua categoria. Para o caso de uma idade inválida ser informada, uma janela de erro é exibida. As mensagens de erro não serão apresenta-das neste e nos demais exemplos, porém, os códigos responsáveis por elas, sim.

O Labei que representa a categoria deve ser definido em tempo de desenho (Object Inspector) com a propriedade Visible e com o valor False.


É solicitado ao usuário que informe a idade que será armazenada em um Edit, sendo que uma avaliação sobre o valor informado é feita no momento em que o botão é pressionado e a categoria é exibida em um Labei, que inicialmente está invisível. Caso a idade seja inválida, uma janela de erro será exibida ao usuário.

Figura 7.1 - Interface desejada para a resolução do exercício.

7.2.1.3 Sobre a Implementação

A partir desse ponto, serão tratados os comentários que são trechos explicativos, que procuram transcrever, de uma forma clara, observa-ções acerca da instrução implementada, com o objetivo de auxiliar fu-turamente na sua compreensão.

/* texto do comentário */

O comentário inserido entre os delimitadores /* e */ não será tratado pelo compilador e pode estar em mais de uma linha.

// Texto do comentário

O comentário que estiver após o delimitador // deve terminar na mesma linha em que começou.

Resolução 7.1.1 - Evento OnCUckào Button

void __fastcall TfrmCategoria: :BitBtnlClick(TObject *Sender)

/* As instruções abaixo convertem o conteúdo do componente edtldade, que é armazenado na propriedade Text e, em seguida, na variável inteira. Com o valor convertido, é feita a verificação de limite mínimo para a idade válida. Observe que, se for inferior a 5, o programa é interrompido. */

int nldade = StrToInt(edtIdade->Text);

if (nldade < 5) {

MessageDlg("Idade informada é inválida", mtError, TMsgDIgButtonsQ << mbOK, 0);

Abort();

>/* As verificações a seguir identificam, baseadas na idade, qual a categoria para

a idade informada. Essa categoria é atribuída à propriedade Caption do Labei responsável por exibir a categoria. */

else if (nldade <= 7)


lblCategoria->Caption = "Infantil A";


lblCategoria->Caption = "Infantil B";


lblCategoria->Caption = "Juvenil A";


lblCategoria->Caption = "Juvenil B";

else

lblCategoria->Caption = "Adulto";

lblCategoria->Visible = true; // Observe que em C++ é em minúsculo.

>__________________________________________________________________

Na resolução 7.1.1 o primeiro if trata a exceção, ou seja, um valor inválido. Caso a condição seja verdadeira, uma tela com aviso de erro é exibida ao usuário e, em seguida, é executada a instrução Abort(), que interrompe a execução e devolve o comando à interface gráfica.

Todas as condições se baseiam em comparar a idade informada com a tabela do enunciado. Primeiro, verifica-se se a idade é válida, depois se compara uma a uma. Em caso de uma categoria válida, ela é atribu-ída para o Labei que a representa e, então, fica visível.

Veja o código para o evento OnChange do Edit, responsável em ocul-tar o Labei.

Resolução 7.1.2- Evento OnChange do Edit

Esse evento é capturado no momento em que ocorre qualquer alteração no conteúdo da propriedade Text, quer essa alteração ocorra pela interação do usuário, quer ocorra por atribuição direta em código. A maioria dos componentes visuais que interagem com o usuário, permitindo a ele digitação, tem esse mesmo comportamento. Observe que quando se fala em alteração, fala-se em inclusão, retirada ou modificação de seu conteúdo.

void __fastcall TfrmCategoria: :edtIdadeChange(TObject *Sender)

{if (lblCategoria->Visible)

lblCategoria->Visible = false; // oculta o Labei, caso ele esteja visível

_>_______________________________________________________________

7.2.2 Problema 2: Cálculo do Peso Ideal de uma

Pessoa

Enunciado 7.2

Tendo a altura e o sexo como dados de entrada de uma pessoa ('Af, masculino e 'F, feminino), construa um algoritmo que calcule seu peso

ideal, utilizando as seguintes fórmulas:- Para homens: (72.7*h)-58_____- Para mulheres: (62.1*h)-44.7



O usuário precisa agora informar dois valores: seu sexo e sua altura. Como a fórmula para o cálculo do peso ideal é diferente para homem e mulher, é necessário, antes, identificar o sexo do usuário ('M', masculi-no e T ', feminino) para saber qual fórmula aplicar.

Procure sempre utilizar o que é sugerido ou o que, de certa forma, é padrão ('M' ou 'F'). Não invente nada que só você será capaz de enten-der. Uma outra situação é, quando utilizar letras, garantir que estas estejam em apenas uma caixa (forma - maiúscula ou minúscula), para que se compare o menos possível ou, ainda, que a quantidade de possi-bilidades seja mínima.

Um ambiente gráfico oferece também objetos visuais que podem substituir entradas simples de dados, principalmente quando as op-ções são previsíveis e limitadas, como, por exemplo, o sexo de uma pessoa. Para apresentar esse recurso, esse enunciado terá duas resolu-ções, uma que tratará a entrada do valor para o sexo, através de uma digitação do usuário; e outra usando um componente visual (RadioGroup), onde o usuário selecionará a opção desejada para o sexo a ser informado, o que evita erros de digitação, comparações a mais ou conversão de letra para maiúscula ou minúscula.


Funcionamento

É possível verificar através das figuras 7.2 e 7.3 as duas implementações. A primeira utiliza como interface o usuário o Edit, tanto para informação de altura como de sexo. A segunda utiliza o Edit para a entrada da altura e um RadioGroup para a seleção do sexo.

Um ponto novo que deve ser tratado para a primeira versão da re-solução é o Edit, onde o usuário informará seu sexo, pois, a princípio, ele poderá digitar a letra que quiser, ou pior, várias letras. Essa limita-ção pode ser facilmente controlada através da propriedade MaxEength, que determina o comprimento máximo do Edit, ou seja, a quantidade máxima de caracteres (não apenas letras) que será possível digitar nele. Deixe o valor 1 (um) para essa propriedade.

•----------------------------------------------------

C á lcu lo do Peso Ideal - Com ..

Altura: |l .94 Peso Ideal 83.0380020141602 ISexo: [M [I p*? Calcular Peso

_________

Figura 7.2 - Interface I desejada para a resolução do exercício.


Figura 7.3 - Interface 2 desejada para a resolução do exercício.

Propriedade para o Objeto Edit

MaxLength: Essa propriedade, no objeto Edit, é responsávelpela limitação em relação a quantidades de caracteres que serão aceitos durante a digitação no componente.

A figura 7.4 representa as propriedades alteradas para o RadioGroup. A seleção de sexo pelo usuário (figura 7.3) é definida na propriedade Items.

C a p tio n S e x o

Colum ns 1

Ite m ln d e x 0

Item s (TStrin gs)

Figura 7.4 - Object Inspector com propriedades manipuladas no RadioGroup.

As propriedades que são utilizadas nesse componente e que não existem nos anteriores são a Itemlndex e a Items. A primeira (Columns) diz em quantas colunas os itens serão exibidos no componente. No exemplo, a quantidade é 1. A propriedade Itemlndex informa (ou sele-ciona) o item que está (ou será) marcado como ativo, entre os que pertecem à propriedade Items.

O uso do componente RadioGroup é recomendado para os casos onde um conjunto de opções são apresentadas ao usuário, e dessas opções apenas uma pode ser por ele escolhida.

Propriedades para o Objeto RadioGroup

Columns: Essa propriedade determina a quantidade de colu-nas que serão utilizadas para a exibição dos itens possíveis de seleção.


Itemlndex: Essa propriedade recebe ou informa qual o item atu-almente selecionado. Por padrão, quando se cria esse objeto, o valor inicial para essa propriedade é -2, ou seja, nenhuma das opções estará seleciona-da. Pode-se ver esses itens como se estivessem em uma matriz de uma dimensão, dessa forma, os ele-mentos começam em 0 (zero) e terminam na quan-tidade de elementos -2, pois é considerada a posi-ção zero como primeiro elemento da matriz.

Items: Essa propriedade é um tipo de dado ligado à classeTStrings, que será melhor detalhada no capítulo 9, referente a matrizes. Através dela, os valores pos-síveis de seleção são informados.


O Labei que representa o peso ideal calculado também tem sua visi-bilidade alterada nesse evento. Note que a validação1 é feita apenas quando o usuário clicar no botão.

Resolução 7.2.1 - Evento OnCHckAo Buttonáa primeira resolução

void __fastcall TfrmPesoComEdit: :BitBtnlClick(TObject *Sender)

{float nPeso;

/* Observe na linha abaixo a chamada à função UpperCase(), que recebe o valor existente no componente edtSexo e o transforma para maiusculo. Então, o

compara com o valor constante M. Caso o valor digitado pelo usuário seja M, o

cálculo baseado na fórmula fornecida para homens é feito. */

if (UpperCase(edtSexo->Text) == "M") {

try {

nPeso = (72.7 * StrToFloat(edtA!tura->Text)) - 58;

}catch (EConvertError &E) {

throw EConvertError("Valor Informado na Altura é Invalido");

>}

// Caso o valor digitado seja F, o código a ser executado é que está abaixo.

else if (UpperCase(edtSexo->Text) == "F") {

try {

nPeso = (62.1 * StrToFloat(edtAltura->Text)) - 44.7;

}catch (EConvertError &E) {


}____1________________________________________________________________

1 Validação na programação se refere à comparação e verificação dos dados, ou seja, se estes são válidos ou não para dar prosseguimento ao implementado.


{ Os valores que deverão ser aceitos são apenas o M ou F, porém não foi apresentado nada para validar logo na digitação, sendo assim, ela é feita no momento em que se deseja efetuar o processo. Dessa forma, caso o valor digitado não seja um dos previstos, uma mensagem de erro é exibida ao usuário. >

else {

MessageDlg("Informe M ou F no campo de Sexo", mtError,TMsgDlgButtons() << mbOK, 0);

edtSexo->SetFocus();

Abort();

>// Após todo o processamento, o Labei que apresentará o peso é exibido.

lblPesoIdeal->Visible = true;

lblPesoIdeal->Caption = FormatFloat("##0.00", nPeso);

>

Resolução 7.2.2- Evento OnEnterdo Editda primeira resolução

void __fastcall TfrmPesoComEdit::edtAlturaEnter(TObject *Sender)

{// No momento em que o foco entra no componente, o Labei responsável porinformar o peso ideal é tornado invisível.//

lblPesoIdeal->Visible = false;

>__________________________________________________________________

Exceções em C++ Builder: O bloco de instruções try... catch tem seu uso recomendado quando uma determinada instrução (ou um conjunto delas) tem alguma probabilidade de gerar erro. Normal-mente, esse erro (exceção) pode ocorrer devido a alguma interação com o usuário ou com algum outro dispositivo, tal como leitura de um arquivo ou, ainda, comunicação com algum dispositivo de hardware.

Nos exemplos apresentados, a exceção pode ser causada por uma interação indevida com o usuário, como, por exemplo, em informar um valor de um tipo não válido. É possível o programador garantir a não-aceitação de um valor proibido.

Try, em inglês, quer dizer "tente", dessa forma, pode ser explicada a estrutura da seguinte maneira:

Tente executar as instruções que estão entre as palavras (instruções) try... e catch e, caso ocorra algum tipo de erro (exceção) em qualquer uma delas, na primeira ocorrência, execute as instruções existentes entre o catch e o delimitador final.

O catch pode ser interpretado como "pegue", "capture". Isso traz a abstração de que, em caso de insucesso em uma das instruções dentro do try, um erro deve ser capturado e é isso que acontece.


O que ocorre muito (e de forma normal) é o uso desse bloco sem especificação de qual exceção deve ser tratada. Por exemplo:

try {

a = dividendo / divisor;

>catch(...) {

ShowMessage("Impossível divisão por zero");

>Observe que, em uma divisão de números inteiros (assume-se que as

variáveis anteriores o são), o único erro possível e esperado é de divisão por zero. Dessa forma, não é tratada a exceção, mas apenas uma men-sagem é exibida ao usuário.

Essa situação não é indicada quando há a possibilidade de mais de um tipo de exceção ocorrer em um bloco de instrução. Dessa forma, é recomendado que se trabalhe com o tipo de exceção específico, como trabalhado no exemplo seguinte, onde se espera pela exceção EConvertError. Veja o exemplo:

try {

nPeso = (72.7 * StrToFloat(edtAltura.Text)) - 58;

>catch(EConvertError &E) {


>Note que, caso ocorra o erro de conversão que dispara a exceção

EConvertError, ela é capturada dentro do catch(), onde uma variável local ao bloco é criada, trazendo nela referências da exceção que po-dem ser obtidas através de suas propriedades.

throw é o gatilho responsável por disparar exceções. Nesse caso, é criada uma exceção do tipo capturado, que nada mais faz do que exibir uma janela com a mensagem de erro enviada como argumento.

int a;

String b = "Texto";

try {

a = StrToInt(b);

}catch (...) {

ShowMessage('Tmpossível conversão");

>Observe que, no bloco try, é solicitada a conversão de uma String B

para um valor inteiro, que deverá ser armazenada em uma variável int a, ocorrendo um erro de conversão, porém, a exceção a ser capturada é uma generalizada (qualquer uma), através do catch(...).


UpperCase()

SintaxeAnsiString UpperCase(const AnsiString S);

ObjetivoTransformar o valor do argumento String em maiúsculo.

ExemplosNome = UpperCase("c++ builder");

sNome = UpperCase(sCidade);

Detalhamento dos Argumentos e Valor de RetornoS: Valor que deverá ser transformado para maiúsculo.

Sobre os ExemplosNo primeiro exemplo, o retorno será atribuído à variável sNome,

que obrigatoriamente (nesse caso) deve ter sido declarada como AnsiString. O valor resultante será "CPP BUILDER".

O segundo exemplo tem uma variável que deve ser do tipo AnsiString, ao invés de um valor constante. Essa é uma situação mais comum. Supondo que a variável sCidade possua "foz do iguaçu", o resultado será "FOZ DO IGUAÇU".

Resolução 7.2.3 - Evento OnCHckáo Button da segunda resolução

void __fastcall TfrmPesoIdealComRadio: :BitBtnlClick(TObject *Sender)

{float nPeso = 0;

{ Observe, na linha abaixo, a verificação sendo feita entre a propriedade

Itemlndex com o valor 0 (zero), ou seja, o primeiro elemento. A ordem dos elementos respeita a ordem de digitação (por linha) na propriedade Items. }

if (rgSexo->ItemIndex == 0) {

try {

nPeso = (72.7 * StrToFloat(edtAltura->Text)) - 58;

>catch (EConvertError &E) {


>>else {

try {

nPeso = (62.1 * StrToFloat(edtAltura->Text)) - 44.7;



}>


{ Observe que o valor que será atribuído à propriedade Visible é, na realidade, uma expressão, porém essa expressão retoma o valor True ou False e o valor resultante dessa expressão que será armazenado. }

lblPesoIdeal->Visible = (nPeso > 0);

lblPesoIdeal->Caption = FloatToStr(nPeso);

}__________________________________________________________________

A implementação para o evento OnEnter do Edit é semelhante ao da primeira resolução.

7.2.3 Problema 3: Cálculo de Crédito para uma Conta

Corrente

Enunciado 7.3

Um banco concederá um crédito especial aos seus clientes, variável com o saldo médio no último ano. Faça um algoritmo que leia o saldo médio de um cliente e calcule o valor do crédito de acordo com a tabela a seguir. Mostre uma mensagem, informando o saldo médio e o valor do crédito.

Saldo Médio Percentual de Crédito

De 0,00 até 200,00 Nenhum

Acima de 200,00 até 400,00 20% do valor do saldo médio

Acima de 400,00 até 600,00 30% do valor do saldo médio

Acima de 600,00 40% do valor do saldo médio


Através do valor do saldo médio deve-se verificar, por meio de uma tabela de valores, em qual intervalo o dado informado se encontra, para, então, chegar ao resultado desejado (percentual de crédito a ser oferecido para o cliente).


Funcionamento

A figura 7.5 exibe o momento da aplicação em execução, demonstran-do o valor do crédito obtido através do cálculo sobre o valor informado.




Observe que no código do evento OnClick (resolução 7.6) as condi-ções utilizadas no If são semelhantes à tabela do enunciado.

A variável nCredito é inicializada com zero (0). A lógica, aqui, parte do princípio que, caso nenhuma das condições de teste (If) for satisfei-ta, o valor informado pelo usuário está entre 0 e 400, nesse caso, sem crédito (por essa razão o valor tem início em zero).

Resolução 7.3 - Evento OnCHckào Button

void __fastcall TfrmSaldoMedio: :BitBtnlClick(TObject * *Sender)

{float nCredito = 0;

float nSaldo;

try {

nSaldo = StrToFloat(edtSaldo->Text);


throw EConvertError("Valor Informado no Saldo é Invalido");

>/* Uma vez o valor informado ter sido convertido, ele é verificado em relação

aos limites informados pelo problema e, em seguida, identificado seu valor percentual. */

if (nSaldo > 200 && nSaldo <= 400)

nCredito = 20;

else if (nSaldo > 400 && nSaldo <= 600)

nCredito = 30;

else if (nSaldo > 600)

nCredito = 40;

/* Observe que o argumento que tem o valor é uma instrução, que representa a regra de três para exibir o valor de crédito corretamente. */

pnlCredito->Caption = FormatFloat("###,##0.00", (nSaldo*nCredito/100));

_>__________________________________________________________________

7.2.4 Problema 4: Identificação da Classe

Eleitoral

Enunciado 7.4

Faça um programa que leia a idade de uma pessoa e informe sua classe eleitoral:

• Não eleitor (abaixo de 16 anos);

• Eleitor obrigatório (entre 18 e 70 anos);

• Eleitor facultativo (entre 16 e 18 anos e acima de 70 anos).



Busca-se identificar qual a categoria do usuário em relação ao papel dele como eleitor, tendo como condição a idade informada.

7.2.4.2 A Interface Gráfica com o Usuário (GUI)

e seu Funcionamento

Note, na figura 7.6, que as categorias possíveis a um eleitor estão exibidas em "caixas", desenhadas através do componente Panei. Ago-ra, o usuário verifica as informações desejadas não por meio de uma resposta direta, mas, sim, através de componentes.


Esse novo exemplo traz o componente UpDown, responsável por, em conjunto com outro componente, permitir o incremento e decremento de valores. Também é trabalhado o componente TrackBar, que traz a impressão de um marcador de posições (ou nível), e o com-ponente Animate, responsável pela reprodução de pequenos AVIs (ani-mações/filmes). Esses componentes podem ser selecionados na guia Win32, como mostra a figura 7.7.

Figura 7.7 - Seleção dos componentes TrackBar, UpDown e Animate na Tool Palette.

O usuário poderá informar a idade através da digitação no Edit ou clicando nas setas do componente UpDown. Não são aceitas idades


negativas e nem superiores a 100. Esse controle é feito inicialmente através de propriedades do componente UpDown. Conforme a idade é informada, uma verificação nos intervalos das categorias é feita e um processamento matemático é realizado para identificar em qual posi-ção o Slider2 é colocado, além da verificação de qual categoria ficará visível para o usuário.

A seguir, tem-se a descrição dos componentes e suas propriedades trabalhadas e as figuras 7.8, 7.9 e 7.10, que exibem o valor de cada propriedade para esse exercício.

Propriedades

Associate:

Increment:

Max:Min:Orientation:

Position:

Propriedades

Align:

Frequency:

Max:Min:Orientation:

Position:

para o Objeto UpDown

Propriedade responsável por informar qual com-ponente estará ligado com o UpDown 5 o qual exi-birá os valores.Informa "de quanto em quanto" o valor será incrementado/decrementado a cada clique nas setas.Limite máximo dos valores.Limite mínimo dos valores.Informa se as setas serão exibidas na vertical ou horizontal.Atribui ou informa o valor a ser exibido no objeto informado na propriedade Associate.

para o Objeto TrackBar

A maioria dos componentes que tem tamanhos ajustáveis possuem essa propriedade. Ela diz como o componente se alinhará em relação ao contêiner a que pertence. Não confunda com alinhamento (justificação).Especifica o incremento entre os Tick mcirks (os riscos).Limite máximo para a propriedade Position. Limite mínimo para a propriedade Position. Informa se o Trackbar será exibido na vertical ou horizontal.Atribui ou informa a posição do Slider.

2 Slider é o componente que é semelhante a uma régua de cálculo e, nesse caso, se moverá dependendo do valor da idade indicado no Edit.


i±rAssociate edtldade

Increment 1Max 100Min 0Orientation udVerticalPosition 0

Figura 7.8 - Object Inspector com propriedades manipuladas no UpDown.

Align alTop /V

Frequency

Max

1

50

Min 0

Orientation trHorizontal

Position 0

Figura 7.9 - Object Inspector com propriedades manipuladas no TrackBar.

|CommonAVI_______ aviEmptyRecycle

Figura 7.10 - Object Inspector com propriedade manipulada no Animate.


Resolução 7.4.1 - Declaração de variável auxiliar para atualização dos

três componentes que devem expressar o mesmo

valor

TfrmEleitor *frmEleitor;

int Origem; // 0 = Digitação no Edit e 1 = Clique no Trackbar

/* Uma vez que é permitido ao usuário que selecione a idade, digitando-a no

Edit, selecionando-a através do UpDown ou através do TrackBar, e que a infor-mação em um componente deve ser propagada para os demais, se faz uso de uma variável flag para que a aplicação não entre em um laço infinito. */

Resolução 7.4.2 - Evento OnEnterúo Edit que recebe a idade

void __fastcall TfrmEleitor::edtIdadeEnter(TObject *Sender)

{/* A variável flag recebe o valor zero quando o foco for para o Edit, pois quer dizer que a digitação pode ocorrer através dele. */

Origem = 0;

_>__________________________________________________________________

Resolução 7.4.3 - Evento OnExitào Edit que recebe a idade

void __fastcall TfrmEleitor: :edtIdadeExit(TObject *Sender)

{/* O foco saindo do Edit quer dizer que pode ocorrer através da seleção direta no

trackbar. */Origem = 1;

_>__________________________________________________________________


Resolução 7.4.4- Evento OnMouseDownào UpDownque seleciona a idade

Esse evento é ativado quando o botão do mouse é pressionado com o

seu ponteiro sobre um componente.

void __fastcall TfrmEleitor: :udIdadeMouseDown(TObject *Sender,

TMouseButton Button, TShiftState Shift, int X, int Y)

{Origem = 0;

>__________________________________________________________________

Resolução 7.4.5 - Evento OnCreatedo Form

void __fastcall TfrmEleitor: :FormCreate(TObject *Sender)

{/* Sempre que a aplicação é iniciada, o formulário (nesta aplicação existe ape-nas um) é criado. No momento em que isso ocorre, a animação deve ser inicializada. Active é uma propriedade que pode ser acessada através do Object Inspector também e ela torna a animação ativa, em execução. */

aviAnimacao->Active = true;

_>__________________________________________________________________

Resolução 7.4.6 - Evento OnChangedo Edit

void __fastcall TfrmEleitor::edtIdadeChange(TObject *Sender)

{try {

{ Observe que, no momento em que ocorre a alteração do valor do Edit, ele é atribuído à propriedade Position do componente UpDown, pois o valor informado

em um desses componentes (Edit e UpDown) deve ser o mesmo no outro. } udIdade->Position = StrToInt(edtIdade->Text);

>catch(Exception &E) {

edtIdade->Text = '0';

>_>__________________________________________________________________

Resolução 7.4.7 - Evento OnChangingào UpDown

Esse evento ocorre no momento em que o valor da propriedade Position está sendo alterado. Diferente do OnChange do Edit, que ocorre após a mudança. O evento pode ser disparado ao clicar em qualquer uma das setas de alteração do componente.Esse evento, em caso de existir em outros componentes, deve ser sempre analisado, pois seu comportamento pode diferenciar de componente para componente.

void __fastcall TfrmEleitor: :udIdadeChanging(TObject *Sender,

bool &AllowChange)

/* A variável de referência recebida pela procedure AllowChange é responsável por permitir ou não a alteração solicitada pelo pressionamento de uma das

setas. Seu padrão é True. Caso por algum motivo não queira que a alteração

de valor solicitada seja atribuída à propriedade Position, atribua False a ela. */


{int nldade = StrToInt(edtIdade->Text);

/* Observe que o valor do Edit, que é automaticamente atualizado pelo UpDown, devido à ligação estabelecida pela propriedade Associate, deve ser também

refletido ao Slider do TrackBar, porém o UpDown tem seu limite em 100 e o TrackBar tem em sua "trilha" 50 pontos. Dessa forma, uma divisão é feita e seu valor inteiro é atribuído à propriedade Position do TrackBar. >

if (Origem != 1)

tbSituacao->Position = StrToInt(edtIdade->Text) / 2;

/* Uma vez tendo a posição identificada, todos os Paneis são ocultados para que, então, após uma avaliação baseada nos limites informados pelo problema, o Panei correto possa ser exibido. */

pnlNao->Visible = False;

pnlFacultativo01->Visible = False;

pnlAtivo->Visible = False;

pnlFacultativo02->Visible = False;

/* É feita a verificação da idade informada com as idades e respectivas catego-rias para, assim, tornar o Panei correto visível. */

if (nldade < 16)

pnlNao->Visible = true;

else if (nldade < 18)

pnlFacultativo01->Visible = true;

else if (nldade < 70)

pnlAtivo->Visible = true;

else

pnlFacultativo02->Visible = true;

>__________________________________________________________________

7.2.5 Problema 5: Identificando o maior entre

dois Números

Enunciado 7.5

Faça um programa que leia dois números e imprima uma mensagem

dizendo qual é o maior deles. Detalhe: se os números forem iguais,

imprima uma mensagem avisando ao usuário._______________________


Dois números são fornecidos e uma simples verificação deve ser fei-ta para informar se o segundo é maior, menor ou igual ao primeiro.


Funcionamento

Note na figura 7.11 que os valores são digitados em dois Edits, res-pectivamente. Há um botão para que seja realizada a comparação e um Labei para a visualização do resultado solicitado.

Estrutura Condiciona] 99

O usuário informa os dois valores que, em tempo de desenho3, foram definidos como zero. Após a digitação, para verificação, deve ser clicado ou pressionado o botão Comparar. Os números não se apagam, podendo o usuário digitar novamente um dos dois ou os dois. O resultado da avaliação é exibido em um Labei com a formatação de cor e de fonte diferenciada.


7.2.5.3 A Implementação

Resolução 7.5 - Evento OnClickdo Button

void __fastcall TfrmNumeros:: BitBtnlClick(TObject *Sender)

{/* Note que apenas são feitas as verificações em relação aos valores dos Edits

para atribuição ao Labei do símbolo que representa o resultado da compara-ção correta. */

if (edtA->Text > edtB->Text)

lblSituacao->Caption =

else if (edtA->Text < edtB->Text)


else


_>__________________________________________________________________

7.3 Conceitualização: Switch

O comando switch é um substituto para if... else, if... else aninhado ou múltiplo, pois ele avalia uma expressão (ou valor) ordinal apenas uma vez e faz as comparações com os valores preestabelecidos.

Sintaxesw itch(expressão) {

case valorl : bloco_de_comando_l;

case valor2 : bloco_de_comando_2;

3 O termo "Tempo de Desenho" refere-se ao momento em que se está desenhando, implementando seu projeto, ou seja, ele, nesse momento, não está em execução.


case valorn : bloco_de_comando_n:

[default]

[comando ou bloco de comando;]

> // do switch, é obrigatório

Onde:<expressão>: Refere-se à variável (função ou resultado de uma

expressão) que terá seu valor comparado aos valo-res dos cases que compõem o switch.

<constantel >: Refere-se ao valor que será comparado com a <ex-pressão, por exemplo:

switch (Opcao) {

case 1 : dia:=idade*365;

break;

case 2 : mes: =(idade*365)/30;

break;

case 3 : hor: = (idade*365)*24;

break;

>[default]: Refere-se ao que deve ser feito para o caso de ne-

nhuma das condições de comparações anteriores ser verdadeira, por exemplo:

switch(Opcao) {

case 1:

dia = idade*365;

ShowMessage(dia + "dias aproximadamente vividos");

break;

case 2:

mes=(idade*365)/30;

ShowMessage(mes + "meses aproximadamente vividos");

break;

case 3:

hor=(idade*365)*24;

ShowMessage(hor + "horas aproximadamente vividos");

break;

default :

ShowMessage("Opção Inválida...");

>

Esclarecimentos:

Assim como o lf, o sivitch faz uma pergunta (switchO) onde é ava-liada a resposta sobre um conjunto definido previamente (valorl... valor2... valorn). O valor da expressão é verificado por mais de uma vez, até que o informado seja identificado como pertencente ao con-junto. Caso o valor verificado não seja identificado dentro das opções do conjunto definido, o código após o default (caso presente) é execu-


tado. É possível também que o valor da expressão seja comparado a um intervalo de valores, da seguinte forma:

O C++ Builder precisa da cláusula case a cada valor a ser verifica-do, e a verificação deve ser feita valor a valor. Não há necessidade dos delimitadores de bloco ( l e i ) . Caso haja o interesse em utilizar essa estrutura para um intervalo de valores, este exemplo deve ser seguido:

switch(Num) {

case 10:

case 11:

case 12: ShowMessage("Categoria A");

break;

case 13:

case 14:

case 15: ShowMessage("Categoria B'');

break;

case 16:

case 17:

case 18: ShowMessage("Categoria C");

break;

default:

ShowMessage("Sem possibilidade de competir");

>Verifique que são necessários vários cases com os valores do intervalo

desejado e, no último case, a instrução a ser executada no caso de um dos valores serem válidos. No momento do break, o switch() é encerrado.

Algumas Considerações:

• O valor da expressão (ou seletor) será comparado com uma das constantes definidas e deve ser declarada com um tamanho má-ximo de 2 bytes, tais como um Byte, Char, Word ou Integer.

• A cláusula default é opcional e, caso o bloco de comandos possua mais de uma linha de instrução, é necessário incluir um con-forme já abordado anteriormente em outras estruturas.

• O I final é obrigatório, pois finaliza a estrutura do sivitch.

7.4 Problemas com Resolução através

do Switch

7.4.1 Problema 6: Ordenar três Números Informados

Enunciado 7.6

Desenvolva um aplicativo que solicite três números reais ao usuário e, através da seleção de uma entre as três opções mostradas na tabela


a seguir, exiba (sem perder a ordem de entrada) os valores na ordem

desejada.

________ Opções a se escolher_____

Ordem crescente__________________

Ordem decrescente________________

O maior fica entre os outros dois números


Três números serão informados pelo usuário sem uma ordem, desconsiderando seus sinais e se são todos iguais. O usuário poderá, após a digitação, visualizar os números de três formas diferentes, as quais são o requisito desejado e identificado no enunciado para a reso-lução do problema.


Funcionamento

A figura 7.12 exibe um GroupBox para a entrada dos valores por parte do usuário e um RadioGroup que mostra as opções possíveis para exibição dos dados informados. Paneis foram incluídos para receber os valores na ordem escolhida pelo usuário. Dessa forma, ele poderá visualizar os dados da maneira que foram introduzidos e na forma que escolheu para a exibição.

O usuário informa os três valores e escolhe a maneira que deseja que eles sejam exibidos nos Paneis. Tendo isso realizado, através do botão Ordenar, a exibição dos números em ordem é feita. Os números digitados permanecem, permitindo, assim, que o usuário selecione outra forma de ordenação.




Resolução 7.6 - Evento Ondickúo Button

void __fastcall TfrmOrdem; :BitBtnlClick(TObject *Sender)

{float Primeiro, Segundo, Terceiro, Auxiliar;

/* Inicialmente é trabalhada a conversão dos valores digitados. */

try {

Primeiro = StrToFloat(edtPrimeiro->Text);


MessageDlg("Atenção, o primeiro valor informado não é um número real", mtError, TMsgDIgButtonsQ << mbOK, 0);

Abort();

>

try {

Segundo = StrToFloat(edtSegundo->Text);


MessageDlg("Atenção, o segundo valor informado não é um número real", mtError, TMsgDlgButtons() << mbOK, 0);

Abort();

>try {

Terceiro = StrToFloat(edtTerceiro->Text);

>catch (Exception &E) {

MessageDlg("Atenção, o terceiro valor informado não é um número real", mtError, TMsgDlgButtons() << mbOK, 0);

Abort();

}/* Obviamente os conjuntos de try... except acima poderiam ser convertidos para

apenas um, porém não seria possível identificar em qual está o problema. */

// Exibição em Ordem Crescente selecionada (ela será trabalhada).

switch (rgOpcoes->ItemIndex) {

case 0: {

/* Observe que devido à troca de valores entre as variáveis, não foi optado pelo uso de else if para a resolução, pois os valores das variáveis se alteram dentro de cada condição. */

pnlTitulo->Caption = "Ordenação crescente";

if (Primeiro > Segundo) {

Auxiliar = Primeiro;

Primeiro = Segundo;

Segundo = Auxiliar;

>

if (Primeiro > Terceiro) {


Primeiro = Terceiro;


Terceiro = Auxiliar;

>if (Segundo > Terceiro) {

Auxiliar = Segundo;

Segundo = Terceiro;


>>

// Exibição em Ordem decrescente selecionada (ela será trabalhada).

case 1: {

pnlTitulo->Caption = "Ordenação decrescente";

if (Primeiro < Segundo) {


Primeiro = Segundo;

Segundo = Auxiliar;

}

if (Primeiro < Terceiro) {


Primeiro = Terceiro;


}

if (Segundo < Terceiro) {

Auxiliar = Segundo;

Segundo = Terceiro;


>>

// Exibição do maior número selecionada (ela será trabalhada).

default : {

pnlTitulo->Caption = "Maior número entre os outros";

if (Primeiro > Segundo) {


Primeiro = Segundo;

Segundo = Auxiliar;

}

if (Segundo < Terceiro) {

Auxiliar = Segundo;

Segundo = Terceiro;


>>

} // swith

pnlPrimeiro->Caption = FloatToStr(Primeiro);

pnlSegundo->Caption = FloatToStr(Segundo);

pnlTerceiro->Caption = FloatToStr(Terceiro);

> _________________________


7.4.2 Problema 7: Cálculo de Imposto a ser

Cobrado sobre Produtos

Enunciado 7.7

Faça um programa que receba:

• O código de um produto comprado, supondo que a digitação do código

do produto seja sempre válida, ou seja, um número entre 1 e 10;

• O peso do produto em gramas;

• O código do país de origem, supondo que a digitação desse código

seja sempre válida, ou seja, um número inteiro entre 1 e 3. Baseie-se nas tabelas a seguir para calcular o valor total a ser cobrado de imposto.

Código do País de Origem Imposto

1 0%

2 15%

3 25%

Código do Produto Preço por Grama

1 a4 10

5 a 7 25

8 a 10 35


É desejado o valor a ser pago em impostos para a importação de um determinado produto, porém esse valor não é simplesmente informa-do pelo usuário, ele depende de outras informações fornecidas pelo usuário, que são: o próprio código do produto e o código do país de origem desse produto.


Funcionamento

A figura 7.13 exibe um GwupBox para a entrada dos valores refe-rentes ao código, peso em gramas para o produto e um RadioGroup com as possibilidades existentes para os países de origem. Um Panei foi incluso com o intuito de apresentar o valor total a ser cobrado de im-posto sobre o produto importado.

O usuário informa o código e peso em gramas para o produto infor-mado e seleciona, entre as opções, o país de origem da mercadoria. Com esses dados informados, através do pressionamento do botão Cal-cular Imposto, as operações responsáveis por esse cálculo são procedi-das. O resultado deverá ser exibido no Panei com fundo amarelo.




Resolução 7.7 - Evento OnClickóo Button

void __fastcall TfrmProdutosImportados: :BitBtnlClick(TObject *Sender)

{int Produto, Peso;

float Imposto, Preco;

try {

Produto = StrToInt(edtProduto->Text);


MessageDlg("Atenção, o código informado não é um valor válido", mtError,

TMsgDIgButtonsQ << mbOK, 0);

AbortQ;

}/* Como o código do produto pode ser digitado, é verificado se o usuário digitou

um código válido. */

if (Produto < 1 || Produto > 10) {

MessageDlg("Atenção, o código deve estar entre 1 e 10.", mtError,

TMsgDlgButtons() << mbOK, 0);

Abort();

>

try {

Peso = StrToInt(edtPeso->Text);


MessageDlg("Atenção, o Peso informado não é um valor válido.", mtError,


Abort();

>{ Como o país pertence a um RadioGroup, não existe a possibilidade de valor

inválido, dessa forma é apenas verificado qual país foi selecionado para iden-tificação correta de alíquota. >


switch(rgPais->ItemIndex) {

case 0: Imposto = 0.00;

break;


break;


break;

>{ Nessa parte, não existe possibilidade de um código inválido para produtos, dessa forma, a identificação do seu preço é feita baseada em um case. Note a presença dos pontos (..), identificando um intervalo entre os valores avaliados. >

switch(Produto) {

case 1: case 2: case 3: case 4:

Preco = 10;

break;

case 5: case 6: case 7:

Preco = 25;

break;


Preco = 35;

break;

default :

MessageDlg("Atenção, o produto informado é inválido", mtlnformation,

TMsgDIgButtonsO >> mbOK, 0);

Abort();

>

float Valorlmposto = (Peso * * Preco) * Imposto;

pnlImposto->Caption = "Imposto a pagar -> " + FormatFloat("###,##0.00",

Valorlmposto);

7.4.3 Problema 8: Cálculo de Imposto, Baseado

em Peso e Estado

Enunciado 7.8

Faça um programa que receba:

• O código do estado de origem da carga de um caminhão, supondo

que a digitação desse código seja sempre válida, ou seja, um número inteiro entre 1 e 5;

• O peso da carga do caminhão em toneladas;

• O código da carga, supondo que a digitação do código seja sempre

válida, ou seja, um número inteiro entre 10 e 40.

Baseie-se nas tabelas abaixo para calcular o valor total a ser cobrado

de imposto:


Código do Estado Imposto

1 35% Código da Carga Preço por Quilo2 25% 10 a 20 1003 15% 21 a 30 2504 5% 31 a 40 3405 Isento


Necessita-se do valor do imposto a pagar com base nas informações fornecidas pelo usuário, as quais devem ser solicitadas por sua aplicação.

7.4.3.2 A Interface Gráfica com o Usuário (GUI) e o seu

Funcionamento

A figura 7.14, que representa a aplicação com a solução, exibe um GroupBox para a entrada dos valores referentes ao código e peso em toneladas para o produto e um RadioGroup com as possibilidades exis-tentes para os estados de origem. Um Panei foi incluso com o intuito de apresentar o valor total a ser cobrado de imposto sobre o produto im-portado.

O usuário informa o código e o peso em toneladas para o produto informado. Seleciona, entre as opções, o estado de origem da mercado-ria e, através do pressionamento do botão Calcular Imposto, as opera-ções responsáveis por esse cálculo são procedidas. O resultado é exibi-do no Panei com fundo em amarelo.

Produtos por Estado

Dados do Produto

Código da Carga: |1

Estado de Origem

- . d «■ i 2 r 3

r Informe o código e pressione ENTER, ou selecione nas setas ao lado ------- 1-------- carcraaranposto------- -------------



Aqui, a forma de trabalhar varia no que diz respeito à validação da digitação do usuário diretamente no Edit, pois os limites estão no UpDown. Para efeito de aprendizado, diferentemente do exemplo ante-rior, a atribuição do valor do Edit ao UpDown é avaliada após o pressionamento de uma tecla, a tecla Enter. Obviamente essa não é a melhor situação, pois o usuário é obrigado a pressionar uma tecla para o


texto ser validado e, em uma interface visual, isso não é viável, mas fica como atividade encontrar uma solução que equacione essa necessidade.

Para que o usuário saiba dessa necessidade, foi inserida essa infor-mação como Hint (propriedades Hint e ShowHint). Veja os objetos e seus respectivos eventos trabalhados nessa implementação.

Resolução 7.8.1 - Evento Ondickào BitBtn

void __fastcall TfrmProdutosPorEstado: :BitBtnlClick(TObject *Sender)

{/* A implementação tratada nesse código é semelhante às trabalhadas anterior-

mente, dessa forma, fica como atividade uma documentação através de co-mentário. A exceção é o uso dos cases no switch, que têm seu comentário à parte. */

int Carga, Peso;

double Imposto, Preco, Valorlmposto;

try {

Carga = StrToInt(edtCarga->Text);


MessageDlg("Atenção, o código informado não é um valor válido", mtError,


Abort();

}

if (Carga < 10 11 Carga > 40) {

MessageDlg("Atenção, o código deve estar entre 10 e 40.", mtError,


Abort();

>

try {

Peso = StrToInt(edtPeso->Text);

}catch(EConvertError &E) {

MessageDlg("Atenção, o Peso informado não é um valor válido.", mtError,


AbortQ;

>

switch(rgEstado->ItemIndex) {


break;


break;


break;


break;



break;

>

switch(Carga) {

case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:


Preco = 100;

break;


case 29: case 30:

Preco = 250;

break;


case 39: case 40:

Preco = 340;

break;

}

Valorlmposto = ((Peso*1000) * Preco) * Imposto;

pnlImposto->Caption = "Imposto a pagar -> " + FormatFloat("###,##0.00",

Valorlmposto);

Resolução 7.8.2- Evento OnKeyDowndo Edit

Esse evento é capturado no momento em que ocorre o pressionamento de qualquer tecla, quer sejam letras, números ou símbolos; uma tecla de ação (Enter ou Esc, por exemplo); ou uma tecla auxiliar (Shift, Alt ou Ctrl). A função que trata esse evento recebe três argumentos, o objeto que disparou o evento, a tecla pressionada (valor ASCII) e o estado das teclas Shift, Alt e Ctrl no momento em que ocorreu o evento.Esse evento é semelhante ao OnKeyPress com a diferença de que captura o pressionamento de teclas combinadas com Alt, Shift ou Ctrl, teclas de funções (F1,F2,...) e também teclas de valor não ASCII.

void __fastcall TfrmProdutosPorEstado: :edtCargaKeyDown(TObject *Sender,

WORD &Key, TShiftState Shift)

{{ Verifique que a variável key é recebida por essa procedure através de uma

referência (mais detalhes no capítulo 12). Isso quer dizer que o valor dela pode mudar dentro da procedure e refletir para o serviço chamador. Verifique o uso da constante VK_RETURN, ao invés do valor 13 que representaria a tecla Enter. }

if (Key == VK_RETURN) {

try {

udCarga->Position = StrToInt(edtCarga->Text);

>catch(...) {

edtCarga->Text = "0";

>}


7.4.4 Problema 9: Identificação de Reajuste e

Características para um Funcionário

Enunciado 7.9

Faça um programa que receba o valor do salário mínimo, o turno de trabalho, a categoria e o número de horas trabalhadas no mês de um funcionário. Supondo a digitação apenas de dados válidos, calcule e mostre:

• O coeficiente do salário, de acordo com a tabela a seguir:

Turno de Trabalho Valor do Coeficiente

Matutino 10% do Salário Mínimo

Vespertino 15% do Salário Mínimo

Noturno 12% do Salário Mínimo

• O valor do salário bruto, ou seja, o número de horas trabalhadas

multiplicado pelo valor do coeficiente do salário;

• O imposto de acordo com a tabela a seguir:

Categoria Salário BrutoImposto sobre o

Salário Mínimo

Operário>= Ft$ 300,00 5%

< R$ 300,00 3%

Gerente >= R$ 400,00 6%

• A gratificação, de acordo as regras a seguir:

Se o funcionário preencher todos os requisitos a seguir, sua gratificação será de R$ 50,00, caso contrário, será de R$ 30,00. Os

requisitos são:

• Turno: Noturno

• Número de horas trabalhadas: Superiora 80

• O auxílio-alimentação, de acordo com as regras a seguir:

Se o funcionário preencher algum dos requisitos a seguir, seu auxílio- alimentação será de um terço do seu salário bruto, caso contrário, será de metade do seu salário bruto. Os requisitos são:

• Categoria: Operário• Coeficiente de Salário: <=25

• O salário líquido, ou seja: bruto, menos imposto, mais gratificação,

mais auxílio-alimentação.

• A classificação, de acordo com tabela a seguir:

Salário Líquido Mensagem

Menor que R$

350,00 Mal remunerado

Entre R$ 350,00

e R$ 600,00 Normal

Maior que R$

600,00 Bem remunerado



Sua aplicação deverá solicitar algumas informações ao usuário e, baseado nas respostas dele, seu código terá que proceder com algumas análises para chegar às respostas desejadas.


Funcionamento

A figura 7.15 representa a aplicação com os Labeis e Edits (salário mínimo e horas trabalhadas), dois RadioGroups (categoria e turno de trabalho) e dois Paneis (com informações solicitadas e a qualidade da remuneração do funcionário).

O usuário informa o valor atual para o salário mínimo, a quantida-de de horas trabalhadas, identifica qual a categoria do funcionário em questão e o turno em que ele trabalha. Após isso informado, ele pressi-ona o botão Calcular para que o processamento e a resolução ocorram. Cada um dos pontos desejados terá seu valor exibido no maior Panei e a identificação da qualidade de remuneração do funcionário é exibida no Panei amarelo.



Resolução 7.9 - Evento OnCUckáo BitBtn

void __fastcall TfrmSalarioFuncionario: :BitBtnlClick(TObject *Sender)

{int Horas;

double SalarioMinimo, Coeficiente, SalarioBruto, Imposto, Gratificacao, Auxilio,


Salarioüquido;

try {

Horas = StrToInt(edtHoras->Text);


MessageDlg("Atenção, a quantidade de horas informadas é inválida", mtError,

TMsgDIgButtonsO << mbOK, 0);

Abort();

}

try {

SalarioMinimo = StrToFloat(edtSalarioMinimo->Text);


MessageDlg("Atenção, o valor do salário mínimo informado é inválido.", mtError,

TMsgDIgButtonsO << rnbOK, 0);

AbortO;

>

switch(rgTurno->ItemIndex) {

case 0: Coeficiente = 0.10;

break;


break;


break;

>

Coeficiente = SalarioMinimo * Coeficiente;

lblCoeficiente->Caption = FormatFloat("###,##0.00", Coeficiente);

SalarioBruto = Coeficiente * Horas;

lblSalarioBruto->Caption = FormatFloat("###,##0.00", SalarioBruto);

/* Observe que, para um case, é possível a inserção de uma outra estrutu-ra condicional, nesse caso um if. Porém, qualquer estrutura já vista e as que ainda serão trabalhadas podem ser inseridas dentro de uma outra estrutura. */

switch(rgCategoria->ItemIndex) {

case 0:

if (SalarioBruto >= 300.00)

Imposto = 0.05;

else

Imposto = 0.03;

break;

case 1:

if (SalarioBruto >= 400.00)

Imposto = 0.06;

else

Imposto = 0.00;

break;

>


Imposto = (SalarioMinimo * Imposto);

lblImposto->Caption = FormatFloat("###,##0.00", Imposto);

if (rgTurno->ItemIndex == 2 && Horas > 80)

Gratificacao = 50.00;

else

Gratificacao = 30.00;

lblGratificacao->Caption = FormatFloat("###,##0.00", Gratificacao);

if (rgCategoria->ItemIndex == 0 && Coeficiente <= 25.00)

Auxilio = (SalarioMinimo / 3);

else

Auxilio = (SaiarioBruto / 2);

lblAuxilio->Caption = FormatFloat("###,##0.00", Auxilio);

SalarioLiquido = SaiarioBruto - Imposto + Gratificacao + Auxilio;

lblSalarioLiquido->Caption = FormatFloat("###,##0.00", SalarioLiquido);

if (SalarioLiquido < 350.00)

pnlSituacao->Caption = "Mal remunerado";

else if (SalarioLiquido <= 600.00)

pnlSituacao->Caption = "Normal";

else

pnlSituacao->Caption = "Bem remunerado";

7.4.5 Problema 10: Cálculo de Rendimento

Enunciado 7.10

Uma agência bancária possui dois tipos de investimentos, conforme o quadro a seguir. Faça um programa que receba o tipo de investimento e o seu valor, e que calcule e mostre o valor corrigido de acordo com o tipo de investimento.

Tipo Descrição Rendimento Mensal1 Poupança 3%

2 Fundos de Renda Fixa 4%


O problema apresentado nesse enunciado tem como diferença, em relação aos anteriores, apenas o contexto em que está inserido. Note que é solicitado, como solução, um valor, que deve ser calculado com base em uma tabela de opções e que esse cálculo será feito sobre um valor informado pelo usuário.



Funcionamento

A interface para resolução do problema proposto pelo enunciado (figura 7.16) é composta por componentes para informação do valor do investimento e opções de seleção quanto ao tipo de investimento. Possui o botão que dispara a execução da solução e um Panei onde o resultado é exibido.


O usuário informa o valor e o tipo do investimento e, então, pressio-na o botão Calcular. Nesse instante, é efetuado o processamento e o resultado é apresentado no Panei com fundo amarelo.

Para ilustrar o uso de um novo componente, para essa resolução é utilizado um componente não visual, o Timer. Ele é dito como não visual devido ao fato de poder ser referenciado apenas em tempo de desenho, ou seja, em sua aplicação o usuário sequer sabe da exis-tência dele, como pode ser visto na figura 7.19, que representa o formulário em tempo de desenho onde o Timer aparece. Esse com-ponente está na aba System da paleta de componentes, como mos-tra a figura 7.17.

O componente Timer tem uma finalidade muito especial: ele cap-tura, de tempo em tempo (milissegundos), a execução do sistema para que sua aplicação possa desempenhar uma atividade deseja-da, a qual deve ser executada de forma automática, muitas vezes sem interação do usuário. Em nosso exemplo, esse componente foi inserido para que um relógio seja exibido e a hora automaticamente atualizada.


Figura 7.17 - Seleção do componente Timer na Toll Palette.

É possível desabilitar a execução através da propriedade Enabled e também controlar o tempo em que o componente deve ser ativado pela propriedade Interval, que tem seu valor em milissegundos (onde o va-lor 1000 representa 1 segundo), observe na figura 7.18. Não é reco-mendado o uso de vários componentes Timers em apenas uma aplica-ção, pois isso pode causar queda de desempenho.

Figura 7.18 - Object Inspector com propriedades manipuladas no Timer.

Propriedades para o Objeto Timer

Enabled: Essa propriedade é responsável por ativar/desativar a execução do código implementado no evento OnTimer.

Interval: Tempo atribuído ao componente como intervalopara captura da execução da aplicação.


Resolução 7.10.1 - Evento OnCHckào BitBtn

void __fastcall TfrmAgenciaBancaria: :BitBtnlClick(TObject *Sender)

{float Investimento, NovoValor;

try {

Investimento = StrToFloat(edtInvestimento->Text);



MessageDlg("Atenção, o valor do investimento informado é inválido.", mtError,

TMsgDIgButtonsO << mbOK, 0);

Abort();

>

switch(rgInvestimento->ItemIndex) {

case 0: NovoValor = Investimento * 1.03;

break;

case 1: NovoValor = Investimento * 1.04;

break;

>

pnlNovoValor->Caption = FormatFioat("###,##0.00", NovoValor);

}__________________________________________________________________

Resolução 7 .10.2-Evento OnTimerào Timer

Esse evento é capturado a cada intervalo de tempo, o qual é estipulado pela propriedade Interval. Nesse evento, é possível implementar funcionalidades que devem ser executadas periodicamente, algumas vezes sem a intervenção do usuário e até sem ele saber.

void __fastcall TfrmAgenciaBancaria: :timerHoraTimer(TObject *Sender)

{{ Time() é responsável por informar a hora atual em seu computador. O resulta-

do é um valor TDateTime, que deve ser convertido para String, para poder ser armazenado no Panei. >

pnlRelogio->Caption = TimeToStr(Time());

_>__________________________________________________________________

Time e Time()

SintaxeTDateTime Time();

Objetivo

Retonar a hora atual do sistema (computador).

Exemplo

TimeQ;

7.5 Conclusão

A utilização da estrutura condicional apresentada neste capítulo aumenta a solução de vários problemas. É possível utilizar tanto o if simples, o if aninhado e, ainda, o switch. Quem determinará qual usar será você, desenvolvedor. Assim, procure nos exercícios propostos, na seção Exercícios, alternar o uso dessas técnicas, não ficando somente em uma delas.


Use componentes, propriedades e eventos já apresentados para incrementar a interface também. Somente a prática sedimentará os conhecimentos. Isso só depende de você. Mãos à obra!!

Exercícios

1. A prefeitura de Piripiri abriu uma linha de crédito para os funci-onários estatutários. O valor máximo da prestação não pode ul-trapassar 30% do salário bruto. Seu programa deverá receber o salário bruto e o valor da prestação. Com esses valores, ele deve-rá informar se o empréstimo pode ou não ser concedido.

2. Um comerciante comprou um produto e quer vendê-lo com um lucro de 45% se o valor da compra for menor que R$ 20,00; caso contrário, o lucro será de 30%. Seu programa deverá receber o valor do produto e informar o valor para a sua venda.

3. Faça um programa que possa converter uma determinada quan-tia dada em reais para uma das seguintes moedas:

a) Pesos Argentinos;

b) Libra Esterlina;

c) Dólar;

d) Iene;

e) Euro.

Note que as cotações para essas moedas devem ser também soli-citadas e estarem visíveis ao usuário.

4. Em um campeonato nacional de arco-e-flecha, tem-se equipes de três jogadores para cada estado. Sabendo-se que os arqueiros de uma equipe não obtiveram o mesmo número de pontos, seu pro-grama deverá informar se a equipe foi classificada, de acordo com a seguinte especificação:

a) Ler os pontos que cada jogador da equipe obteve;

b) Mostrar esses valores em ordem decrescente;

c) Se a soma dos pontos for maior que 100, imprimir a média aritmética entre eles; senão, informar que a equipe foi desclassificada;

d) Um jogador não pode ter pontuação negativa e, tampouco, superior a 100.

5. Faça um programa que receba dois números e execute uma das operações listadas a seguir de acordo com a escolha do usuário:

Estrutura Condicional - eisnt.org+/manuais/07_Estruturas_condic... · Estrutura Condicional 83 7.2...

Documents

Transcript of Estrutura Condicional - eisnt.org+/manuais/07_Estruturas_condic... · Estrutura Condicional 83 7.2...