Microfundamento - Algoritmos e Lógica de Programação (1).pdf

Algoritmos e Lógica de
Programação
Prof. Rodrigo Richard Gomes

Introdução à lógica de
programação
Unidade 1 – Lógica de Programação e
Estruturas de Controle

1 – Dê 5 passos para frente
2 – Vire 90 graus para a direita
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
10 – Vire 90 graus à esquerda
12 – Entregue-me o objeto

Conceitos de
Algoritmos
• Algoritmo é a descrição de uma sequência de
passos que deve ser seguida para a realização de
uma tarefa

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.

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𝑎𝑎

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

Estruturas
básicas de um
Algoritmo
Estrutura
Seqüencial
Estrutura
Condicional
Estrutura de
Repetição

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

Tipos de dados
Tipos
de
dados
Simples
Numéricos
Inteiros
Reais
Não numéricos
Lógico
Caractere
Estruturados
Arranjos
Vetores
Matrizes
Arquivos

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

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"

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

Variáveis – Endereço de memória
Memória RAM

Memória RAM
Unidades de armazenamento
1 bit – 0 ou 1
1 byte – 8 bits
1 kilobyte (KB) – 1024 bytes (210)
1 megabyte (MB) – 1024 KB (220)
1 gigabyte (GB) – 1024 MB (230)
1 terabyte (TB) – 1024 GB (240)

Memória RAM
Unidades de armazenamento
1 bit – 0 ou 1
1 byte – 8 bits
1 kilobyte (KB) – 1024 bytes (210)
1 megabyte (MB) – 1024 KB (220)
1 gigabyte (GB) – 1024 MB (230)
1 terabyte (TB) – 1024 GB (240)
4 GB de memória RAM equivalem a cerca
de 4 bilhões de bytes na memória

Variáveis –
Endereço de
memória

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

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

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

Identificadores
• Para que um nome de variável seja significativo, não é
necessário usar nomes muito extensos:
datadenascimento
dtnasc

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

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();
}

Algoritmo Exemplo
(identificadores apropriados e inapropriados)
{
// 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();
}

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.

{
int idade;
int numero;
double altura;
double peso;
double salario;
string nomePai;
string rua;
string bairro;
string dtNasc;
bool temCasa;
}

{
int idade, numero;
double altura, peso, salario;
string nomePai, rua, bairro, dtNasc;
bool temCasa;
}

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

Etapas de um algoritmo
Entrada de dados
Saída de dados
Processamento (cálculo)

Estruturas básicas de
programação

Estrutura Sequencial
Atribuição

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;

• 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).

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);
}
}

using System;
class MainClass {
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);
}
}

Saída de Dados

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.

• 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

• 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

Placeholders, concatenação e interpolação
using System;
class MainClass {
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();
}
}

Placeholders, concatenação e interpolação

Entrada de Dados

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();

• 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());

• Lendo texto
• Lendo valores booleanos
variavel = Console.ReadLine();
variavel = bool.Parse(Console.ReadLine());

using System;
class MainClass {
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();
}
}

{
int n1, n2, soma;
double media;
Console.Write("Digite um número: ");
Console.Write("Digite outro número: ");
soma = n1 + n2;
media = soma / 2;
Console.WriteLine("Soma = "+soma);
Console.WriteLine("Media = "+media);
}
Exemplo 1
Entrada
de Dados
Cálculos
Saída de
Dados

Operações Aritméticas

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;

• 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;

• 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;

• Operadores de incremento
using System;
class MainClass {
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}");
}
}

• 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

• 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));

• 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));

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

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.

• 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

using System;
class MainClass {
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}");
}
}

• 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

• 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;

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;

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

Exemplo 1
Fluxograma
Início
FimAlgoritmo
soma
media
n1, n2,
n3, n4,
n5
soma = n1 + n2 + n3 + n4 + n5
media = soma / 2

Exemplo 1
using System;
class MainClass {
// Declaração de variáveis
int n1, n2, n3, n4, n5, Soma;
Double Media;
// Entrada de dados
Console.Write("Digite o primeiro número: ");
Console.Write("Digite o segundo numero: ");
Console.Write("Digite o terceiro numero: ");
Console.Write("Digite o quarto numero: ");
Console.Write("Digite o quinto numero: ");
// 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}");
}
}

