aula algoritmos e programação LinguagemC.pdf

Universidade Federal do Rio Grande do Sul
Instituto de Informática
Aula 03 - Linguagem C:
Tipos de variáveis, expressões
aritmética
Dr. Muriel Figueredo Franco
mffranco@inf.ufrgs.br
2024/1
INF01202 - Algoritmos e Programação CIC (Teórica)

Avisos

Moodle: https://moodle.ufrgs.br
—
Algoritmos e Programação – Turmas G e H – 2024/1

Slides teóricos, Cronograma, Atividades práticas
—
Provas: 11/05 (P1), 06/07 (P2) e 15/07 (Recuperação)

Sábados, todas as turmas em conjunto

Aulas Práticas

Sumário
1. Exercício
2. Características da Linguagem C
3. Expressões Aritméticas
4. Exercícios

Exercício - Enunciado
● Enunciado: Faça um algoritmo e o programa
correspondente que, dado o preço de um produto
em reais, converta este valor para o equivalente
em dólares. O preço do produto e a taxa de
conversão para o dólar devem ser informados
através do teclado.

Exercício - Análise e definição do problema
• Entradas: ?
• Saídas: ?
• Processamento: ?

Exercício - Análise e definição do problema
• Entradas: preço do produto em reais, taxa de conversão
• Saídas: preço do produto em dólares
• Processamento: Converter o preço do produto em
reais, para dólares, dividindo o preço em reais pela taxa de
conversão.

Exercício - Algoritmo
Algoritmo ConversãoParaDolar
/* Calcula a conversão de um valor em Reais para Dólar
entradas: preço em real, taxa de conversão
saídas: preço em dolar */
1. início
2. obtém valor do preço em real
3. obtém valor da taxa de conversão
4. calcula o preço em dolar
5. informa o preço em dolar
6. fim

Exercício – Algoritmo refinado
saídas: preço em dólar */
1. início
2. ler precoReal
3. ler taxa
4. precoDolar ← precoReal / taxa
5. escrever precoDolar
6. fim.
saídas: preço em dólar */
1. início
2. obtém valor do preço em real
3. obtém valor da taxa de conversão
4. calcula o preço em dolar
5. informa o preço em dolar
6. fim

Exercício – Programa em C
/* NOME DO AUTOR */
/* Programa que converte um valor em reais para dolares.
Entradas: valor em reais, taxa de conversão
Saída: valor em dólares */
#include <stdio.h> // biblioteca para I/O
int main() // programa principal
{
float preco_real, preco_dolar, taxa; // nao pode ser
inteiro!
printf(“Informar preco em real: R$ ”);
scanf(“%f”,&preco_real); //le e armazena na variável
printf(“Informar taxa de conversao: R$ ”);
scanf(“%f”,&taxa);
preco_dolar = preco_real/taxa;
printf(“O preco em dolar vale: US$ %4.2f”, preco_dolar);
return 0; // encerra funcao main
}

Exercício – Execução
Usar notação americana para
números reais.
O ponto é usado como separador
decimal.

2. Características
da Linguagem C

Histórico da linguagem C
● Linguagem
– Compilada
– Estruturada
– Padronizada pela ISO
● Criada por Dennis Ritchie, na década de 1970, no AT&T Bell
Labs, para reescrever o sistema operacional Unix
● Baseada na linguagem chamada “B”; versão reduzida da BCPL
(Basic Combined Programming Language)
● Uma das linguagens mais populares, desde que foi criada
● Existem poucas arquiteturas para as quais não existe compilador
para C
● Inspirou diversas outras linguagens:
— C++, Java, C#, etc

Recapitulando: Variáveis - Tipos
Tipo Representa Exemplos Tamanho
Intervalo de valores
aceitos
char Caracteres a, B, *, 9 1 byte
Qualquer caractere
no padrão ASCII
int Números inteiro 0,12,-323 4 bytes
[-2147483648 a
2147483647]
float
Números reais
com precisão
de 7 dígitos
3.4, 85.96 4 bytes
double
Números reais
com precisão
de 15 dígitos
85.9656...
8 bytes

