6. 1 – Dê 5 passos para frente
2 – Vire 90 graus para a direita
3 – Dê 7 passos para frente
4 – Vire 90 graus para a esquerda
5 – Fique de joelhos
6 – Estenda sua mão e pegue o objeto que
estiver à sua frente
7 – Levante-se
8 – Vire 90 graus à esquerda
9 – Dê 7 passos para frente
10 – Vire 90 graus à esquerda
11 – Dê 5 passos para frente
12 – Entregue-me o objeto
10. Receita de bolo
INGREDIENTES
MASSA
• 1/2 xícara (chá) de óleo
• 3 cenouras médias raladas
• 4 ovos
• 2 xícaras (chá) de açúcar
• 2 e 1/2 xícaras (chá) de farinha de trigo
• 1 colher (sopa) de fermento em pó
COBERTURA
• 1 colher (sopa) de manteiga
• 3 colheres (sopa) de chocolate em pó
• 1 xícara (chá) de açúcar
• 1 xícara (chá) de leite
MODO DE PREPARO
MASSA
1. Em um liquidificador, adicione a cenoura, os ovos e o óleo, depois misture.
2. Acrescente o açúcar e bata novamente por 5 minutos.
3. Em uma tigela ou na batedeira, adicione a farinha de trigo e depois misture novamente.
4. Acrescente o fermento e misture lentamente com uma colher.
5. Asse em um forno preaquecido a 180° C por aproximadamente 40 minutos.
COBERTURA
1. Despeje em uma tigela a manteiga, o chocolate em pó, o açúcar e o leite, depois misture.
2. Leve a mistura ao fogo e continue misturando até obter uma consistência cremosa, depois
despeje a calda por cima do bolo.
11. Calculando as raízes de uma equação do 2º
grau
1. Identificar os coeficientes a, b e c
2. Calcular o valor de delta
Δ = 𝑏𝑏2 − 4𝑎𝑎𝑎𝑎
3. Se o delta é negativo, a equação não possui raízes reais
4. Se o delta é nulo, a equação possui 1 raiz (-b/2a)
𝑥𝑥 =
−𝑏𝑏
2𝑎𝑎
5. Se o delta é positivo, a equação possui duas raízes
𝑥𝑥 =
−𝑏𝑏 ± 𝑏𝑏2 − 4𝑎𝑎𝑎𝑎
2𝑎𝑎
13. Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa
• Algoritmo é uma sequência finita de instruções
ou operações cuja execução, em tempo finito,
resolve um problema computacional
14. Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa
• Algoritmo é uma sequência finita de instruções
ou operações cuja execução, em tempo finito,
resolve um problema computacional
15. Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa
• Algoritmo é uma sequência finita de instruções
ou operações cuja execução, em tempo finito,
resolve um problema computacional
16. Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa
• Algoritmo é uma sequência finita de instruções
ou operações cuja execução, em tempo finito,
resolve um problema computacional
17. Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa
• Algoritmo é uma sequência finita de instruções
ou operações cuja execução, em tempo finito,
resolve um problema computacional
20. O que é uma
Variável?
• Variável é uma posição na memória do
computador reservada pelo programa durante a
sua execução para armazenar dados que serão
utilizados pelo próprio programa
• Estes dados podem ter sido gerados pelo próprio
programa (comandos de repetição, comando de
atribuição, etc.) ou inseridos pelo usuário através
de um comando de entrada/leitura de dados
23. Tipos de
dados
• Numéricos
• INTEIRO
• São os valores numéricos inteiros (sem
casas decimais)
• Podem ser valores positivos ou negativos
• Ex: 0, -2, 47, 58, 123220, -34235
• REAL ou PONTO FLUTUANTE
• São os valores numéricos que possuem
casas decimais
• Podem ser valores positivos ou negativos
• Ex: 0.12, -45.17, 3.14159, 0.000001, 2
24. Tipos de
dados
• Não Numéricos
• LÓGICO ou BOOLEANO
• Representadas por apenas 2 valores:
• Verdadeiro
• Falso
• CARACTERE
• Representadas por uma sequência de
caracteres (letras, números ou caracteres
especiais)
• Textos em geral
• Ex: "Av. Amazonas", "José da Silva",
"20/10/1998"
25. Tipos de
dados
• Nota de uma prova
• Nota final de uma disciplina
• Endereço
• CPF
• RG
• Número do CEP
• Taxa SELIC
• Preço de um notebook novo
• Marca do seu carro
• Peso do seu pet
• Qtde de títulos do seu time
• Nome do seu time
• Número do seu sapato
• Seu usuário no Instagram
• Seu e-mail
• Você tem CNH?
• Quantos primos você tem?
• Você tem irmãos?
• O período em que você
está matriculado
• O nome do seu curso
• Seu ano de nascimento
35. Identificadores
• Um identificador diferencia uma variável das outras
• Deve ser único
• A criação de variáveis em um programa se dá através da declaração de
variáveis
• Todas as variáveis ou constantes são identificadas por um nome que
chamamos de IDENTIFICADOR
• Exemplos:
• Salario
• Idade
• J
• Xpto
• NomeDaVariavel
36. Identificadores
• Regras para formação de identificadores
• Identificadores em C# podem conter LETRAS, DÍGITOS, UNDERSCORE
(_) e caracteres UNICODE
• Devem começar OBRIGATORIAMENTE com uma LETRA ou
UNDERSCORE (_)
• Não podem conter ESPAÇOS ou caracteres especiais (?, !, -)
• Não podem estar na lista de palavras-chave do C# (consulte aqui essa
lista)
• C# faz diferenciação entre letras MAIÚSCULAS e minúsculas (idade é
diferente de IDADE)
• Nomes válidos: i, j, FRUTA, salario, a12,
i23ER21, nomealuno
• Nomes inválidos: 1, 25, nome-fruta, 5JOSE,
A$1, nome aluno
37. Identificadores
• O identificador deve ser significativo e passar ao programador
(ou quem está lendo o programa/algoritmo) que informação a
variável ou constante vai armazenar:
• Nomes inapropriados: i, j, a12, i23ER21, xyz,
kkk, Rodrigo
• Nomes apropriados: idade, salario,
nomefruta, contador, datadenascimento
38. Identificadores
• Para que um nome de variável seja significativo, não é
necessário usar nomes muito extensos:
datadenascimento
dtnasc
39. Identificadores
• Boas práticas
• Embora o C# permita utilização de caracteres acentuados e
caracteres UNICODE, programadores de todo o mundo
evitam a utilização desses caracteres. Essa é
reconhecidamente uma boa prática de programação
• Utilizar a convenção camelCase para identificadores que
possuem 2 ou mais palavras:
• nomeAluno
• dtNasc
• salarioFuncionario
40. Algoritmo Exemplo
(identificadores apropriados e inapropriados)
static void Main(string[] args)
{
int a, b, c;
a = int.Parse(Console.ReadLine());
b = 1;
for (c = 2; c <= a; c++)
b = b * c;
Console.Write(b);
Console.ReadKey();
}
41. Algoritmo Exemplo
(identificadores apropriados e inapropriados)
static void Main(string[] args)
{
// Programa para calcular o fatorial de um número
int Numero, Fatorial, Contador;
Console.Write("Informe um número: ");
Numero = int.Parse(Console.ReadLine());
Fatorial = 1;
for (Contador = 2; Contador <= Numero; Contador++)
Fatorial = Fatorial * Contador;
Console.Write("Fatorial de "+Numero+" = "+ Fatorial);
Console.ReadKey();
}
42.
43. Declaração de variáveis
• Declaração de variáveis em C#
• As variáveis podem ser de vários tipos:
• int: define variáveis numéricas do tipo inteiro, ou seja, sem casas
decimais. (Ex: 12, 1000, 5, 345)
• double ou float: define variáveis numéricas do tipo real, ou seja, com
casas decimais. (Ex: 1.45, 0.05, 500.4, 3.4)
• string: define variáveis do tipo caractere, ou seja, cadeia de caracteres.
(Ex: "João da Silva", "Av. Afonso Pena", "PUC Minas").
• bool: define variáveis do tipo booleano, ou seja, com valor true ou false.
44. Declaração de variáveis
static void Main(string[] args)
{
int idade;
int numero;
double altura;
double peso;
double salario;
string nomePai;
string rua;
string bairro;
string dtNasc;
bool temCasa;
}
46. Etapas de um algoritmo
• 1ª etapa : entrada de dados (informados pelo usuário)
• 2ª etapa : processamento (cálculos)
• 3ª etapa : saída de dados (exibição dos resultados)
Processamento
(cálculos)
Entrada
de dados
Saída
de dados
47. Etapas de um algoritmo
Entrada de dados
Saída de dados
Processamento (cálculo)
52. Comando de atribuição
• O comando de atribuição é utilizado para se atribuir valores ou
resultado de operações (expressões aritméticas, etc.) a variáveis
• No C# é representado pelo sinal de igualdade =
• Sintaxe
variavel = expressão;
53. Comando de atribuição
• ATENÇÃO: quando um valor é atribuído a uma variável, o valor
anterior armazenado na mesma é perdido.
• Podemos atribuir um valor fixo (1), o conteúdo de uma outra variável
(2) ou o resultado de uma expressão aritmética ou booleana (3).
54. Comando de atribuição
using System;
class MainClass {
public static void Main (string[] args) {
int idade;
double altura, peso, copiaPeso, IMC;
string nome;
bool temCNH;
idade = 23;
altura = 1.76;
peso = 78.9;
nome = "João da Silva";
temCNH = true;
copiaPeso = peso;
IMC = peso / (altura * altura);
}
}
55. Comando de atribuição
using System;
class MainClass {
public static void Main (string[] args) {
int idade = 23;
double altura = 1.76, peso = 78.9;
string nome = "João da Silva";
bool temCNH = true;
copiaPeso = peso;
IMC = peso / (altura * altura);
}
}
56. Etapas de um algoritmo
• 1ª etapa : entrada de dados (informados pelo usuário)
• 2ª etapa : processamento (cálculos)
• 3ª etapa : saída de dados (exibição dos resultados)
Processamento
(cálculos)
Entrada
de dados
Saída
de dados
58. Comandos de saída de dados
• O C# fornece dois comandos para se escrever (imprimir)
informações na tela
• Console.Write(...);
• A informação entre parênteses é impressa e o cursor
permanece na mesma linha.
• Console.WriteLine(...);
• Idem, porém o cursor pula para a primeira coluna da
próxima linha.
59. Comandos de saída de dados
• Temos as seguintes variações para o comando:
• Console.Write("Mensagem a ser impressa");
• O texto entre aspas é impresso.
• Console.Write(var);
• O conteúdo da variável var é impresso.
• Console.Write("Mensagem 1 "+var1+" Mensagem 2 "+var2);
• Os textos são impressos junto com os conteúdos das variáveis var1 e var2.
• ATENÇÃO: É importante o uso de espaços dentro das
aspas a fim de que os dados (textos e conteúdos de
variáveis) sejam impressos separados uns dos outros
60. Comandos de saída de dados
• Exemplos de uso dos comandos Console.Write / Console.WriteLine
string nome;
int idade;
double salario, inss;
Console.Write("Nome: "+nome);
→ impressão: Nome: José da Silva
Console.WriteLine("Sua idade é de "+idade+" anos.");
→ impressão: Sua idade é de 39 anos.
Console.WriteLine("Salário de R$ "+salario+" e INSS de R$ "+inss);
→ impressão: Salário de R$ 850.65 e INSS de R$ 87.40
Console.WriteLine(); → salto de uma linha em branco
61. Placeholders, concatenação e interpolação
using System;
class MainClass {
public static void Main (string[] args) {
int idade = 27;
string nome = "João da Silva";
// Concatenação
Console.WriteLine("Meu nome é "+nome+" e tenho "+idade+" anos de idade.");
// Placeholder
Console.WriteLine("Meu nome é {0} e tenho {1} anos de idade.", nome, idade);
// Interpolação
Console.WriteLine($"Meu nome é {nome} e tenho {idade} anos de idade.");
Console.ReadKey();
}
}
63. Etapas de um algoritmo
• 1ª etapa : entrada de dados (informados pelo usuário)
• 2ª etapa : processamento (cálculos)
• 3ª etapa : saída de dados (exibição dos resultados)
Processamento
(cálculos)
Entrada
de dados
Saída
de dados
65. Comando de entrada de dados
• Comando utilizado para receber os valores digitados pelos usuário.
• O tipo de dado a ser digitado pelo usuário depende do tipo da variável
utilizada no comando, se a variável for do tipo int não podemos, por
exemplo, digitar um texto, pois essa entrada provocará um erro na
execução do programa.
• O usuário digita o dado via teclado e aperta ENTER. O dado é então
armazenado/atribuído à variável e o cursor da tela pula para a primeira
coluna da próxima linha.
variavel = Console.ReadLine();
66. Comando de entrada de dados
• Lendo valores inteiros
• Lendo valores reais
variavel = int.Parse(Console.ReadLine());
variavel = Convert.ToInt32(Console.ReadLine());
variavel = Double.Parse(Console.ReadLine());
variavel = float.Parse(Console.ReadLine());
variavel = Convert.ToDouble(Console.ReadLine());
67. Comando de entrada de dados
• Lendo texto
• Lendo valores booleanos
variavel = Console.ReadLine();
variavel = bool.Parse(Console.ReadLine());
68. Comando de entrada de dados
using System;
class MainClass {
public static void Main (string[] args) {
int n1, n2;
double n3, n4;
float n5;
string s;
bool b1, b2;
// Leitura de Inteiros
Console.Write("Digite um número inteiro: ");
n1 = int.Parse(Console.ReadLine());
Console.Write("Digite outro número inteiro: ");
n2 = Convert.ToInt32(Console.ReadLine());
// Leitura de valores ponto-flutuante
Console.Write("Digite um número real: ");
n3 = double.Parse(Console.ReadLine());
Console.Write("Digite outro número real: ");
n4 = Convert.ToDouble(Console.ReadLine());
Console.Write("Digite mais um número real: ");
n5 = float.Parse(Console.ReadLine());
Console.Write("Digite um booleano (digite true ou false): ");
b1 = bool.Parse(Console.ReadLine());
Console.ReadKey();
}
}
72. Etapas de um algoritmo
• 1ª etapa : entrada de dados (informados pelo usuário)
• 2ª etapa : processamento (cálculos)
• 3ª etapa : saída de dados (exibição dos resultados)
Processamento
(cálculos)
Entrada
de dados
Saída
de dados
74. Operações aritméticas
• Uma expressão aritmética, é a tradução de uma equação matemática
em uma linguagem de programação
• Em C# utilizamos os seguintes operadores
Operador Operação Exemplo
+ Soma soma = numero + 100;
- Subtração result = 100 – soma;
* Multiplicação INSS = salario * 0.11;
/ Divisão media = soma / qtde;
% Resto de uma divisão inteira resto = numero % 2;
75. Operações aritméticas
• Operadores de atribuição combinados
Operador Operação Exemplo Significado
+= Soma soma += 100; soma = soma + 100;
-= Subtração result -= 20; result = result – 20;
*= Multiplicação dobro *= 2; dobro = dobro * 2;
/= Divisão metade /= 2; metade = metade / 2;
%= Resto de uma divisão inteira resto %= 7; resto = resto / 7;
76. Operações aritméticas
• Operadores de incremento e decremento
Operador Operação Exemplo Significado
++ Pré-incremento ++x; x = x + 1;
Pós-incremento x++; x = x + 1;
-- Pré-decremento --x; x = x – 1;
Pós-decremento x--; x = x – 1;
77. Operações aritméticas
• Operadores de incremento
using System;
class MainClass {
public static void Main (string[] args) {
int preinc = 7, posinc = 7, predec = 7, posdec = 7;
Console.WriteLine($"preinc = {++preinc}");
Console.WriteLine($"posinc = {posinc++}");
Console.WriteLine($"predec = {--predec}");
Console.WriteLine($"posdec = {posdec--}");
Console.WriteLine("nREIMPRIMINDO");
Console.WriteLine($"preinc = {preinc}");
Console.WriteLine($"posinc = {posinc}");
Console.WriteLine($"predec = {predec}");
Console.WriteLine($"posdec = {posdec}");
}
}
78. Operações aritméticas
• Operadores / e %
• O resultado da divisão depende dos operandos
• 9/2 é diferente de 9.0/2 ou 9/2.0
• Se os dois operandos são inteiros, o operador / calcula o quociente
• Se um dos operandos é real, o operador / calcula a divisão exata
• O operador % calcular o resto de uma divisão inteira
79. Operações aritméticas
• Para calcular potenciação e radiciação, utilizamos as funções
Math.Pow() e Math.Sqrt()
Função Operação Exemplo
Math.Sqrt() Radiciação Raiz = Math.Sqrt(9);
Math.Pow() Potenciação e
Radiciação
Quadrado = Math.Pow(9, 2);
RaizCubica = Math.Pow(81, (1/3));
80. Operações aritméticas
• Quais os resultados das expressões abaixo?
Operação Resultado
A = 9 + 4;
B = 9 – 4;
C = 9 * 4;
D = 9 / 4;
E = 9 % 4;
F = Math.Pow(3, 4);
G = Math.Sqrt(9);
H = Math.Pow(27, (1/3.0));
81. Operações aritméticas
• Quais os resultados das expressões abaixo?
Operação Resultado
A = 9 + 4; 13
B = 9 – 4; 5
C = 9 * 4; 36
D = 9 / 4; 2
E = 9 % 4; 1
F = Math.Pow(3, 4); 81
G = Math.Sqrt(9); 3
H = Math.Pow(27, (1/3.0)); 3
82. Operações aritméticas
• Quais os resultados das expressões abaixo?
Operação Resultado
A = 9 + 4; 13
B = 9 – 4; 5
C = 9 * 4; 36
D = 9 / 4; 2
E = 9 % 4; 1
F = Math.Pow(3, 4); 81
G = Math.Sqrt(9); 3
H = Math.Pow(27, (1/3.0)); 3
Variáveis que recebem o
resultado das funções
Math.Pow() e Math.Sqrt()
devem ser do tipo Double.
83. Operações aritméticas
• Se o operador % é utilizado para calcular o resto de uma divisão
inteira, como calculamos percentuais?
• Representando a taxa percentual em sua forma decimal
12 % valor
0.12 * valor
ou
(12/100) * valor
12 % de valor
84. Operações aritméticas
using System;
class MainClass {
public static void Main (string[] args) {
int a = 5, b = 2, c;
int Soma, Subt, Mult, Quociente, Resto;
Double DivExata, RaizQuadrada, Quadrado, Cubo, RaizCubica;
// Cálculos
Soma = a + b;
Subt = a - b;
Mult = a * b;
Quociente = a / b;
Resto = a % b;
DivExata = 9 / 2.0;
RaizQuadrada = Math.Sqrt(36);
Quadrado = Math.Pow(a, b);
c = b + 1;
Cubo = Math.Pow(c, c);
RaizCubica = Math.Pow(125, 1/3.0);
// Impressão dos resultados
Console.WriteLine($"{a} + {b} = {Soma}");
Console.WriteLine($"{a} - {b} = {Subt}");
Console.WriteLine($"{a} * {b} = {Mult}");
Console.WriteLine($"{a} / {b} = {Quociente}");
Console.WriteLine($"{a} % {b} = {Resto}");
Console.WriteLine($"9 / 2.0 = {DivExata}");
Console.WriteLine($"A raiz quadrada de 36 = {RaizQuadrada}");
Console.WriteLine($"{a} elevado a {b} = {Quadrado}");
Console.WriteLine($"{c} elevado a {c} = {Cubo}");
Console.WriteLine($"A raiz cubica de 125 = {RaizCubica}");
}
}
85. Operações aritméticas
• Ordem de execução dos operadores aritméticos:
1. Parênteses
2. Operadores * (multiplicação), / (divisão) e % (resto de uma divisão inteira)
3. Operadores + (adição) e – (subtração)
• ATENÇÃO: Para mudarmos a ordem de execução dos operadores utilizamos os parênteses, em
quantos níveis precisarmos.
• Exemplos:
valor = 3 + 4 * 5 / 6 * 7 – 8; = 16
valor = (3 + 4) * 5 / 6 * ( 7 - 8 ); = - 5
86. Operações aritméticas
• Exemplos
2
R
A π
=
2
7
4
)
( 2
−
+
= x
x
x
f
5
3
3
2
1
−
+
+
=
N
N
N
VALOR
valor = n1+n2+n3 / 3 – 5;
fx = 4 * Math.Pow(x, 2) + 7*x – 2;
area = Math.PI * Math.Pow(raio, 2);
valor = (n1+n2+n3) / 3 – 5;
87. Conversão de tipos
• Conversão implícita
• Type casting (conversão explítica)
int x = 5;
Double y = x;
int x = 5, y = 2;
float f = (float)x/y;
Double d = x/(Double)y;
88. Exemplo 1
Faça um programa que leia 5 números inteiros diferentes
informados pelo usuário e calcule e imprima a soma e a
média aritmética destes números.
Fórmulas:
SOMA = N1 + N2 + N3 + N4 + N5
MEDIA = SOMA / 5
90. Exemplo 1
using System;
class MainClass {
public static void Main (string[] args) {
// Declaração de variáveis
int n1, n2, n3, n4, n5, Soma;
Double Media;
// Entrada de dados
Console.Write("Digite o primeiro número: ");
n1 = int.Parse(Console.ReadLine());
Console.Write("Digite o segundo numero: ");
n2 = int.Parse(Console.ReadLine());
Console.Write("Digite o terceiro numero: ");
n3 = int.Parse(Console.ReadLine());
Console.Write("Digite o quarto numero: ");
n4 = int.Parse(Console.ReadLine());
Console.Write("Digite o quinto numero: ");
n5 = int.Parse(Console.ReadLine());
// Cálculo / processamento
Soma = n1 + n2 + n3 + n4 + n5;
Media = Soma / 5.0;
// Saída de dados
Console.WriteLine($"Soma = {Soma}");
Console.WriteLine($"Media = {Media}");
}
}
91. Exemplo 1
using System;
class MainClass {
public static void Main (string[] args) {
// Declaração de variáveis
int n1, n2, n3, n4, n5, Soma;
Double Media;
// Entrada de dados
Console.Write("Digite o primeiro número: ");
n1 = int.Parse(Console.ReadLine());
Console.Write("Digite o segundo numero: ");
n2 = int.Parse(Console.ReadLine());
Console.Write("Digite o terceiro numero: ");
n3 = int.Parse(Console.ReadLine());
Console.Write("Digite o quarto numero: ");
n4 = int.Parse(Console.ReadLine());
Console.Write("Digite o quinto numero: ");
n5 = int.Parse(Console.ReadLine());
// Cálculo / processamento
Soma = n1 + n2 + n3 + n4 + n5;
Media = Soma / 5.0;
// Saída de dados
Console.WriteLine($"Soma = {Soma}");
Console.WriteLine($"Media = {Media}");
}
}
Entrada
de Dados
Cálculos
Saída de
Dados
92. Exemplo 2
Faça um algoritmo que calcule e imprima o valor da
hipotenusa de um triângulo retângulo. Os valores dos
catetos serão informados pelo usuário.
Fórmula:
2
2
2
1 Cateto
Cateto
Hipotenusa +
=
94. Exemplo 2
using System;
class MainClass {
public static void Main (string[] args) {
// Declaração de variáveis
Double Hipotenusa, Cateto1, Cateto2;
// Entrada de dados
Console.Write("Informe o valor do cateto 1: ");
Cateto1 = Double.Parse(Console.ReadLine());
Console.Write("Informe o valor do cateto 2: ");
Cateto2 = Double.Parse(Console.ReadLine());
// Cálculo da Hipotenusa
Hipotenusa = Math.Sqrt(Math.Pow(Cateto1,2) + Math.Pow(Cateto2,2));
// Saída / impressão do resultado
Console.Write($"Hipotenusa = {Hipotenusa}");
}
}
95. Exemplo 3
Faça um algoritmo que solicite ao usuário o valor do seu
salário bruto e calcule e imprima quanto ele irá pagar de
INSS.
Fórmula:
INSS = 11% do salário
97. Exemplo 3
using System;
class MainClass {
public static void Main (string[] args) {
// Declaração de variáveis
Double Salario, Inss;
// Entrada de dados
Console.Write("Informe o valor do seu salário: ");
Salario = Double.Parse(Console.ReadLine());
// Cálculo
Inss = Salario * 0.11;
// Saída de dados
Console.WriteLine($"O valor do INSS = R$ {Inss:0.00}");
}
}
100. Estrutura condicional
• Programas simples normalmente consistem de uma lista de
comandos executados de forma sequencial
• Mas a habilidade de testar condições e executar diferentes comandos
com base nos resultados desses testes é uma ferramenta valiosa
using System;
class MainClass {
public static void Main (string[] args) {
// Declaração de variáveis
Double Hipotenusa, Cateto1, Cateto2;
// Entrada de dados
Console.Write("Informe o valor do cateto 1: ");
Cateto1 = Double.Parse(Console.ReadLine());
Console.Write("Informe o valor do cateto 2: ");
Cateto2 = Double.Parse(Console.ReadLine());
// Cálculo da Hipotenusa
Hipotenusa = Math.Sqrt(Math.Pow(Cateto1,2) + Math.Pow(Cateto2,2));
// Saída / impressão do resultado
Console.Write($"Hipotenusa = {Hipotenusa}");
}
}
101. Estrutura condicional/seleção
• O comando if permite determinar se um comando (ou bloco de
comandos) será executado ou não, dependendo se a condição é
VERDADEIRA ou FALSA
• Já o comando if-else determina qual comando (ou bloco de
comandos) será executado, se o comando seguinte ao if ou o
seguinte ao else
• Exemplos
Comando condicional simples
se estiver chovendo
vou levar meu guarda-chuva
Comando condicional composto
se estiver chovendo
vou de carro
senão
vou de moto
103. Estrutura condicional simples
if (condição)
comando;
comando;
comando;
Condição VERDADEIRA: o
comando depois do if SERÁ
executado
comando;
comando;
comando;
comando;
104. Estrutura condicional simples
if (condição)
comando;
comando;
comando;
Condição FALSA: o comando
depois do if NÃO SERÁ
executado
comando;
comando;
comando;
comando;
105. Estrutura condicional simples
using System;
class MainClass {
public static void Main (string[] args) {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
Console.WriteLine("O aluno foi aprovado.");
}
}
107. Estrutura condicional composta
if (condição)
comando1;
else
comando2;
comando;
comando;
Condição VERDADEIRA: o
comando depois do if SERÁ
executado
comando;
comando;
comando;
comando;
108. Estrutura condicional composta
if (condição)
comando1;
else
comando2;
comando;
comando;
Condição FALSA: o comando
depois do else SERÁ executado
comando;
comando;
comando;
comando;
109. Estrutura condicional composta
using System;
class MainClass {
public static void Main (string[] args) {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
Console.WriteLine("O aluno foi aprovado.");
else
Console.WriteLine("O aluno foi reprovado.");
}
}
110. Blocos de comandos
• Frequentemente o corpo do comando if ou da cláusula else consistem em
múltiplos comandos, ao invés de um comando único. Esses comandos
devem estar agrupados por chaves { } formando um bloco de instruções.
{
comando1;
comando2;
...
comandon;
}
111. Blocos de comandos
using System;
class MainClass {
public static void Main (string[] args) {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
{
Console.WriteLine("O aluno foi aprovado.");
Console.WriteLine("PARABENS!!!");
}
else
Console.WriteLine("O aluno foi reprovado.");
}
}
112. Blocos de comandos
using System;
class MainClass {
public static void Main (string[] args) {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
Console.WriteLine("O aluno foi aprovado.");
else
{
Console.WriteLine("O aluno foi reprovado.");
Console.WriteLine("Ele devera fazer a reavaliação!!!");
}
}
}
113. Blocos de comandos
using System;
class MainClass {
public static void Main (string[] args) {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
{
Console.WriteLine("O aluno foi aprovado.");
Console.WriteLine("PARABENS!!!");
}
else
{
Console.WriteLine("O aluno foi reprovado.");
Console.WriteLine("Ele devera fazer a reavaliação!!!");
}
}
}
114. Layout das chaves { }
• O posicionamento das chaves não é importante para o compilador,
mas é importante para a legibilidade do seu código
• Há 2 formas utilizadas por programadores
• Alinhamento das chaves
if (nota < 60)
{
double notaMinReaval = 120 – nota;
Console.WriteLine("Você precisa de "+notaMinReaval+"na reavaliação para ser aprovado");
}
• Chave de abertura na mesma linha do comando
if (nota < 60) {
double notaMinReaval = 120 – nota;
Console.WriteLine("Você precisa de "+notaMinReaval+"na reavaliação para ser aprovado");
}
115. Operadores relacionais
• A condição utilizada em um comando if normalmente é composta por
expressões booleanas expressas por comparações de valores através
de operadores relacionais
x != y
Desigualdade
!=
idade >= maiorIdade
Maior ou igual
>=
soma <= 0
Menor ou igual
<=
numero1 > numero2
Maior
>
valor < 100
Menor
<
n1 == n2
Igualdade
==
Exemplo
Operação
Operador
117. Operadores booleanos
• A condição em um comando if pode ser composta por diversas
expressões booleanas combinadas através dos operadores booleanos
&& (e), || (ou) e ! (não/negação)
if (! (x==y && a >= b) )
Nega a condição
! (NOT)
if (idade >= 65 || salario < 937)
Um V = V
|| (OR)
if (nota >= 60 && faltas <= 17)
Todos V = V
&& (AND)
Exemplo
Operação
Operador
118. Operadores booleanos
Operador && (AND)
Todas as condições devem ser
true para que a resposta seja true
Operador || (OR)
Basta que 1 condição seja true
para que a resposta seja true
Operador ! (NOT)
O operador ! inverte o valor da
condição
A B A && B
true true true
true false false
false true false
false false false
A B A || B
true true true
true false true
false true true
false false false
A !A
true false
false true
119. Exemplo
Faixa Salarial Alíquota
Até R$1000,00 8%
Acima de R$1000,00 10%
Faça um programa em C# para calcular e imprimir o valor a ser
descontado de INSS no salário de um empregado utilizando a
tabela abaixo. O usuário fornecerá o salário.
120. Solução
using System;
class MainClass {
public static void Main (string[] args) {
double Salario, INSS;
Console.Write("Digite o salario do funcionario : R$ ");
Salario = Double.Parse(Console.ReadLine());
if (Salario <= 1000)
INSS = Salario * 0.08;
else
INSS = Salario * 0.10;
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}
121. Solução (EVITE – if´s independentes)
using System;
class MainClass {
public static void Main (string[] args) {
double Salario, INSS = 0;
Console.Write("Digite o salario do funcionario : R$ ");
Salario = Double.Parse(Console.ReadLine());
if (Salario <= 1000)
INSS = Salario * 0.08;
if (Salario > 1000)
INSS = Salario * 0.10;
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}
122. Exemplo 2
Faixa Salarial Alíquota
Até R$ 1000,00 8%
Entre R$ 1000,00 10%
e R$ 1800,00
Acima de R$ 1800,00 12%
Faça um programa em C# para calcular e imprimir o valor a ser
descontado de INSS no salário de um empregado utilizando a
tabela abaixo. O usuário fornecerá o salário.
123. Solução
using System;
class MainClass {
public static void Main (string[] args) {
Double Salario, INSS;
Console.Write("Digite o salario do funcionario : ");
Salario = Double.Parse(Console.ReadLine());
if (Salario <= 1000)
INSS = Salario * 0.08;
else
if (Salario <= 1800)
INSS = Salario * 0.10;
else
INSS = Salario * 0.12;
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}
124. Solução
using System;
class MainClass {
public static void Main (string[] args) {
Double Salario, INSS;
Console.Write("Digite o salario do funcionario : ");
Salario = Double.Parse(Console.ReadLine());
if (Salario <= 1000)
INSS = Salario * 0.08;
else
if (Salario <= 1800)
INSS = Salario * 0.10;
else
INSS = Salario * 0.12;
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}
125. Solução (EVITE – usando if´s independentes)
using System;
class MainClass {
public static void Main (string[] args) {
Double Salario, INSS;
Console.Write("Digite o salario do funcionario : ");
Salario = Double.Parse(Console.ReadLine());
if (Salario <= 1000)
INSS = Salario * 0.08;
if (Salario > 1000 && Salario <= 1800)
INSS = Salario * 0.10;
if (Salario > 1800)
INSS = Salario * 0.12;
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}
126. Ladder if x nested if (if aninhado)
Ladder if
if (condição1)
comando1;
else if (condição2)
comando2;
else if (condição3)
comando3;
...
else if (condiçãon)
comandon;
else
comandon+1;
Nested if
if (condição1)
comando1;
else
if (condição2)
comando2;
else
if (condição3)
comando3;
...
else
if (condiçãon)
comandon;
else
comandon+1;
127. Else oscilante
O que foi escrito
if (Richter >= 0)
if (Richter <= 4)
Console.WriteLine("Terremoto inofensivo!");
else
Console.WriteLine("Escala Richter não permite valores negativos");
O nível de recuo sugere que o else se refere ao teste (Richter >= 0), o que é incorreto. O compilador ignora
espaços e tabulações e seguirá a regra em que um else pertence ao if mais próximo.
O que o C# interpretou
if (Richter >= 0)
if (Richter <= 4)
Console.WriteLine("Terremoto inofensivo!");
else
Console.WriteLine("Escala Richter não permite valores negativos");
128. Else oscilante
O que foi deveria ter sido escrito
if (Richter >= 0)
{
if (Richter <= 4)
Console.WriteLine("Terremoto inofensivo!");
}
else
Console.WriteLine("Escala Richter não permite valores negativos");
Agora o else se refere ao primeiro if.
129. Comando switch
• Switch/case é uma estrutura condicional que define o código a ser
executado baseando-se em uma comparação de valores/alternativas
switch(opcao)
{
case op1:
comandos caso a opção 1 tenha sido escolhida
break;
case op2:
comandos caso a opção 2 tenha sido escolhida
break;
...
case opn:
comandos caso a opção n tenha sido escolhida
break;
default:
comandos caso nenhuma das opções anteriores tenha sido escolhida
}
130. Comando switch
using System;
class MainClass {
public static void Main (string[] args) {
int mes;
Console.Write("Digite o numero do mes: ");
mes = int.Parse(Console.ReadLine());
String mesStr;
switch (mes)
{
case 1: mesStr = "Janeiro";
break;
case 2: mesStr = "Fevereiro";
break;
case 3: mesStr = "Marco";
break;
case 4: mesStr = "Abril";
break;
case 5: mesStr = "Maio";
break;
case 6: mesStr = "Junho";
break;
case 7: mesStr = "Julho";
break;
case 8: mesStr = "Agosto";
break;
case 9: mesStr = "Setembro";
break;
case 10: mesStr = "Outubro";
break;
case 11: mesStr = "Novembro";
break;
case 12: mesStr = "Dezembro";
break;
default: mesStr = "Mes invalido";
break;
}
Console.WriteLine(mesStr);
}
}
131. Comando switch
switch (mesStr)
{
case "Janeiro":
case "Março":
case "Maio":
case "Julho":
case "Agosto":
case "Outubro":
case "Dezembro":
Console.WriteLine("Este mês tem 31 dias");
break;
case "Fevereiro":
Console.WriteLine("Este mês tem 28 ou 29 dias");
break;
default:
Console.WriteLine("Este mês tem 30 dias");
break;
}
132. Operador condicional/ternário ?:
• C# fornece um operador ternário (trabalha sobre 3 operandos) que
pode ser utilizado, em algumas situações, no lugar de um if-else
• Sintaxe:
• condição é qualquer expressão que retornar um valor booleano
• Se a condição é true, a expressão_true será avaliada e retornada
• Se a condição é falsa, a expressão_false será avaliada e retornada
condição ? expressão_true : expressão_false
133. Operador condicional/ternário ?:
• Exemplo 1
• Essa estrutura pode ser substituída pelo operador ternário
• Você pode usar parênteses para tornar a leitura mais legível
bool passou;
if(nota >= 60)
passou = true;
else
passou = false;
passou = nota >= 60 ? true : false;
passou = (nota >= 60 ? true : false);
passou = (nota >= 60) ? true : false;
134. Operador condicional/ternário ?:
• Exemplo 2
• Utilizando o operador ternário
Console.WriteLine("O aluno foi "+ (nota >= 60?"aprovado":"reprovado") );
string status;
if (nota >= 60)
status = "aprovado";
else
status = "reprovado";
Console.WriteLine("O aluno foi "+status);
138. Estrutura de repetição
• Em diversas situações se torna necessário repetir um ou mais
comandos um determinado número de vezes
• Uma instrução de repetição (loop ou laço) permite especificar que um
programa deve repetir uma ou mais instruções
• O C# possui 3 tipos de comandos de repetição
while (condição)
comando;
do
comando;
while (condição);
for (inicialização;condição;atualização)
comando;
152. Estruturas de repetição
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.Write($"A raiz quadrada de {numero} = {raiz}");
}
}
156. Estruturas de repetição – Comando while
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
while (numero > 0)
{
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
}
}
}
160. Estruturas de repetição – Comando do..while
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada enquanto
// o numero digitado for maior que 0 (zero)
do
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
} while (numero > 0);
}
}
162. Estruturas de repetição – Comando do..while
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada enquanto
// o numero digitado for maior que 0 (zero)
do
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
if (numero > 0)
{
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
} while (numero > 0);
}
}
166. Estruturas de repetição – Comando for
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
int cont = 1;
// Calcula a raiz quadrada de 10 numeros
while (cont <= 10)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
cont = cont + 1; // ou cont++ ou cont += 1
}
}
}
167. Estruturas de repetição – Comando for
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
int cont;
// Calcula a raiz quadrada de 10 numeros
for(cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
168. Estruturas de repetição – Comando for
using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada de 10 numeros
for(int cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
169. using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada de 10 numeros
for(int cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
Estruturas de repetição – Comando for
1. inicialização
170. using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada de 10 numeros
for(int cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
Estruturas de repetição – Comando for
2. condição
171. using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada de 10 numeros
for(int cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
Estruturas de repetição – Comando for
3. Bloco de
comandos
172. using System;
class MainClass {
public static void Main (string[] args) {
Double numero, raiz;
// Calcula a raiz quadrada de 10 numeros
for(int cont = 1; cont <= 10; cont++)
{
Console.Write("Digite um numero: ");
numero = Double.Parse(Console.ReadLine());
raiz = Math.Sqrt(numero);
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}
Estruturas de repetição – Comando for
4. atualização
179. Contador
• Um contador é uma variável do tipo INTEIRO criada com o objetivo de contar a
ocorrência de alguma situação de interesse durante um laço de repetição
• Incrementada por um valor constante (geralmente 1)
• Para incrementar o valor de uma variável utiliza-se o seguinte comando:
• contador = contador + 1;
• Exemplos:
• qtde = qtde + 1;
• aprovados = aprovados + 1;
• numPar = numPar + 1;
181. Contador – Exemplo 1
using System;
class MainClass {
public static void Main (string[] args) {
int positivos = 0; // Contador de números positivos
int num;
Console.Write("Digite um numero entre -100 e 100: ");
num = int.Parse(Console.ReadLine());
while (num >= -100 && num <= 100)
{
if(num > 0)
positivos = positivos + 1;
Console.Write("Digite um numero entre -100 e 100: ");
num = int.Parse(Console.ReadLine());
}
Console.Write($"Foram digitados {positivos} numeros positivos.");
}
}
182. Contador – Exemplo 2
using System;
class MainClass {
public static void Main (string[] args) {
int pares = 0; // Contador de números pares
int num;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
}
Console.Write($"Foram digitados {pares} numeros pares.");
}
}
183. Contador – Exemplo 3a
using System;
class MainClass {
public static void Main (string[] args) {
// Contador de números pares e ímpares
int pares = 0, impares;
int num;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
else
impares = impares + 1;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
}
Console.Write($"Foram digitados {pares} numeros pares e {impares} impares.");
}
}
184.
185.
186. Contador – Exemplo 3b
using System;
class MainClass {
public static void Main (string[] args) {
// Contador de números pares e ímpares
int pares = 0, impares = 0;
int num;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
else
impares = impares + 1;
Console.Write("Digite um numero positivo: ");
num = int.Parse(Console.ReadLine());
}
Console.Write($"Foram digitados {pares} numeros pares e {impares} impares.");
}
}
187. Contador
• A forma clássica de incremento de um contador é:
• contador = contador + 1;
• As linguagens C-Like (C, C++, Java e C#) fornecem outras maneiras de
incrementar um contador
• Através do operador de incremento (++)
• qtde++;
• aprovados++;
• numPar++;
• Através do operador de atribuição composto (+=)
• qtde += 1;
• aprovados += 1;
• numPar += 1;
188. Contador – Exemplo 4 (erro)
using System;
class MainClass {
public static void Main (string[] args) {
string nome;
int nota = 0;
int aprov = 0, reprov = 0;
for(int i = 1; i <= 5; i++) {
Console.Write("Digite o nome do aluno: ");
nome = Console.ReadLine();
Console.Write("Digite a nota: ");
nota = int.Parse(Console.ReadLine());
}
if(nota >= 60)
aprov++;
else
reprov++;
Console.Write($"{aprov} alunos foram aprovados e {reprov} foram reprovados.");
}
}
189.
190.
191. using System;
class MainClass {
public static void Main (string[] args) {
string nome;
int nota = 0;
int aprov = 0, reprov = 0;
for(int i = 1; i <= 5; i++) {
Console.Write("Digite o nome do aluno: ");
nome = Console.ReadLine();
Console.Write("Digite a nota: ");
nota = int.Parse(Console.ReadLine());
}
if(nota >= 60)
aprov++;
else
reprov++;
Console.Write($"{aprov} alunos foram aprovados e {reprov} foram reprovados.");
}
}
Contador – Exemplo 4 (erro)
192. using System;
class MainClass {
public static void Main (string[] args) {
string nome;
int nota = 0;
int aprov = 0, reprov = 0;
for(int i = 1; i <= 5; i++) {
Console.Write("Digite o nome do aluno: ");
nome = Console.ReadLine();
Console.Write("Digite a nota: ");
nota = int.Parse(Console.ReadLine());
}
if(nota >= 60)
aprov++;
else
reprov++;
Console.Write($"{aprov} alunos foram aprovados e {reprov} foram reprovados.");
}
}
Contador – Exemplo 4 (erro)
193. using System;
class MainClass {
public static void Main (string[] args) {
string nome;
int nota = 0;
int aprov = 0, reprov = 0;
for(int i = 1; i <= 5; i++) {
Console.Write("Digite o nome do aluno: ");
nome = Console.ReadLine();
Console.Write("Digite a nota: ");
nota = int.Parse(Console.ReadLine());
if(nota >= 60)
aprov++;
else
reprov++;
}
Console.Write($"{aprov} alunos foram aprovados e {reprov} foram reprovados.");
}
}
Contador – Exemplo 4
195. Acumulador (somatórios)
• Um acumulador é uma variável (inteira ou real) criada com o objetivo de calcular
o somatório de algum valor
• Incrementada por um valor variável
• Geralmente é utilizada uma variável lida (ou gerada) dentro do processo de repetição (looping);
• Para fazer o somatório do valor de uma variável utiliza-se o seguinte comando:
• acumulador = acumulador + variável de que deseja somar;
• Exemplos:
• somaNotas = somaNotas + nota;
• total = total + custoProduto;
• somaIdadeMulheres = somaIdadeMulheres + idade;
• somaIdadeHomens = somaIdadeHomens + idade;
197. Acumulador – Exemplo 1
using System;
class MainClass {
public static void Main (string[] args) {
int num;
int soma = 0; // Acumulador
Console.Write("Digite um numero maior que zero: ");
num = int.Parse(Console.ReadLine());
while (num > 0)
{
soma = soma + num;
Console.Write("Digite um numero maior que zero: ");
num = int.Parse(Console.ReadLine());
}
Console.Write($"A soma dos numeros digitados = {soma}.");
}
}
198. Acumulador – Exemplo 1a (problema)
using System;
class MainClass {
public static void Main (string[] args) {
Double num;
int soma = 0; // Acumulador
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
while (num > 0)
{
soma = soma + num;
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
}
Console.Write($"A soma dos numeros digitados = {soma}.");
}
}
199.
200. Acumulador – Exemplo 1a (problema)
using System;
class MainClass {
public static void Main (string[] args) {
Double num;
int soma = 0; // Acumulador
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
while (num > 0)
{
soma = soma + num;
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
}
Console.Write($"A soma dos numeros digitados = {soma}.");
}
}
201. Acumulador – Exemplo 1b
using System;
class MainClass {
public static void Main (string[] args) {
Double num;
Double soma = 0; // Acumulador
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
while (num > 0)
{
soma = soma + num;
Console.Write("Digite um numero maior que zero: ");
num = Double.Parse(Console.ReadLine());
}
Console.Write($"A soma dos numeros digitados = {soma}.");
}
}
202. using System;
class MainClass {
public static void Main (string[] args) {
Double preco, totalCompra = 0; // Acumulador
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
while (preco > 0)
{
totalCompra = totalCompra + preco;
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
}
Console.Write($"nO valor total da compra = R$ {totalCompra:0.00}");
}
}
Acumulador – Exemplo 2
203. Acumulador – Exemplo 2a
using System;
class MainClass {
public static void Main (string[] args) {
Double preco, totalCompra = 0; // Acumulador
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
while (preco > 0)
{
totalCompra = totalCompra + preco;
Console.Write($"tSubtotal = R$ {totalCompra:0.00}.n");
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
}
Console.Write($"nO valor total da compra = R$ {totalCompra:0.00}");
}
}
204. Acumulador
• A forma clássica de atualizar um acumulador é:
• acumulador = acumulador + variável de que deseja somar;
• As linguagens C-Like (C, C++, Java e C#) fornecem outras maneiras de
atualizar o valor do acumulador
• Através do operador de atribuição composto
• somaNotas += nota;
• total += custoProduto;
• somaIdadeMulheres += idade;
• somaIdadeHomens += idade;
205. using System;
class MainClass {
public static void Main (string[] args) {
Double preco, totalCompra = 0; // Acumulador
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
while (preco > 0)
{
totalCompra += preco;
Console.Write($"tSubtotal = R$ {totalCompra:0.00}.n");
Console.Write("Digite o preco do produto: R$ ");
preco = Double.Parse(Console.ReadLine());
}
Console.Write($"nO valor total da compra = R$ {totalCompra:0.00}");
}
}
Acumulador – Exemplo 2b
207. Modularização
• A modularização é uma técnica utilizada para desenvolver algoritmos,
dividindo-se um problema em partes, denominados módulos, os
quais são menores e mais fáceis de ler, desenvolver e corrigir
• Nas diversas linguagens de programação, os módulos são conhecidos
como sub-rotinas (FORTRAN), funções (C e Pascal), procedimentos
(Pascal e Ada), métodos (linguagens orientadas a objetos)
• Nesse material, inicialmente, vamos tratar os módulos como
procedimentos e funções
208. Modularização
• Porque utilizar funções e procedimentos?
• Facilitar a legibilidade e manutenibilidade do programa
• Evitar que o programa fique muito extenso
• Permitir a reutilização de código
• Evitar que um trecho de código seja repetido várias vezes dentro de um
programa
209. Procedimentos
• Um procedimento é um conjunto de instruções que realiza uma
determinada tarefa
• Um procedimento é uma abstração de um comando
210. Funções
• Funções são criadas da mesma forma que procedimentos
• A diferença é que as funções podem ser utilizadas em expressões,
como se fossem variáveis
• Isso se deve ao fato de funções retornarem valores
• Assim, é necessário, ao declarar uma função, definir o tipo do dado
que será retornado
211. Modularização
• Em linguagens Orientadas a Objetos como é o caso de C# e Java, os
procedimentos e funções são chamados de métodos
• Procedimentos : métodos sem retorno de valor
• Funções: métodos com retorno de valor
212. Declaração
• Declarando um método com retorno de valor (função) em C#
tipo_retorno nome_método ( <lista de parâmetros> )
{
comando1;
comando2;
...
comandon;
return valor_retorno;
}
213. Declaração
• Declarando um método sem retorno de valor (procedimento) em C#
void nome_método ( <lista de parâmetros> )
{
comando1;
comando2;
...
comandon;
}
214. Declaração
• Declarando um método sem retorno de valor (procedimento) em C#
void nome_método ( <lista de parâmetros> )
{
comando1;
comando2;
...
comandon;
}
O tipo void indica que a
função não retorna um
valor
215. Escopo
• Parâmetros formais e variáveis declaradas dentro de um método
podem ser utilizados apenas dentro dele
• Resumindo, parâmetros formais e variáveis locais existem e podem
ser acessados apenas dentro do método onde foram declarados,
deixando de existir após a execução do método
216. Invocando (chamando) um método
• Método sem retorno (procedimento)
• A chamada a um procedimento é feita da mesma maneira que um comando
qualquer da linguagem
comando1;
comando2;
...
Procedimento(<parametros>);
...
comandon;
217. Invocação (ou chamada)
• Método com retorno (função)
• A chamada a uma função pode ser feita em qualquer parte do programa que
espera por um valor ou variável
• Assim, uma forma normalmente utilizada para invocar (chamar) uma função,
é atribuir seu valor de retorno a uma variável
variavel = Funcao(<parametros>);
218. Invocação (ou chamada)
• Método com retorno (função)
• Pode-se, portanto, invocar uma função em qualquer ponto do programa onde
um valor ou variável puder ser utilizado (obs: exceção à atribuição de valores
para variáveis)
variavel = Funcao(parametros);
Console.WriteLine(Funcao(parametros));
Resultado = expressão + Funcao(parametros);
Funcao(parametros) = variavel;
219. Exemplos
• Método sem retorno de valor (procedimento)
static void ImprimeCabecalho()
{
Console.WriteLine("*******************");
Console.WriteLine("* Algoritmos e *");
Console.WriteLine("* Lógica de *");
Console.WriteLine("* Programação *");
Console.WriteLine("*******************");
Console.WriteLine();
}
220. Exemplos
• Método com parâmetros e sem retorno de valor (procedimento)
static void ImprimeCabecalho(string nome)
{
Console.WriteLine("*******************");
Console.WriteLine("* Algoritmos e *");
Console.WriteLine("* Lógica de *");
Console.WriteLine("* Programação *");
Console.WriteLine("*******************");
Console.WriteLine($"Nome do aluno: {nome}");
Console.WriteLine();
}
221. Exemplos
• Método com parâmetros e sem retorno de valor (procedimento)
static void ImprimeCabecalho(string nome, char sexo)
{
Console.WriteLine("*******************");
Console.WriteLine("* Algoritmos e *");
Console.WriteLine("* Lógica de *");
Console.WriteLine("* Programação *");
Console.WriteLine("*******************");
if(sexo == 'F' || sexo == 'f’)
Console.WriteLine($"Nome da aluna: {nome}");
else
Console.WriteLine($"Nome do aluno: {nome}");
Console.WriteLine();
}
222. Exemplos
• Método com parâmetros e com retorno de valor (função)
static void procSoma(int a, int b) {
int S;
S = a + b;
Console.WriteLine($"A soma entre {a} e {b} = {S}.");
}
static int funcSoma(int a, int b) {
int S;
S = a + b;
return S;
}
public static void Main (string[] args) {
int v1 = 13, v2 = 38;
procSoma(v1, v2);
Console.WriteLine($"{v1} + {v2} = {funcSoma(v1, v2)}");
}
223. Exemplos
• Método com parâmetros e com retorno de valor (função)
static void procSoma(int a, int b) {
int S;
S = a + b;
Console.WriteLine($"A soma entre {a} e {b} = {S}.");
}
static int funcSoma(int a, int b) {
int S;
S = a + b;
return S;
}
static int funcSoma_v2(int a, int b)
{
return a + b;
}
224. Exemplos
• Método com parâmetros e com retorno de valor (função)
static void procMax(int a, int b) {
if (a > b)
Console.WriteLine($"{a} é maior que {b}");
else
Console.WriteLine($"{b} é maior que (ou igual a) {a}");
}
static int Max(int a, int b) {
int maior;
if (a > b)
maior = a;
else
maior = b;
return maior;
}
public static void Main (string[] args) {
int v1 = 13, v2 = 38;
procMax(v1, v2);
int resultado = 100 - Max(v1, v2);
Console.WriteLine($"100 - {Max(v1, v2)} = {resultado}");
}
225. Exemplos
• Método com parâmetros e com retorno de valor (função)
static int Max(int a, int b) {
int maior;
if (a > b)
maior = a;
else
maior = b;
return maior;
}
static int Max_v2(int a, int b) {
if (a > b)
return a;
else
return b;
}
static int Max_v3(int a, int b) {
return (a > b)? a : b;
}
226. Exemplos
• Método com parâmetros e com retorno de valor (função)
static int Max(int a, int b) {
return (a > b)? a : b;
}
static int Min(int a, int b) {
return (a < b)? a : b;
}
static int Diferenca(int a, int b) {
return Max(a, b) - Min(a, b);
}
public static void Main (string[] args) {
int v1 = 13, v2 = 38;
Console.WriteLine($"A diferença entre {v1} e {v2} = {Diferenca(v1, v2)}");
Console.WriteLine($"A diferença entre {v2} e {v1} = {Diferenca(v2, v1)}");
}
227. Passagem de parâmetros
• Parâmetros são variáveis ou valores que podem ser transferidos (ou
passados) do programa principal para um método (função ou
procedimento)
• Os valores ou variáveis passados como parâmetros indicam quais os
valores com os quais o método irá trabalhar
• Quanto à nomenclatura, existem 2 tipos de parâmetros:
• Formais: são aqueles que fazem parte da declaração do método e funcionam como
se fossem variáveis
• Reais: são os valores ou variáveis passados para o método em sua invocação ou
chamada. Esses valores ou variáveis são atribuídos aos parâmetros formais
228. Passagem de parâmetros
• Quanto à forma em que os parâmetros são passados, existem 2
maneiras:
• Passagem por valor: o valor do parâmetro real é copiado para o parâmetro
formal, preservando assim o valor original do parâmetro real. Os parâmetros
reais podem ser tanto valores quanto variáveis.
• Passagem por referência: o parâmetro formal funciona como um alias
(apelido) para o parâmetro real. Qualquer alteração feita nos parâmetros
formais, na verdade, está alterando os valores dos parâmetros reais. Nesse
caso, o parâmetro real deve ser uma variável.
229. Passagem de parâmetros por referência
static void Troca(ref int x, ref int y)
{
Console.WriteLine("t********* Método Troca *********");
Console.WriteLine($"tAntes da troca: x = {x} e y = {y}");
int temp = x;
x = y;
y = temp;
Console.WriteLine($"tApós a troca: x = {x} e y = {y}");
Console.WriteLine("t********************************");
}
static void TrocaInternamente(int x, int y)
{
Console.WriteLine("t*** Método TrocaInternamente ***");
Console.WriteLine($"tAntes da troca: x = {x} e y = {y}");
int temp = x;
x = y;
y = temp;
Console.WriteLine($"tApós a troca: x = {x} e y = {y}");
Console.WriteLine("t********************************");
}
230. Passagem de parâmetros por referência
public static void Main (string[] args) {
int a = 5, b = 7, c = 3, d = 19;
Console.WriteLine($"Antes da chamada ao método Troca: a = {a} e b = {b}");
Troca(ref a, ref b);
Console.WriteLine($"Após a chamada ao método Troca: a = {a} e b = {b}");
Console.WriteLine("n=================================n");
Console.WriteLine($"Antes da chamada ao método TrocaInternamente: c = {c} e d = {d}");
TrocaInternamente(c, d);
Console.WriteLine($"Após a chamada ao método TrocaInternamente: c = {c} e d = {d}");
}
231. O método Main()
• O método Main() (principal) é uma função especial dentro de um
programa escrito na linguagem C#
• Ele é chamado automaticamente quando o programa inicial sua
execução
• É ele quem faz a chamada a outros métodos necessários para a
execução do programa
232. Boas práticas
• Um método deve ser pequeno (pouco código)
• Uma antiga regra, dizia que uma boa função deveria caber em uma única tela
• Um método deve ser coeso, ter uma única responsabilidade ou tarefa
• Um método deve ter um nome significativo
• Não exagere na quantidade de parâmetros
234. Manipulação de arquivos em C#
• As classes de manipulação de arquivo estão no namespace System.IO
• IO = Input/Output
• StreamReader e StreamWriter são duas classes responsáveis,
respectivamente, pela leitura e gravação de arquivos em formato
texto
235. Manipulação de arquivos em C#
• StreamReader: fluxo de dados de entrada ou leitura
• Os dados são lidos do arquivo para o seu programa
236. Manipulação de arquivos em C#
• StreamWriter: fluxo de dados de saída ou gravação
• Os dados saem do seu programa e são armazenados em arquivo
237. Manipulação de arquivos em C#
• Operações básicas
• Abrir um arquivo para escrita (gravação)
• Abrir um arquivo para leitura
• Escrever/gravar dados em um arquivo
• Ler dados de um arquivo
• Fechar um arquivo
238. Abrindo um arquivo para escrita
• Para gravarmos dados em um arquivo, no formato texto, devemos instanciar um objeto
da classe StreamWriter
• A classe StreamWriter possui 7 construtoras
• A mais simples recebe como parâmetro um string contendo o path para o arquivo
• StreamWriter SW = new StreamWriter("teste.txt");
• Quando passamos apenas o nome do arquivo, sem o caminho onde ele está localizado, o
arquivo é armazenado no mesmo diretório que o executável do seu programa
• String nomeArq = "MeuArquivo.txt";
• StreamWriter SW = new StreamWriter(nomeArq);
• StreamWriter SW = new StreamWriter("c:tempnavio.dat");
• Nesse caso ocorrerá um erro, pois o C# interpretará os caracteres de escape t e n
• Solução:
• StreamWriter SW = new StreamWriter("c:tempnavio.dat");
• StreamWriter SW = new StreamWriter(@"c:tempnavio.dat");
239. Abrindo um arquivo para escrita
• Qual deve ser a extensão para um arquivo no formato texto?
• Diferente do que muitos imaginam, a extensão .txt não define se um arquivo
está gravado no formato texto. Assim, um arquivo em formato texto pode ter
qualquer extensão.
• Então para que servem as extensões?
• As extensões de arquivos servem para que o Windows saiba que programa
deve ser aberto para visualizar o conteúdo do arquivo. Assim ele sabe que um
arquivo com extensão .doc deve ser visualizado no Word e outro, com
extensão .pdf, no Acrobat Reader.
240. Abrindo um arquivo para escrita
• O parâmetro append é um booleano e determina como um arquivo já
existente será aberto para escrita.
• False: o conteúdo do arquivo é truncado (apagado)
• True: o conteúdo anterior do arquivo é mantido, e quando forem feitas novas
gravações, elas serão armazenadas no final do arquivo
• Por padrão o append é igual a false
• StreamWriter SW = new StreamWriter("teste.txt", true);
• Mantém os dados já existentes no arquivo e adiciona os novos dados no final do
arquivo
• StreamWriter SW = new StreamWriter("teste.txt")
• StreamWriter SW = new StreamWriter("teste.txt", false)
• Apaga os dados previamente armazenados no arquivo
241. Abrindo um arquivo para leitura/gravação
• PERGUNTA: o que acontece se abrirmos um StreamReader e depois
um StreamWriter para o mesmo arquivo?
242. Abrindo um arquivo para leitura/gravação
• PERGUNTA: o que acontece se abrirmos um StreamReader e depois
um StreamWriter para o mesmo arquivo?
• Ocorre um erro. Não podemos ter dois fluxos para um arquivo
abertos ao mesmo tempo.
243. Gravando dados em um arquivo
• Depois de instanciar um objeto StreamWriter, basta usar os métodos
Write() ou WriteLine() para gravar dados em um arquivo, assim como
você usa esses métodos para mostrar algo na tela
• Exemplo:
• arquivo.WriteLine(nome);
• arquivo.Write(x);
244. Abrindo um arquivo para leitura
• Para lermos dados de um arquivo, gravado no formato texto, devemos
instanciar um objeto da classe StreamReader
• A classe StreamReader possui 10 construtoras
• A mais simples recebe como parâmetro um string contendo o path para o
arquivo
• StreamReader SR = new StreamReader("teste.txt");
• Lembre-se: quando passamos apenas o nome do arquivo, sem o caminho
onde ele está localizado, o arquivo é armazenado no mesmo diretório que
o executável do seu programa
• String nomeArq = "MeuArquivo.txt";
• StreamReader SR = new StreamReader(nomeArq);
• StreamReader SR = new StreamReader("c:tempnavio.dat");
• StreamReader SR = new StreamReader(@"c:tempnavio.dat");
245. Lendo dados de um arquivo
• Usa-se, assim como na classe Console, o método ReadLine(), o qual
retorna um string e move o cursor para a linha seguinte no arquivo
• Exemplo:
• string linha = SR.ReadLine();
• linha = SR.ReadLine().ToUpper();
• linha = SR.ReadLine().ToLower();
246. Testando o fim de um arquivo
• Quando o arquivo termina, o método ReadLine() retorna null. Assim,
para testar se ainda há dados no arquivo, pode-se usar a seguinte
estrutura:
linha = SR.ReadLine();
while(linha != null)
{
…
linha = SR.ReadLine();
}
247. Fechando um arquivo
• Usa-se o método Close() tanto para as classes StreamReader quanto
para StreamWriter
REGRA DE OURO: Abriu? Feche!!!