Exemplo 1
using System;
class MainClass {
int n1, n2, n3, n4, n5, Soma;
Double Media;
// Entrada de dados
Console.Write("Digite o primeiro número: ");
Console.Write("Digite o segundo numero: ");
Console.Write("Digite o terceiro numero: ");
Console.Write("Digite o quarto numero: ");
Console.Write("Digite o quinto numero: ");
// 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

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 +
=

Exemplo 2
Fluxograma
Início
FimAlgoritmo
hipotenusa
cateto1
cateto2
hipotenusa = 𝑐𝑐𝑐𝑐𝑐𝑐𝑐2 + 𝑐𝑐𝑐𝑐𝑐𝑐𝑐2

Exemplo 2
using System;
class MainClass {
Double Hipotenusa, Cateto1, Cateto2;
// Entrada de dados
Console.Write("Informe o valor do cateto 1: ");
Cateto1 = 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}");
}
}

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

Exemplo 3
Fluxograma
Início
FimAlgoritmo
inss
salario
inss = 11% do salario

Exemplo 3
using System;
class MainClass {
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}");
}
}

Estruturas condicionais

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 {
Double Hipotenusa, Cateto1, Cateto2;
// Entrada de dados
// 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}");
}
}

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

Estrutura condicional simples
• Sintaxe:
if (condição)
comando;
A condição pode ser
verdadeira ou falsa

if (condição)
comando;
comando;
comando;
Condição VERDADEIRA: o
comando depois do if SERÁ
executado
comando;
comando;
comando;
comando;

if (condição)
comando;
comando;
comando;
Condição FALSA: o comando
depois do if NÃO SERÁ
executado
comando;
comando;
comando;
comando;

using System;
class MainClass {
int nota;
Console.Write("Digite a nota do aluno : ");
nota = int.Parse(Console.ReadLine());
if (nota >= 60)
Console.WriteLine("O aluno foi aprovado.");
}
}

Estrutura condicional composta
• Sintaxe:
if (condição)
comando1;
else
comando2;
A condição pode ser
verdadeira ou falsa

if (condição)
comando1;
else
comando2;
comando;
comando;
Condição VERDADEIRA: o
comando depois do if SERÁ
executado
comando;
comando;
comando;
comando;

if (condição)
comando1;
else
comando2;
comando;
comando;
Condição FALSA: o comando
depois do else SERÁ executado
comando;
comando;
comando;
comando;

using System;
class MainClass {
int nota;
if (nota >= 60)
else
Console.WriteLine("O aluno foi reprovado.");
}
}

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;
}

Blocos de comandos
using System;
class MainClass {
int nota;
if (nota >= 60)
{
Console.WriteLine("PARABENS!!!");
}
else
}
}

Blocos de comandos
using System;
class MainClass {
int nota;
if (nota >= 60)
else
{
Console.WriteLine("Ele devera fazer a reavaliação!!!");
}
}
}

Blocos de comandos
using System;
class MainClass {
int nota;
if (nota >= 60)
{
Console.WriteLine("PARABENS!!!");
}
else
{
Console.WriteLine("Ele devera fazer a reavaliação!!!");
}
}
}

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");
}

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

Operadores relacionais
= ≠ ==
Operador de atribuição
int x = 5;
Operador relacional igual
if (x == y)

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

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

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.

Solução
using System;
class MainClass {
double Salario, INSS;
Console.Write("Digite o salario do funcionario : R$ ");
if (Salario <= 1000)
INSS = Salario * 0.08;
else
Console.WriteLine($"Valor a ser descontado de INSS = R$ {INSS:0.00}");
}
}

Solução (EVITE – if´s independentes)
using System;
class MainClass {
double Salario, INSS = 0;
Console.Write("Digite o salario do funcionario : R$ ");
if (Salario > 1000)
}
}

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.

Solução
using System;
class MainClass {
Double Salario, INSS;
Console.Write("Digite o salario do funcionario : ");
else
else
}
}

Solução (EVITE – usando if´s independentes)
using System;
class MainClass {
Double Salario, INSS;
Console.Write("Digite o salario do funcionario : ");
if (Salario > 1000 && Salario <= 1800)
if (Salario > 1800)
}
}

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;

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)
else