Elementos léxicos do C
● Letras: maiúsculas e minúsculas
● Dígitos: 0 a 9
● Sublinhado: _
● Outros símbolos especiais:
– #|& /* “ . , ; .. ( ) { } ‘ : = ^

Sintaxe: sensível à caixa das letras
● Letras maiúsculas e minúsculas são diferentes!
● Palavras reservadas sempre em minúsculas!
● Convenção:
– Variáveis: combinam maiúsculas e minúsculas
– Notação camelBack ou (camelCase).
● Ex: alturaMedia, precoEmReal, ...
– Notação com underline.
● Ex: altura_media, preco_em_real
– Constantes (definidas com define) em maiúsculas
– Veremos mais adiante.

Palavras reservadas da linguagem C
● Identificadores associados a elementos que compõem
uma linguagem de programação
● As 32 palavras reservadas padrão são:
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

Comentários
● Permite a inclusão de observações, que visam auxiliar a
compreensão do que está sendo executado pelo programa.
● O compilador ignora completamente tudo que estiver
comentado.
● Podem adotar 2 formas:
– Comentários de uma linha:
//<comentário>
– Comentários de muitas linhas:
/* <comentário> */
● Boa prática:
– Incluir comentário na 1ª linha, contendo descrição do programa!
– Incluir comentários em funções e partes do programa mais
complicadas

Bibliotecas
● Conjuntos de funções elementares pré-definidas.
– Funções são pequenos subprogramas que realizam uma tarefa
específica e que podem ser “chamados” em outros programas.
– “Caixas de ferramentas”
● Bibliotecas disponíveis:
– Muitas!
– Entrada e saída de dados, manipulação matemática, manipulação
de áudio e vídeo, manipulação de banco de dados, etc.
● Sintaxe para incluir uma biblioteca:
#include <biblioteca>

Bibliotecas
● Algumas bibliotecas importantes:
Funções de texto
#include <string.h>
Funções do sistema
#include <system.h>
Funções matemáticas
#include <math.h>
Funções padrão, como system
#include <stdlib.h>
Funções de entrada e saída
#include <stdio.h>

Expressões aritméticas
● Sintaxe de expressões aritméticas:
● Onde:
– Operando:
– Corresponde a um valor constante, de uma variável, resultante de uma
função ou de outra expressão.
– Operador:
– Operador aritmético.
<operando> <operador> <operando>

Operadores aritméticos
Resto da divisão inteira de x por y
(requer operandos inteiros)
x % y
%
Divide x por y (se operandos inteiros,
executa divisão inteira, senão real)
x / y
/
Multiplica x e y
*
Subtrai y de x
x – y
-
Soma x e y
x + y
+
Explicação
Exemplo
Operador
x * y

Exemplos:
x + 10
x + y
x + 12*y
x + pow(y,3)

Exemplos:
x + 10
x + y
x + 12*y
x + pow(y,3)
Constante (literal)
Variável
Expressão
Função

Exemplo - Operadores aritméticos
{
int val1, val2, quociente, resto; // variáveis inteiras
val1 = 12;
val2 = 5;
quociente = val1/val2;
resto = val1%val2;
printf(“Quociente: %dnResto: %dn”, quociente, resto);
}
O que será exibido
na tela?

Resto da divisão inteira
● O resto da divisão inteira é útil em várias situações
práticas:
– Como converter 3473 segundos para o formato MM:SS, onde MM
é a quantidade de minutos e SS é a quantidade de segundos?
○ MM = 3473/60 = 57
○ SS = 3473%60 = 53
Saída: 57:53

Resto da divisão inteira
● O resto da divisão inteira é útil em várias situações
práticas:
– Como converter 3473 segundos para o formato MM:SS, onde MM
é a quantidade de minutos e SS é a quantidade de segundos?
■ MM = 3473/60 = 57
■ SS = 3473%60 = 53
■ Resultado -- 57:53

