Baixe Programação em C++ com exemplos de algoritmos e funções e outras Notas de estudo em PDF para Informática, somente na Docsity!
- Programa em Linguagem C++ Builder
#include <stdlib.h> // contém atoi()
#include <math.h> // contém pow()
// no botão OK:
int A, B, C, D;
float x1, x2;
A = atoi(Edit1->Text.c_str());
B = atoi(Edit2->Text.c_str());
C = atoi(Edit3->Text.c_str());
D = pow(B,2) - 4AC;
if (D >= 0)
x1 = (-B + sqrt(D))/ 2*A;
x2 = (-B - sqrt(D))/ 2*A;
Edit4->Text = x1;
Edit5->Text = x2;
else
ShowMessage("Delta < 0");
2.4.5. Exercício
1. Escreva um programa para converter graus Celsius para Fahrenheit, e vice versa, a partir de
uma temperatura fornecida por um usuário, usando o form A) e o form B).
form A form B
2.5. Laços de repetição em C
2.5.1. Loop Para/Faça (for)
Exemplo :
Desenvolva um programa que gere uma tabela de conversão de temperatura de graus
Farenheit para graus Celcius.
Portugol Linguagem C++ Builder
inicio
inteiro x;
real C, F;
para F de 0 até 100 faça
C <- (5 * (F-32)) / 9;
fim para
fim
int x;
float C, F;
for (F = 0; F < 100; F++ )
C = (5 * (F-32)) / 9;
2.5.2. Loop Enquanto/Faça (while)
Portugol Linguagem C++ Builder
inicio
inteiro x;
real C, F;
F <- 0;
enquanto F < 100 faça
C <- (5 * (F-32)) / 9;
F <- F + 1;
fim para
fim
int x;
float C, F;
F = 0;
while (F < 100)
C = (5 * (F-32)) / 9;
F++; // F = F + 1;
2.5.5 Exercícios
1. Altere o loop for do exemplo anterior, para os loops while e do/while.
2. Escreva o algoritmo e o respectivo programa em C para um programa que conte a
quantidade de números pares e ímpares digitados por um usuário. O usuário pode digitar
quantos números quiser, e pode encerrar o programa quando desejar.
3. Escreva o algoritmo e o respectivo programa em C, para um programa que conte a
quantidade de números primos digitados por um usuário. O usuário pode digitar quantos
números quiser, e pode encerrar o programa quando desejar.
2.6. PROCEDIMENTOS EM C
2.6.1. Definição
A utilização de procedimentos permite que um conjunto de comandos possa ser usado
repetidas vezes dentro de um programa, sem a necessidade de reescrever o código várias
vezes. Um bloco de comandos é associado a um nome (nome do procedimento); sempre que
for necessário executar estes comandos, basta chamar o nome do procedimento.
2.6.2. Exemplo 1
Desenvolva um programa que calcule a soma de dois valores reais fornecidos pelo usuário.
- Formulário:
- Dentro do Botão [+]:
void __fastcall TForm1::Button1Click(TObject *Sender)
float valor1,valor2,resp;
valor1 = atof(Edit1->Text.c_str());
valor2 = atof(Edit2->Text.c_str());
resp = valor1 + valor2;
Edit3->Text = resp;
#include <vcl.h> #pragma hdrstop #include <stdlib.h> #include "Unit1.h" #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //------------------------------------------------------------------------
float resp; //------------------------------------------------------------------------- void Soma( float a, float b) { resp = a + b; } //------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { float valor1,valor2; valor1 = atof(Edit1->Text.c_str()); valor2 = atof(Edit2->Text.c_str()); Soma(valor1,valor2); Edit3->Text = resp; } //------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { float valor1; valor1 = atof(Edit1->Text.c_str()); Soma(valor1,10); Edit3->Text = resp; } //------------------------------------------------------------------------
1 - Bibliotecas e diretivas de
compilação
2 -Espaço para declaração de
variáveis globais
3 - Espaço para declarar
procedimentos e funções ou
seus protótipos.
4 -Trecho de programa do
botão [+] e a chamada do
procedimento Soma.
5 -Trecho de programa do
botão [+ 10] e a chamada do
procedimento Soma.
Da listagem anterior pode-se observar que a observação número:
1 – identifica o local aonde são adicionadas as bibliotecas e diretivas do programa. Sempre no
início da Unit,
2 –identifica o local para declaração de variáveis globais. As variáveis globais devem existir
antes de serem usadas pelo programa, pos isto vem antes; note que a variável resp é usado
dentro do procedimento, e também dentro de cada botão.
3 –identifica o local para escrever os procedimentos (ou protótipos). Da mesma forma que a
variável global, o procedimento precisa primeiro existar para que possa ser usado pelo resto
do programa. Pode ser escrito o procedimento inteiro ou apenas o protótipo; neste caso o
bloco do procedimento pode ser escrito em qualquer parte do programa. (menos dentro de
eventos do formulário).
4- identifica a chamada do procedimento. No momento em que precisa-se calcular a soma,
chama-se o procedimento. Note que existe passagem de parâmetros. O conteúdo de valor1 é
passado para a variável a do procedimneto e o conteúdo de valor2 é passado para a variável b
do procedimento. Observe também que valor1 e valor2 são variáveis locais do botão, portanto
não podem ser acessadas pelo procedimento; por isto é necessário realizar passagem de
parâmetros. As variáveis a e b são locais do procedimento (só existem dentro do
procedimento), mas a resposta é atribuída a resp, que é uma variável global, portanto pode ser
acessada por todo o programa.
5- igual ao item 4, com o valor constante 10 em vez da variável valor2.
2.6.3. Protótipo
Dado o exemplo anterior, formalmente pode-se criar o protótipo de um procedimento com
apresentado a seguir:
NomeDoProcedimento(lista de parâmetros);
Sempre declarando o procedimento como global, ele pode ser acessado em qualquer parte do
programa.
D = pow(B,2) - 4AC; // calcula delta if ( D >= 0 ) // testa se existe raízes { x1 = (-B + sqrt(D))/ 2A; x2 = (-B - sqrt(D))/ 2A; Edit4->Text = x1; // apresenta resposta Edit5->Text = x2; } else { ShowMessage("Delta < 0"); Edit1->Text = ""; // limpa Caixas de Texto Edit2->Text = ""; Edit3->Text = ""; Edit4->Text = ""; Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado } } //----------------------------------------------------- // botão para limpar os valores da tela void __fastcall TForm1::Button2Click(TObject *Sender) { Edit1->Text = ""; // limpa Caixas de Texto Edit2->Text = ""; Edit3->Text = ""; Edit4->Text = ""; Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado } //-----------------------------------------------------
No exemplo acima , note que os trechos de programa escritos em vermelho se repetem. Então
podemos transformar o trecho repetido, em um procedimento.
b) Com Procedimento
// declaração de variáveis globais
int A, B, C, D; float x1, x2; //---------------------------------------------------- // procedimento para limpar a tela void LimpaTela( void ) { Form1->Edit1->Text = ""; // limpa Caixas de Texto Form1->Edit2->Text = ""; Form1->Edit3->Text = ""; Form1->Edit4->Text = ""; Form1->Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado }
void __fastcall TForm1::Button1Click(TObject Sender) { A = atoi(Edit1->Text.c_str()); B = atoi(Edit2->Text.c_str()); C = atoi(Edit3->Text.c_str()); D = potencia(B,2) - 4AC; if ( D >= 0 ) { x1 = (-B + sqrt(D))/ 2A; x2 = (-B - sqrt(D))/ 2*A; Edit4->Text = x1; Edit5->Text = x2; } else { ShowMessage("Delta < 0"); LimpaTela(); } } //-----------------------------------------------------
variável que vai retornar o valor deve ser do mesmo tipo da função. Observe que a função
sempre tem um tipo, ou seja, uma função pode ser do tipo inteiro, real, etc. Quando a função
não tem um tipo ( void ), então ela não pode retornar um valor, ou seja passa a ser um
procedimento.
2.7.4. Exemplo 1
Desenvolva um programa que calcule a soma de dois valores reais fornecidos pelo usuário.
- Formulário:
No exemplo de procedimento os conteúdos das variáveis locais eram trocados via passagem
de parâmetros, mas a variável de resposta resp, passou a ser global a fim de receber a soma
dos conteúdos passados para a e b.
Agora, se a variável resp não for mais declarada como global, ou seja, passar a ser local de
cada botão, então pode-se reescrever o procedimento na forma de uma função, como
apresentado a seguir:
#include <vcl.h> #pragma hdrstop #include <stdlib.h> #include "Unit1.h" #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //------------------------------------------------------------------------
//------------------------------------------------------------------------- void Soma( float a, float b) { float r; r = a + b; return r; } //------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { float valor1,valor2 , resp;; valor1 = atof(Edit1->Text.c_str()); valor2 = atof(Edit2->Text.c_str()); resp = Soma(valor1,valor2); Edit3->Text = resp; } //------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { float valor1, resp; valor1 = atof(Edit1->Text.c_str()); resp = Soma(valor1,10); Edit3->Text = resp; }
1 - Bibliotecas e diretivas de
compilação.
2 -Espaço para declaração de
variáveis globais.
3 - Espaço para declarar
procedimentos e funções ou
seus protótipos.
4 -Trecho de programa do
botão [+] e a chamada da
função Soma.
5 -Trecho de programa do
botão [+ 10] e a chamada da
função Soma.
#include <vcl.h> #pragma hdrstop #include "raizes.h" #include <stdlib.h> // contém atoi() #include <math.h> // contém pow() #pragma package(smart_init) #pragma resource "*.dfm" TForm1 Form1; //---------------------------------------------------- // declaração de variáveis globais int A, B, C, D; float x1, x2; //---------------------------------------------------- __fastcall TForm1::TForm1(TComponent Owner) : TForm(Owner) { } //----------------------------------------------------- void LimpaTela( void ) { Form1->Edit1->Text = ""; // limpa Caixas de Texto Form1->Edit2->Text = ""; Form1->Edit3->Text = ""; Form1->Edit4->Text = ""; Form1->Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado } //------------------------------------------------------ // função que realiza o cálculo da potência long potencia( int base, int exp) { int x; // conta o número de vezes a ser multiplicado long resp = base; for (x=1; x<exp; x++) { resp = resp * base; } return resp; }
void __fastcall TForm1::Button1Click(TObject Sender) { A = atoi(Edit1->Text.c_str()); B = atoi(Edit2->Text.c_str()); C = atoi(Edit3->Text.c_str()); D = potencia(B,2) - 4AC; // chamada da função if ( D >= 0 ) { x1 = (-B + sqrt(D))/ 2A; x2 = (-B - sqrt(D))/ 2*A; Edit4->Text = x1; Edit5->Text = x2; } else { ShowMessage("Delta < 0"); LimpaTela(); // chamada do procedimento } } //----------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { LimpaTela(); // chamada do procedimento } //-----------------------------------------------------
2.7.6. Exercícios
1. Escreva e teste o funcionamento dos exercícios acima.
2. Modifique o programa do cálculo do fatorial para uma função que calcule o valor do
fatorial de um número.
3. Desenvolva um programa que permita realizar operações de adição e subtração de dois
valores fornecidos pelo usuário, através de uma função.
2.8.2. Incremento/Decremento a Priori
Neste caso, primeiro é incrementado o valor, e depois é atribuído a variável.
Exemplo:
Incremento Decremento
int total;
int valor;
valor = 1;
total = ++valor;
/** neste exemplo valor é incrementado e
depois é feita a atribuição **/
int total;
int valor;
valor = 1;
total = --valor;
/** neste exemplo valor é decrementado e
depois é feita a atribuição **/
2.8.3. Exercício
Qual o conteúdo das variáveis total e valor após a execução dos seguintes comandos?
int valor, total;
valor = 3;
total = 5;
total = valor++;
total = ++valor;
total = valor--;
total = --valor;
2.9. Atribuição Composta
Através da combinação de operadores pode-se fazer atribuições das seguintes formas:
Exemplo :
total += valor; // total = total + valor;
valor += 1; // valor = valor + 1;
valor *= 10; // valor = valor * 10;
2.9.1. Exercício
Qual o valor das variáveis valor e total após a execução dos seguintes comandos?
int valor = 3;
int total = 5;
total *= ++valor;
2.10. Atribuição Múltipla
Depois de declaradas as variáveis podem-se ter comandos de atribuição da seguinte forma:
total = valor = resposta = 0; // atribui 0 a todas as variáveis
2.10.1. Exemplo
int resposta, valor, total;
resposta=total=0;
valor=4;
reposta = total + valor;
ou, {
int resposta, valor, total;
resposta=total=0;
reposta = total + (valor = 4);