Else oscilante
O que foi deveria ter sido escrito
if (Richter >= 0)
{
if (Richter <= 4)
}
else
Agora o else se refere ao primeiro if.

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
}

Comando switch
using System;
class MainClass {
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);
}
}

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;
}

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

• 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;

• 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);

• Exemplo 3
• Utilizando o operador ternário
double INSS;
if (salario <= 1000)
INSS = salario * 0.08;
else
INSS = salario * 0.10;
INSS = (salario <= 1000 ? salario * 0.08 : salario * 0.10);

Estruturas de repetição

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;

O Fluxograma
• Diagrama utilizado para representar graficamente um algoritmo

Console.Write("*************n");
Console.Write("Algoritmos e ");
Console.Write("Lógica ");
Console.Write("de Programaçãon");
Console.Write("*************");
}

Console.Write("*************");
}

using System;
class MainClass {
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}");
}
}

Comando while
Repetição com teste no início

Estruturas de repetição – Comando while

using System;
class MainClass {
while (numero > 0)
{
Console.WriteLine($"A raiz quadrada de {numero} = {raiz}");
}
}
}

Comando do..while
Repetição com teste no final

Estruturas de repetição – Comando do..while

using System;
class MainClass {
// Calcula a raiz quadrada enquanto
// o numero digitado for maior que 0 (zero)
do
{
} while (numero > 0);
}
}

using System;
class MainClass {
// Calcula a raiz quadrada enquanto
// o numero digitado for maior que 0 (zero)
do
{
if (numero > 0)
{
}
} while (numero > 0);
}
}

Comando for
Repetição contada

Estruturas de repetição – Comando for

using System;
class MainClass {
int cont = 1;
// Calcula a raiz quadrada de 10 numeros
while (cont <= 10)
{
cont = cont + 1; // ou cont++ ou cont += 1
}
}
}

using System;
class MainClass {
int cont;
for(cont = 1; cont <= 10; cont++)
{
}
}
}

using System;
class MainClass {
for(int cont = 1; cont <= 10; cont++)
{
}
}
}

using System;
class MainClass {
{
}
}
}
1. inicialização

using System;
class MainClass {
{
}
}
}
2. condição

using System;
class MainClass {
{
}
}
}
3. Bloco de
comandos

using System;
class MainClass {
{
}
}
}
4. atualização

RESUMO

while (condição)
comando;
while (condição) {
comando_1;
comando_2;
...
comando_n;
}

do {
comando_1;
comando_2;
...
comando_n;
} while (condição);

Diferença
entre os
comandos
while
e
do..while

for (inicialização; condição; atualização) {
comando_1;
comando_2;
...
comando_n;
}

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;

Contador – Exemplo 1
using System;
class MainClass {
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: ");
}
Console.Write($"Foram digitados {positivos} numeros positivos.");
}
}

using System;
class MainClass {
int pares = 0; // Contador de números pares
int num;
Console.Write("Digite um numero positivo: ");
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
}
Console.Write($"Foram digitados {pares} numeros pares.");
}
}

Contador – Exemplo 3a
using System;
class MainClass {
// Contador de números pares e ímpares
int pares = 0, impares;
int num;
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
else
impares = impares + 1;
}
Console.Write($"Foram digitados {pares} numeros pares e {impares} impares.");
}
}

Contador – Exemplo 3b
using System;
class MainClass {
// Contador de números pares e ímpares
int pares = 0, impares = 0;
int num;
while (num >= 0)
{
if(num % 2 == 0)
pares = pares + 1;
else
impares = impares + 1;
}
Console.Write($"Foram digitados {pares} numeros pares e {impares} impares.");
}
}

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;

Contador – Exemplo 4 (erro)
using System;
class MainClass {
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: ");
}
if(nota >= 60)
aprov++;
else
reprov++;
Console.Write($"{aprov} alunos foram aprovados e {reprov} foram reprovados.");
}
}

using System;
class MainClass {
string nome;
int nota = 0;
for(int i = 1; i <= 5; i++) {
}
if(nota >= 60)
aprov++;
else
reprov++;
}
}
Contador – Exemplo 4 (erro)