Funções aritméticas
Necessário:
#include <math.h>
Função Exemplo Explicação
ceil ceil(x) Retorna o menor inteiro maior ou igual a x: ceil(3.2) é 4
cos cos(x) Cosseno de x (x em radianos)
exp exp(x) e elevado à potencia x
fabs fabs(x) Valor absoluto de x
floor floor(x) Retorne o maior inteiro menor ou igual a x: floor(3.2) é 3
log log(x) Logaritmo natural de x
log10 log10(x) Logaritmo decimal de x
pow pow(x, y) Calcula x elevado à potência y
sin sin(x) Seno de x
sqrt sqrt(x) Raiz quadrada de x
round round(x) Retorna o inteiro mais próximo de x: round(3.2) é 3
tan tan(x) Tangente de x
Referência:
https://en.wikibooks.org/wiki/C_Programming/math.h

Expressões e operações matemáticas básicas
● Prioridade (precedência de operadores):
Prioridade Operadores
1ª Parênteses mais internos
2ª Funções
3ª *, /, %
4ª +, -

Equivalência de expressões
Expressão
algébrica
Expressão em C Interpretação
a + b + c + d
4
a+b+c+d / 4
(a+b+c+d) / 4
Necessidade de parênteses, para que a
soma dos 4 valores ocorra antes da
divisão. Se não usados, d será dividido (/)
por 4 antes de somado com os demais
b2
4ac
b2 / 4 * a * c
b * b / (4 * a * c)
Todos os operadores devem ser
explicitamente escritos na prioridade
definida
(a + b) 2 ( a + b ) * ( a + b )
ou
pow(a+b,2)
Não existe operador potência: multiplica 2
vezes ou usa função pow (biblioteca
<math.h>).
4πr 3 4 * 3.1416 * (r*r*r)
ou
4*3.1416 * pow(r,3)
π é um caractere grego, sem significado
para C padrão.

Expressões aritméticas - Exercício
Determine o valor de cada expressão, considerando
x=2, y=3, c=10
1. (12-c)*(8/x) = ?
2. 12-c*(8/x) = ?
3. 14%4-2*y = ?

x=2,y=3,c=10
1. (12-c)*(8/x) = (12-10)*(8/2) = 2*4 = 8
2. 12-c*(8/x) = ?
3. 14%4-2*y = ?

x=2,y=3,c=10.
1. (12-c)*(8/x) = (12-10)*(8/2) = 2*4 = 8
2. 12-c*(8/x) = 12-10*(8/2) = 12-10*4 = 12-40 = -28
3. 14%4-2*y = ?

x=2,y=3,c=10.
1. (12-c)*(8/x) = (12-10)*(8/2) = 2*4 = 8
2. 12-c*(8/x) = 12-10*(8/2) = 12-10*4 = 12-40 = -28
3. 14%4-2*y = 14%4-2*3 = 2-2*3 = 2-6 = -4

Modeladores (casts)
● Em algumas situações, queremos alterar o tipo do valor
resultante de uma expressão aritmética
— Para isso, utilizamos os modeladores (casts)
● Sintaxe:
● Exemplo:
— float x, int y=7;
— x = y/2;

Resultado: 3.0
— X = (float) y/2;

Resultado: 3.5
(<tipo>) <expressão>

Modeladores (casts)
● Quando todos os operandos de uma expressão são
inteiros, todos os resultados parciais são inteiros também
● Considere que x, y e z são inteiros e num_real é float.
int
int int
int
int int
int
int
float
int x, y, z;
x = 1;
y = 2;
Z = 1;
float num_real;
num_real= x/2+ y/2 + z/2;
?
int

Modeladores (casts)
inteiros, todos os resultados parciais são inteiros
também.
0 + 1 + 0 = 1.0
int x, y, z;
x = 1;
y = 2;
z = 1;
float num_real;
num_real= x/2+ y/2 + z/2;
int
int int
int
int int
int
int
float
int

Modeladores (casts)
inteiros, todos os resultados parciais são inteiros
também.
0 + 1 + 0 = 1.0
int x, y, z;
x = 1;
y = 2;
Z = 1;
float num_real;
num_real= x/2+ y/2 + z/2; Ocorre truncamento.
Descartam-se os
dígitos decimais
int
int int
int
int int
int
int
float
int

Modeladores (casts)
/* Programa que demonstra a utilização de casts
Entrada: 3 valores inteiros
Saída: 4 resultados da soma das divisões das entradas por 2 */
{
int x=1, y=2, z=1; // variáveis inteiras inicializadas na
declaração
float res1, res2, res3, res4; // variáveis float declaradas
res1 = x/2 + y/2 + z/2;
res2 = (float)x/2 + y/2 + z/2;
res3 = (float)x/2 + (float)y/2 + z/2;
res4 = (float)x/2 + (float)y/2 + (float)z/2;
printf("Caso 1 %fn", res1);
}
O que será exibido na tela?

Modeladores (casts)
{
declaração
float res1, res2, res3, res4; // variáveis float declaradas
res1 = x/2 + y/2 + z/2;
res2 = (float)x/2 + y/2 + z/2;
res3 = (float)x/2 + (float)y/2 + z/2;
res4 = (float)x/2 + (float)y/2 + (float)z/2;
}