using System;
class MainClass {
string nome;
int nota = 0;
for(int i = 1; i <= 5; i++) {
if(nota >= 60)
aprov++;
else
reprov++;
}
}
}

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;

Acumulador – Exemplo 1
using System;
class MainClass {
int num;
int soma = 0; // Acumulador
Console.Write("Digite um numero maior que zero: ");
while (num > 0)
{
soma = soma + num;
}
Console.Write($"A soma dos numeros digitados = {soma}.");
}
}

Acumulador – Exemplo 1a (problema)
using System;
class MainClass {
Double num;
int soma = 0; // Acumulador
num = Double.Parse(Console.ReadLine());
while (num > 0)
{
soma = soma + num;
}
}
}

Acumulador – Exemplo 1b
using System;
class MainClass {
Double num;
Double soma = 0; // Acumulador
while (num > 0)
{
soma = soma + num;
}
}
}

using System;
class MainClass {
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($"nO valor total da compra = R$ {totalCompra:0.00}");
}
}
Acumulador – Exemplo 2

Acumulador – Exemplo 2a
using System;
class MainClass {
while (preco > 0)
{
totalCompra = totalCompra + preco;
Console.Write($"tSubtotal = R$ {totalCompra:0.00}.n");
}
}
}

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;

using System;
class MainClass {
while (preco > 0)
{
totalCompra += preco;
Console.Write($"tSubtotal = R$ {totalCompra:0.00}.n");
}
}
}
Acumulador – Exemplo 2b

Modularização
Unidade 2 – Modularização e
manipulação de dados em memória
primária e secundária

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

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

Procedimentos
• Um procedimento é um conjunto de instruções que realiza uma
determinada tarefa
• Um procedimento é uma abstração de um comando

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

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

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;
}

Declaração
• Declarando um método sem retorno de valor (procedimento) em C#
void nome_método ( <lista de parâmetros> )
{
comando1;
comando2;
...
comandon;
}

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

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

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;

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>);

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;

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();
}

Exemplos
• Método com parâmetros e sem retorno de valor (procedimento)
static void ImprimeCabecalho(string nome)
{
Console.WriteLine($"Nome do aluno: {nome}");
}

Exemplos
• Método com parâmetros e sem retorno de valor (procedimento)
static void ImprimeCabecalho(string nome, char sexo)
{
if(sexo == 'F' || sexo == 'f’)
Console.WriteLine($"Nome da aluna: {nome}");
else
Console.WriteLine($"Nome do aluno: {nome}");
}

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;
}
int v1 = 13, v2 = 38;
procSoma(v1, v2);
Console.WriteLine($"{v1} + {v2} = {funcSoma(v1, v2)}");
}

Exemplos
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;
}

Exemplos
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;
}
int v1 = 13, v2 = 38;
procMax(v1, v2);
int resultado = 100 - Max(v1, v2);
Console.WriteLine($"100 - {Max(v1, v2)} = {resultado}");
}

Exemplos
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;
}

Exemplos
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);
}
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)}");
}

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

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.

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********************************");
}

Passagem de parâmetros por referência
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}");
}

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

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

Manipulação de arquivos
Unidade 2 – Modularização e
manipulação de dados em memória
primária e secundária

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

• StreamReader: fluxo de dados de entrada ou leitura
• Os dados são lidos do arquivo para o seu programa

• StreamWriter: fluxo de dados de saída ou gravação
• Os dados saem do seu programa e são armazenados em arquivo

• 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

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");

• 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.

• 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

Abrindo um arquivo para leitura/gravação
• PERGUNTA: o que acontece se abrirmos um StreamReader e depois
um StreamWriter para o mesmo arquivo?

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.

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);

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");

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();

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();
}

Fechando um arquivo
• Usa-se o método Close() tanto para as classes StreamReader quanto
para StreamWriter
REGRA DE OURO: Abriu? Feche!!!

Microfundamento - Algoritmos e Lógica de Programação (1).pdf

Mais conteúdo relacionado

Semelhante a Microfundamento - Algoritmos e Lógica de Programação (1).pdf (20)

Último (10)

Microfundamento - Algoritmos e Lógica de Programação (1).pdf