Modeladores (casts)
{
declaração
float res;
res = x/2.0 + y/2.0 + z/2.0;
printf(“Resultado %fn", res);
}
O que será exibido na tela?

Modeladores (casts)
{
declaração
float res;
res = x/2.0 + y/2.0 + z/2.0;
printf(“Resultado %fn", res);
}
O que será exibido na
tela? Quando os operadores de cada
subexpressão são inteiros e reais,
cada resultado parcial é real

● Em código são escritos assim:
– int
x = 5;
y = -15;
– números reais - float, double
num = 15.99 ---- igual a 15,99
v = 3.6753e2 ---- igual a 367,53 (ou 3.6753 * 10²)
eps = 8e-7 ---- igual a 0,0000008 (ou 8 * 10-7
)
● especificar tipo float: 0.1f --- sufixo f
● especificar tipo double: 0.1d --- sufixo d (default, se não usar sufixo)
– char aparece entre aspas simples
letra = ‘A’
cod = ‘>’
val = ‘5’
– string (cadeia de caractereres) aparece entre aspas duplas
– “palavra”, “texto contendo espacos”, “texto comnquebra de linha”
Valores constantes (“literais”)

Operadores de atribuição (atalhos)
Operador Exemplo Comentário
= x = y Atribui o valor de y a x
++ x++ x = x + 1
-- x-- x = x – 1
+= x += y x = x + y
-= x -= y x = x – y
*= x *= y x = x * y
/= x /= y x = x / y
%= x %= y x = x % y

Constantes
● Constantes são dados que não são alterados ao longo
da execução do programa
● Às vezes queremos identificar uma constante que é
utilizada em diversos pontos do programa
– Facilita a manutenção do código

Constantes
#include <stdio.h>
int main()
{
float r, circunferencia, area;
scanf(“%f”, &r);
circunferencia = 2.0*3.16*r;
area = 3.16*r*r;
printf(“%f,%f”,circunferencia,area);
return 0;
}
● O que este programa faz? (ou deveria fazer...)

#include <stdio.h>
int main()
{
circunferencia = 2.0*3.16*r;
area = 3.16*r*r;
printf(“%f,%f”, circunferencia,area);
return 0;
}
Constantes
Este programa deveria calcular a circunferência e a área de
um círculo de raio r.
• Não fica claro o significado de
3.16.
• Deveria ser π, mas o valor está
incorreto.
• Para corrigir, devemos alterar o
valor em cada ocorrência do
programa.

Constantes
● Para representar constantes identificadas:
– Usa-se a diretiva #define
● Exemplo:
● Com isso, pode-se substituir as ocorrências do valor de PI pela constante
PI no código
– Padroniza o tratamento da mesma constante ao longo do código.
● Identificador será substituído em tempo de compilação pelo valor
indicado.
● Convenção:
– Identificadores de constantes devem utilizar apenas letras
maiúsculas!
#define <nome da constante> <valor da constante>
#define PI 3.14159

Constantes
#include <stdio.h>
#define PI 3.14159
int main()
{
circunferencia = 2.0*PI*r;
area = PI*r*r;
printf(“%f,%f”, circunferência,area);
return 0;
}

Exercício
● Um funcionário recebe uma comissão por cada venda
efetuada. Faça um algoritmo e o programa em C que:
—leia valor de uma venda e o percentual de
comissão (número inteiro correspondente ao
percentual)
—calcule a comissão a ser recebida
—mostre a comissão a ser recebida

Exercício
Dado o valor de uma venda em reais e a
comissão (percentual) a ser paga por esta
venda,
calcule e mostre o valor desta comissão.
Especificação do Problema: Enunciado
Entradas: valor de venda em reais,
percentual da comissão em inteiro
Saída: comissão em reais
Processamento: calcular valor de
comissão, multiplicando o valor da
venda pelo percentual em decimal

Exercício
Algoritmo
algoritmo calculacomissao;
/* calcula a comissão de um vendedor
entradas: valorvenda, percentual
saídas: comissao */
1. início
2. ler valorvenda
3. ler percentual
4. comissao ← valorvenda * percentual / 100
5. escrever comissao
6. fim

Exercício
Programa em C
/* Programa que calcula a comissão de uma venda
Entrada: valor vendido em reais e comissão em inteiro
(percentual)
Saída: valor da comissão em reais */
{
float valorVendido; // valor vendido em reais
float comissao; // da comissao em percentual
float comissaoEmReais; // resultado com o valor da comissão
printf("Informe o valor vendidon");
scanf("%f", &valorVendido); // lendo entrada
printf("Informe o percentualn");
scanf("%f", &comissao); // lendo entrada
// Calculo da comissão
comissaoEmReais = (comissao * valorVendido)/100;
printf("Comissao em reais: R$ %.2fn", comissaoEmReais);
}

Exercício
2) Faça um algoritmo que:
– leia um valor inteiro;
– calcule o menor número de notas necessárias
para completar este valor. Lembre que as notas
correntes no real são 200,100,50,20,10,5 e 2 e
1 (incluindo aqui também a moeda).

Exercício
Dado a parte inteira de um valor em reais,
calcular e mostrar o mínimo de notas
equivalentes a este valor.
Especificação do Problema: Enunciado
Entradas: valor inteiro
Saída: notas e quantidades
correspondentes ao valor
Processamento: Identificar o
número de notas de cada valor
necessárias para gerar o valor de
entrada

Exercício
Exemplo de execução:

Exercício
Programa em C
#include <stdio.h>
int main() {
int valor, notas;
printf("Digite o valor: ");
scanf("%d", &valor);
// Calculando o número de notas necessárias
notas = valor / 200;
printf("Notas de 200: %dn", notas);
valor %= 200;
notas = valor / 100;
printf("Notas de 100: %dn", notas);
valor %= 100;
notas = valor / 50;
printf("Ntas de 50: %dn", notas);
Valor %= 50;
// Continuar o código até as notas de R$ 1
return 0;
}
valor = valor % 200

Material suplementar
Os próximos slides contém material suplementar, que deve
ser lido e estudado pelos alunos

Inicialização de variáveis na declaração
● É possível atribuir valores para as variáveis quando elas
são declaradas.
int main() {
declaração
float media;
media = (x + y + z)/2.0;
printf(“Resultado %fn", media);
}

Inicialização de variáveis na declaração
● É possível atribuir valores para as variáveis quando elas
são declaradas.
● Após a definição do tipo, cada variável deste tipo pode
receber um valor.
– Para o caso de mais de uma variável, elas devem ser separadas por
vírgula.
int main() {
declaração
float media;
media = (x + y + z)/2.0;
printf(“Resultado %fn", media);
}
<tipo> <variável 1>=<valor 1>, <variável 2>=<valor 2>,...;

Aprofundando o printf
● Existem caracteres com funções especiais que podem
ser utilizados no printf (e quando trabalhamos com texto
em geral)
Função
b BackSpace
n New Line (mudança de
Linha)
t Tabulação Horizontal
v Tabulação Vertical
imprime o próprio
caractere
' imprime o caractere '
" imprime o caractere "
? imprime o caractere ?

● Exemplo com tabulação horizontal.
● Exibir uma matriz 9 X 9 na tela.
#include <stdio.h>
int main(){
printf("%d %d %dn",2,12,123);
printf("%d %d %dn",223,1,56);
printf("%d %d %dn",135,56,34);
return 0;
}
#include <stdio.h>
int main(){
printf("%dt%dt%dn",2,12,123);
return 0;
}
Utilizando espaços Utilizando tabulação horizontal

● Controle de espaço usado em tela
● Um * (asterisco) entre % e a especificação de formato, indica
que o primeiro valor informado após a string de controle é o
número de posições que devem ser usadas para apresentar o
valor seguinte
#include <stdio.h>
int main( ){
int tam = 10, valor = 12;
printf("n==>%*d<== ==>%*d<==n", 5 , 12, 10, 1); // 5 posições
para 12 e 10 para 1
printf("n==>%*d<==n", tam , 12); // 10 posições para 12
printf("n==>%*d<==n", 20 , valor); // 20 posições para 12
return 0;
}

#include <stdio.h>
int main( ){
int tam = 10, valor = 12;
printf("n==>%*d<== ==>%*d<==n", 5 , 12, 10, 1); // 5 posições para 12 ...
printf("n==>%*d<==n", tam , 12); // 10 posições para 12
printf("n==>%*d<==n", 20 , valor); // 20 posições para 12
return 0;
}
● Controle de espaço usado em tela.
● Um * (asterisco) entre % e a especificação de formato, indica que o
primeiro valor informado após a string de controle é o número de
posições que devem ser usadas para apresentar o valor seguinte.

Usando acentuação em C
● Para acentuar textos que são exibidos através do printf, de acordo
com as normas do Português, é necessário alterar o idioma.
● Usamos a função setlocale da biblioteca locale.h.
#include <stdio.h>
#include <locale.h> //necessário para usar setlocale
int main()
{
printf("Não é possível usar acentuação ou ç corretamente…nn");
printf("n****** Alterando para a localidade do sistema ********nn");
setlocale(LC_ALL,"");
printf("Agora não tem mais problema algum!n");
printf("Já posso usar acentuação e também o caracter ç…n");
return 0;
}

#include <stdio.h>
int main()
{
printf("Não é possível usar acentuação ou ç
corretamente…nn");
printf("n****** Alterando para a localidade do sistema
********nn");
printf("Agora não tem mais problema algum!n");
printf("Já posso usar acentuação e também o caracter ç…
n");
● Para acentuar textos que são exibidos através do printf, de acordo
com as normas do Português, é necessário alterar o idioma.
● Usamos a função setlocale da biblioteca locale.h.

● Em geral, usamos setlocale(LC_ALL,"") uma única
vez, no início do programa, antes de qualquer printf
ser executado.
#include <stdio.h>
int main()
{
…
return 0;
}

aula algoritmos e programação LinguagemC.pdf

Mais conteúdo relacionado

Semelhante a aula algoritmos e programação LinguagemC.pdf (20)

Último (20)

aula algoritmos e programação LinguagemC.pdf