02 Linguagem I 2007 02

Linguagem de
Programao I
Luciano L. Caimi
caimi@urisan.tche.br
URI Universidade Regional Integrada do Alto Uruguai e das Misses Linguagem de Programao I 2007/01
Terminologia e representao
Trecho ou exemplo de cdigo correto
Trecho ou exemplo de cdigo incorreto
Cronologia
BCPL
1967 Martin Richards
1970 Ken Thompson
1972 Dennis Ritchie

Padro ANSI C 1983
Homologado - 1989
Por muitos anos o livro, The C programming language de Brian Kernighan e Dennis
Ritche, editado em 1978, serviu de manual de referncia tanto para programadores como
desenvolvedores de compiladores da linguagem C, motivo pelo qual muitas pessoas,
erradamente, atribuem o desenvolvimento da linguagem a Brian Kernighan.
3
A Linguagem C
Caractersticas:
Linguagem de nvel mdio
Aproxima-se do assembly (manipulao de bits,
Tipos abstratos de dados
Linguagem estruturada
compartimenta o cdigo em subrotinas (procedimentos e
funes), permitindo o uso de variveis locais;

utiliza estruturas de repetio e controle (suporta
diretamente diversos tipos de laos e testes condicionais),
eliminando o uso do goto .
Linguagem compilada (normalmente)

Permite compilao separada
em programas com mltiplos arquivos basta recompilar
apenas o arquivo modificado e no todos os arquivos;
A Linguagem C
Caractersticas (continuao):
Linguagem de estilo livre
Formatao livre
#include <stdio.h>
Case sensitive
int main()
{
printf("Hello, world!\n");
return 0;
}
#include <stdio.h> int main(){printf("Hello, world!\n"); return 0;}

#include <stdio.h> int Main(){printf("Hello, world!\n"); return 0;}
Portabilidade garantida dentro do padro ANSI
Linguagem enxuta (apenas 32 palavras reservadas)
Transfere poder e consequentemente

responsabilidade
ao eprogramador;
URI Universidade
Regional Integrada do Alto Uruguai
das Misses Linguagem de Programao I 2007/01
Palavras Reservadas
auto
double
int
struct
break
else
long
switch
case
enum
register
typedef
char
extern
return
union
const
float
short
unsigned
continue
for
signed
void
default
goto
sizeof
volatile
do
if
static
while
Um Ol!
Comando para
pr-processador
Definies de bibliotecas
de entrada e sada
#include <stdio.h>
Funo main
retorna um
inteiro
Incio de
bloco
Final de
bloco
Nome da
funo main
int main()
Definio de
uma funo
{
return 0;
Chamada
}
Parmetro
para printf
funo printf
Termina a funo
main e retorna
valor 0
7
A Linguagem C
Comentrios:
/* .*/
/* Programa 1: Imprime Hello World! na tela

Autor: Dennis Ritchie */
/* Bibliotecas de funes chamadas */
#include <stdio.h>
/* Incio do programa */
int main()
{
return 0;
}
Autor: Dennis Ritchie */
#include <stdio.h>
// Este comentrio no est no padro ANSI C
int main(){
return 0;
}
8
A Linguagem C
Autor: Luciano L. Caimi */
#include <stdio.h>
/* incluso da biblioteca para: printf, gets, scanf */
#include <math.h>
/* incluso da biblioteca para: pow */
#define TAM 25
/* definindo constante TAM */
const double MY_PI = 3.1415916; /* definindo constante MY_PI */
float area(int raio); /* prottipo da funo rea */
int main(){
char buffer[TAM]; int aux; float result; /* declarao de variveis */
printf(\nEntre com o nome: );
gets(buffer);
/* leitura atravs de gets */
fflush(stdin);
/* limpa buffer de entrada */
printf(\nEntre com o raio: );
scanf(%d, &aux);
/* leitura atravs de scanf */
result = area(aux); /* chamada a funo rea */
return 0;
}
float area(int raio){ /* definio da funo rea */
float var;
/* declarao de varivel local */
var = MY_PI * pow(raio,2); /* chamada a funo pow de math.h */
return var;
/* retorna o valor calculado para quem chamou */
}
9
A Linguagem C
Blocos so delimitados por { e }

Declaraes de variveis somente so vlidas no incio
#include <stdio.h>
dos blocos
int main() {
int var_1, var_2, result_1, result_2;
result_1 = var_1 + var_2;
printf(soma:%d, result_1);
result_2 = var_1 - var_2;
printf(subtracao: %d, result_2);
return 0;
}
#include <stdio.h>
int main() {
int var_1, var_2, result_1;
result_1 = var_1 + var_2;
printf(soma:%d, result_1);
int result_2;
result_2 = var_1 - var_2;
printf(subtracao: %d, result_2);
return 0;
}
10
A Linguagem C
11
A funo main sempre a primeira a ser executada

(sendo obrigatria)
Pelo padro ANSI a funo main retorna um inteiro a
quem a chama: o sistema operacional no caso.
Quando o programador no especifica o tipo de
retorno de uma funo, normalmente o compilador
assume como int.
Grande maioria de comandos termina com ;
Tipos de Dados
tipo tamanho
char
1 byte
int
4 bytes
float
4 bytes
double 8 bytes
void
0 bytes
representao
ASCII
Complemento 2
IEEE 754
IEEE 754
faixa
-128 +127
-2147483648 +2147483647
-1 x 10-37 1 x 1037
-1 x 10-308 1 x 10308
#include <stdio.h>
int main() {
char aux_1 = '0', aux_2 = 65;
printf("\ncaracter aux_1: %c\ninteiro
printf("\n\ncaracter aux_2: %c\ninteiro
aux_1: %d", aux_1, aux_1);

aux_2: %d", aux_2, aux_2);
return 0;
}
12
Qualificadores de Tipos
short, long - para inteiros

short aux_1, aux_2 = 65;
long var_1 = -10;
long int var = 0;
unsigned, signed para inteiros

unsigned int aux_1;
signed int var = 100, var_1 = -5;
unsigned int x = -10;
unsigned - para char

unsigned char aux;
long para double

long double pi = 3.1415916;
13
Nomes de Identificadores
Utilizados para nomear variveis, funes,

constantes, rtulos, estruturas, etc;
Os identificadores em C devem comear com uma
letra ou _ (underline);
Os identificadores podem conter letras, nmeros ou
_ (underline);
As primeiras 31 letras so significativas
case sensitive;
Palavras reservadas no podem ser identificadores
int _aux, Meu_PI, meu_PI, contador2, contador_laco;
long variavel_com_o_nome_muito_longo;
double estas variaveis sao invalidas;
short 3_nomes, var-aux, lao, meu.PI, continue, smbolo;
14
Constantes
15
Qualquer valor que permanece inalterado ao longo da

execuo do programa
tipo
formato
inteiro
1345
inteiro long
1345L ou 1345l
inteiro sem sinal
1345u
inteiro long sem sinal
1345ul
inteiro hexadecimal
0x2A
inteiro octal
025
double
134.5 ou 1e-2
float
134.5f ou 134.5F ou 3e-2f
long double
134.5lf ou 5e3lf
caracter
a, 1
vetor
de caracteres
linguagem C
Constantes
As constantes caracter participam das operaes com

seus valores correspondentes da tabela ASCII.
Por exemplo o caracter 0 corresponde ao valor
numrico 48 e no 0.
Assim:
int X;
X = 0 + 5;
/* resultado: 53 */
- - - - - - - - - - - - - - - - - - - - - -
- - - - -
char var;
int unidades;
var = 48 + unidades; /* var recebe o caracter
ASCII correspondente a unidades */
16
Variveis
Formalmente uma varivel definida como uma

tupla composta de 6 atributos:
<nome, posio na memria, tipo, valor,
tempo de vida, escopo>
nome: identificador usado para referenciar a varivel;

posio na memria: endereo de memria que o compilador
aloca para a varivel;
tipo: tipo de dado. Define seu tamanho, faixa e codificao;
valor: valor armazenado na varivel em um determinado instante
tempo de vida: tempo que o endereo de memria permanece
vinculado a varivel;
escopo: espao/ambiente de referenciamento da varivel;
17
Variveis
18
Variveis precisam ser declaradas.

(No existe declarao implcita.)
A cada varivel associado um tipo, que determina os
valores possveis e as operaes que podem ser
executadas. Sintaxe:
<tipo> nome [= valor inicial];
Na declarao da varivel pode ser definido seu valor
inicial.
Variveis
<tipo> nome [= valor inicial];

char letra = A;
int x = 1, contador;
float var_1, var_2 = 12, var_3;
int aux;
double pi = 3.1415, raio;
Memria
[ ... ]
letra
x
contador
65
0
0
0
1
?
?
?
[000200]
[000201]
[000202]
[000203]
[000204]
[000205]
[000206]
[000207]
[ ... ]
19
Variveis
Onde so declaradas
Como parmetros de funes (varivel local):
int soma(int valor_1, int valor_2);
No incio de um bloco do programa (varivel local):

int main( ){
int aux;
for(x = 0; x < 10; x++){
float raio;
int auxiliar;
Fora de qualquer bloco de programa (varivel global):
20
#include <stdio.h>
int valor_1;
int main( ){
} Regional Integrada do Alto Uruguai e das Misses Linguagem de Programao I 2007/01

URI Universidade
Variveis
Vetores e matrizes: Vetores so usados para tratamento de

conjuntos de dados que possuem as mesmas caractersticas. Uma
das vantagens de usar vetores que o conjunto recebe um nome
comum e elementos deste conjunto so referenciados atravs de
ndices. Pelo nome vetor estaremos referenciando estruturas que
podem ter mais de uma dimenso, como por exemplo matrizes de
duas dimenses.
A forma geral da declarao de um vetor :
<tipo> nome [tamanho];
int vet[100];
/* vetor de 100 nmeros inteiros */
float notas[65]; /* vetor de 65 nmeros reais */
char nome[40];
/* vetor de 40 caracteres */
int mat_A[5][5]; /* matriz de 5x5. Total 25 elementos */
- - - - - - - - - - - - - - - - - - - - - - - - - - x = 3 * vet[2]; /* x recebe o triplo do valor em vet[2] */
vet[5] = Vet[3] + vet[4];
21
Variveis
De acordo com a especificao ANSI o tamanho de um

vetor deve ser estaticamente definido, ou seja, deve ser
uma constante. Desta forma, o cdigo abaixo invlido:
int tam;
/* escalar inteiro */
float notas[tam]; /* vetor de tamanho indefinido */
- - - - - - - - - - - - - - - - - - - - - - - - - - - int tamanho = 10;
...
float vet[tamanho] /* tamanho uma varivel */
22
Variveis
int vet[100];
armazena 100 nmeros inteiros. O primeiro elemento
est em vet[0] e o ltimo em vet[99].
importante notar que em C no h verificao de
limites em vetores. O exemplo abaixo no apresenta erro
de compilao, apenas de execuo:
x = 3 * vet[100]; /* Erro: no existe o elemento vet[100] */
vet[200] = cont;
23
/* Erro: no existe o elemento vet[200] */
O espao de memria, em bytes, ocupado por um vetor

igual a:
espao = tamanho * (nmero de bytes ocupado por tipo)
Variveis
float notas[3] = {8.5, 9.5, 7.0} ;
int cont = 0;
int mat[][] = {{1, 5},{-1, 10}};
Memria
[ ... ]
notas[0]
notas[1]
notas[2]
cont
mat[0][0]
mat[0][1]
mat[1][0]
mat[1][1]
8.5
9.5
7.0
0
1
5
-1
10
[000800]
[000804]
[000808]
[00080B]
[000810]
[000814]
[000818]
[00081B]
[ ... ]
24
Variveis
char disc[15] = linguagem I;
char nomes[][20] = { Fulano de Tal,
Memria [ ... ]
Beltrano S,
disc[0]
l
[000600]
Ciclano de P}
disc[1]
i
[000601]
disc[2]
disc[3]
disc[4]
disc[5]
disc[6]
disc[7]
disc[8]
disc[9]
disc[10]
disc[11]
disc[12]
disc[13]
disc[14]
25
n
g
u
a
g
e
m
I
\0
?
?
?
[000602]
[000603]
[000604]
[000605]
[000606]
[000607]
[000608]
[000609]
[000610]
[000611]
[000612]
[000613]
[000614]
Em C uma string um vetor

de caracteres terminado com
um caractere nulo, representado por \0.
O mesmo colocado
implicitamente pela
linguagem mas deve-se
reservar espao pra ele.
Variveis
Para os vetores de caracteres, no podemos fazer
atribuies diretas de constantes string, somente de
constantes caracter.
char disc[15] = linguagem I; /* Ok: inicializao */
...
disc[10] = 1; /* atribuio vlida */
disc = Arquitetura; /* atribuio invlida */
Para atribui uma constante string a um vetor de

caracteres devemos utilizar a funo strcpy da
biblioteca string.h.
char disc[15] = linguagem I; /* Ok: inicializao */;
...
strcpy(disc, Arquitetura); /* atribuio vlida */
26
Exemplos
int a;
/* a inteiro */
float x;
/* x de ponto flutuante, preciso simples */
double y; /* y de ponto flutuante, preciso dupla */
int b = 0; /* b inteiro, valor inicial 0 */
unsigned int m = 100;
/* m inteiro no-negativo */
long N = 1000000L;
/* N vale um milho */
short rodas = 4;
/* quatro rodas */
char letra = 'a';
/* letra a minscula */
double quase_pi = 3.14;
float quase_e = 2.7f;
/* note o f no final */
float quase_e_tambem = 2.7; /* tambm funciona */
double quase_c = 3e8;
/* O e indica expoente */
unsigned long degrau = 1ul; /* u: unsigned, l: long */
int aux, teste = 0, outro, mais_um = -8;
27
Funes Bsicas de E/S
C possui trs arquivos que so automaticamente

vinculados ao programa em execuo, utilizados como
buffer para as operaes de entrada e sada de dados do
programa:
stdin (conectado ao teclado)
stdout(conectado ao display)
stderr(conectado ao display)
28
Funes Bsicas de E/S
printf: imprime o texto na sada padro

formalmente:
int printf(char *, ...);
printf(expresso de controle, argumentos);
expresso de controle: formada pelo texto a ser impresso
juntamente com os comandos de controle;
argumentos: dados (variveis e constantes) a serem impressos;
printf(O caracter %c o primeiro do alfabeto., a);

printf(A data de hoje eh: %2d\\%2d\\%4d, dia, mes, ano);
printf("Raio: %f --> Area: %f\n", r, meu_pi*r*r);
29
printf
Cdigo
30
Imprimir
%c
Um nico caracter
%d
Decimal
%i
Decimal
%e
Ponto flutuante em notao cientfica
%f
Ponto flutuante
%g
mais curto entre %e e %f
%o
Octal
%s
String de caracteres
%u
Decimal sem sinal
%x
Hexadecimal
%%
Um sinal de %
%lf
double
printf
possvel controlar a quantidade mnima de smbolos a ser

apresentado no printf:
...
cont = 97;
printf(Contador = [%4d], cont );
Contador = [
Contador = [
Contador = [0097]
printf(Contador = [%-4d], cont );
Contador = [97
printf(Contador = [%8.4d], cont );
Contador = [
0097]
31
97]
97]
printf
32
Pode-se usar o controle do nmero de smbolos a ser

apresentado da seguinte maneira: %m.n<formato>
onde m o nmero mnimo de smbolos apresentados e
n tem seu comportamento definido conforme o formato.
%f, %lf
far arredondamento necessrio a fim de que

apaream n dgitos aps a vrgula, formatado num
espao de m caracteres;
%o, %i, %d, %u
preenche com q zeros esquerda do dado. Onde

q = n dgitos significativos do nmero formatados
no espao de m caracteres
%s
Imprimir somente os n primeiros caracteres

formatados no espao de m caracteres
%c
Sem efeito
printf
Valores em ponto flutuante so arredondados;

Colocando-se 0 ele preenche com zeros a esquerda:
%07d
Colocando-se ele faz alinhamento a esquerda: %-8f
...
int dist = 97;
float teste = 345.656;
char texto[20] = "testando tamanho";
33
printf("Resultado: [%10.2f]", teste);
Resultado: [
345.66]
printf("Resultado: [%10s]", texto);
Resultado: [testando tamanho]
printf("Resultado: [%10.5d]", dist);
Resultado: [
00097]
printf("Resultado: [%10.6s]", texto);
Resultado: [
testan]
printf("Resultado: [%-10.3s]",texto);
Resultado: [tes
Caracteres Especiais
Alguns caracteres especiais:
'\n': mudana de linha.

'\r': volta para comeo da linha.
'\b': volta um caracter.
'\\': caracter \
'\"': caracter
'\t': caracter TAB
Outros caracteres especiais podem ser inseridos com:

'\xNN', onde NN o cdigo hexadecimal do
caracter.
printf(\nS\xA1mbolo = \t[%c]",65);
Smbolo = [A]
34
Funes Bsicas de E/S
scanf: l dado na entrada padro (teclado)

int scanf(char *, ...);
formalmente:
scanf(expresso de controle, argumentos);
expresso de controle: determina como os dados sero lidos de
acordo com o especificador de formato;
argumentos: posio de memria onde o(s) valor(es) ser(o)
armazenado(s);
scanf(%c, &opcao);
/* l um char */
scanf(%f, &total);
/* l um float */
scanf(%d %d %d, &dia, &mes, &ano); /* l trs inteiros */
scanf(%lf, &raio);
/* l um double */
35
scanf
formato
36
Ler
%c
Um nico caracter
%d
Decimal
%i
Decimal
%e
Ponto flutuante em notao cientfica
%f
Ponto flutuante
%g
mais curto entre %e e %f
%o
Octal
%s
String de caracteres
%u
Decimal sem sinal
%x
Hexadecimal
%p
Ponteiro
#include <stdio.h>
Exemplo
int main() {
char Nome[50];
int Idade;
#include <stdio.h>
printf("Qual o seu primeiro nome? ");
scanf("%s",
Nome); {
int main()
printf("Qual a sua idade? ");
char Nome[50];
scanf("%d",
int&Idade);
Idade;
return 0; printf("Qual
#include
<stdio.h>
o seu
nome completo? ");
}
gets(Nome);
int main() {
fflush(stdin);
chara Nome[50];
printf("Qual
sua idade? ", &Idade);
int&Idade);
Idade;
scanf("%d",
printf("Qual o seu nome completo? ");
fflush(stdin);
return 0; scanf("%[a-z A-Z]", Nome);
fflush(stdin);
}
printf("Qual a sua idade? ", &Idade);
scanf("%d", &Idade);
fflush(stdin);
return 0;
37
Funes Bsicas de E/S
38
gets
getchar
puts
putchar
gets(char *);
getchar(char);
puts(char *);
putchar(char);
Operadores
Operadores determinam as operaes bsicas que

podem ser executadas nos valores.
Levam em considerao os tipos das variveis.
Em torno de 40 operadores.
Note que char pode ser usado em operaes
como se fosse um inteiro pequeno (8 bits).
H diversos tipos de operadores:
39
Atribuio
Atribuio Reduzida
Aritmticos
Lgicos
Condicionais
Bit a bit
Incremento e Decremento
Atribuio
Utiliza o sinal grfico `= para representao.

= significa `igual a
X = 80;
a = b = 20;
a = (b = 5) + 3;
3 = a;
40
/* vlido
*/
/* vlido
*/
/* Invlido */
Operadores Aritmticos
Realizam as operaes aritmticas bsicas.

Aplicveis a qualquer tipo de dado (exceto void).
Principais operadores aritmticos binrios:
41
Quando aplicado
a valores inteiros
devolve um
inteiro
Unrios
Soma: +
Subtrao: Produto: *
Diviso: /
Resto da diviso inteira: %
Sinal: Sinal: +
No h operador de potenciao.
Exemplos
int n = 10, d =
double x, y, z;
int i, j, k;
i = 25;
j = d + i;
k = i / n;
i = n % d;
x = 25; y = 10;
z = x / y;
42
7;
/* Vrgula separa declaraes de mesmo tipo */
/*
/*
/*
/*
/*
/*
Atribuio */
j recebe 32 */
k recebe 2 (diviso inteira) */
i muda para 3 */
Possvel: converte int -> double */
z recebe 2.5 */
Atribuio Reduzida
Uma operao pode ser combinada com a

atribuio em um mesmo operador:
+=, -=, *=, /=, %=, >>=, <<=, &=, |=, ^=
Assim:
a += b;
/* O mesmo que a = a + b */
c -= b*a;
/* O mesmo que c = c (b*a) */
d *= a - b; /* O mesmo que d = d * (a - b) */
43
Incremento e Decremento
C dispe de operadores de auto-incremento (++) e

auto-decremento (--).
Podem ser utilizados de maneira pr-fixada ou ps
fixada.
int n = 0, m = 0, a, b, c, d;
n++;
/* n agora vale 1 */
++m;
/* m agora vale 1 */
n--; --n;
/* n agora -1 */
a = n++;
/* a recebeu -1; n vale 0 */
b = ++m;
/* b recebeu 2; m vale 2 */
c = 2*(m++); /* c recebeu 4; m vale 3 */
d = 3*(++n); /* d recebeu 3; n vale 1 */
44
Operadores relacionais
45
Utilizados para comparar/relacionar dois operandos:

== (igual a)
!= (diferente de)
> (maior que)
< (menor que)
>= (maior ou igual a)
<= (menor ou igual a)
O resultado da avaliao ser sempre 0(falso) ou
1(verdadeiro)
Operadores relacionais
if (x >= 0)
printf(positivo");
else
printf(negativo");
Cuidado!!!
(x == 0)
46
if (x = 0)
printf(zero");
else
printf(no zero");
Operadores lgicos
Comportam-se como operadores booleanos:

&& (e) todos os operandos devem ser verdadeiros
para a sada ser verdadeira
|| (ou) ao menos um dos operandos deve ser
verdadeiro para a sada ser verdadeira
! (no) inverte o operando. Se era falso torna-se
verdadeiro e vice-versa
if (!aux)
printf(zero");
47
if (x >= 0 && x < 5)

printf("dentro");
else if (x < 0)
printf("muito pequeno");
else
printf("muito grande");
Operadores lgicos
C realiza avaliao curto-circuito:

Avaliao curto circuito de uma expresso uma avaliao onde o
resultado da expresso pode ser determinado avaliando-se apenas
alguns de seus operandos, obtendo-se o mesmo valor caso a
expresso seja avaliada por completo.
O propsito de uma avaliao curto circuito dar eficincia, em
tempo de execuo. A execuo ser mais rpida pois na
avaliao da expresso alguns operandos no sero avaliados.
Cuidado com efeitos colaterais.
aux = 20; val = 40

if (aux > 0 || val > 0)
printf(curto-curcuito");
48
Operadores bit a bit
49
Realizam operaes booleanas bit a bit sobre nmeros

inteiros:
& (and)
| (or)
^ (xor)
~ (complemento)
>> (deslocamento a direita)
<< (deslocamento a esquerda)
A operao realizada sobre o valor expresso em
binrio;
Operadores bit a bit

Expresso
1|2
0xFF & 0x0F
0x0D << 2
0x1C >> 1
~0x03
3^2
50
Em binrios
00000001 | 00000010
11111111 & 00001111
00001101 << 2
00011100 >> 1
~(00000011)
00000011 ^ 00000010
Resultado
00000011 = 0X03 = 3
00001111 = 0x0F = 15
00110100 = 0x34 = 52
00001110 = 0x0E = 14
11111100 = 0xFC = 252
00000001 = 0X01 = 1
Operador Sizeof
Este operador retorna o tamanho da varivel ou tipo

que est em seu operando.
Por exemplo:
float area;
int idades[10];
printf(Um inteiro ocupa %d bytes de memria, sizeof(int));
printf(Um float ocupa %d bytes de memria, sizeof area);
printf(O vetor \idades\ ocupa %d bytes de memria, sizeof idades);
51
Precedncia e Associatividade
52
Diversos operadores podem ser utilizados na mesma

expresso.
A ordem de execuo dos operadores pode ser
determinada explicitamente pelo uso de parntesis.
Quando no so usados parntesis, o compilador usa
regras de precedncia para determinar qual operao
executar primeiro.
Se duas operaes tm a mesma precedncia,
executa de acordo com regra de associatividade
(normalmente da esquerda para a direita).
Precedncia e Associatividade
Maior precedncia
( )
[ ]
->
! ~ ++ -- . -(unrio) (cast) *(unrio) &(unrio) sizeof

* / %
+ << >>
<<= >>=
== !=
&
^
|
&&
||
?
= += -= *= /=
Menor precedncia
53
Exemplos
a
d
e
f
g
f
a
54
=
=
=
=
=
=
=
b + c; /* Atribuio tem menor precedncia que soma */

(a + b) * c;
/* Determinada pelos parntesis */
a + b * c;
/* * tem maior precedncia que + */
a + b c;
/* (a + b) c */
f/e*g;
/* (f/e)*g */
a + b * c d / e; /* (a + (b*c)) (d/e) */
b = c = d = 0;
/* (a = (b = (c = (d = 0)))) */
Converses de tipos
55
C realiza avaliao de expresses em modo misto.

Em outras palavras a linguagem permite que as
expresses contenham operandos de tipos diferentes,
realizando de maneira automtica a converso de tipos.
A converso realizada em C sempre uma converso de
alargamento, ou seja, o tipo menor convertido para um
tipo maior.
Nem todas as converses automticas so possveis,
neste caso o compilador apresenta mensagens de erro
descrevendo o problema.
Converses de tipos
Se as converses forem possveis ele as faz,

seguindo as regras abaixo:
Todos os chars e short so convertidos para int. Todos os float
so convertidos para double.
Para pares de operandos de tipos diferentes: se um deles
long double o outro convertido para long double; se um deles
double o outro convertido para double; se um long o outro
convertido para long; se um unsigned o outro convertido
para unsigned.
56
Exemplos
int n = 10, d =
double x, y, z;
int i, j, k;
i = 25;
x = d + i;
k = i / n;
k = x / n;
x = 25; y = 10;
z = x / y;
j = z + y;
57
7;
/* Vrgula separa declaraes de mesmo tipo */
/*
/*
/*
/*
/*
/*
/*
Atribuio */
x recebe 32.0*/
k recebe 2.0 (diviso inteira) */
k recebe 3.2 */
x recebe 25.0 y recebe 10.0*/
z recebe 2.5 */
j muda para 12 (converso) */
Converses de tipos
Cast
Um cast (modelador) aplicado a uma expresso. Ele fora a
mesma a ser de um tipo especificado. Sua forma geral :
(tipo)expresso
#include <stdio.h>
int main () {
int num;
float f;
num = 10;
f = (float) num / 7;
printf ("%f", f);
return 0;
}
58
Constantes
Constantes podem ser definidas de duas

formas:
Utilizando o comando #define do pr-processador.
Utilizando a palavra-chave const na declarao.
#define MY_PI 3.1415
...
area = raio * MY_PI * MY_PI;
const float MY_PI = 3.1415;

...
area = raio * MY_PI * MY_PI;
59
Estruturas de Deciso
Permitir testes para decidir aes

alternativas:
60
if else
if else if else
switch
(?:) Operador Condicional
if - else
Comandos podem ser executados condicionalmente

utilizando a construo if - else.
if (condio)
comando;
else
comando;
Condio
Parntesis so
necessrios
if (saldo > 0)
printf("credor");
else
printf("devedor");
Comando a executar
se condio for
verdadeira
Comando a executar
se condio for falsa
61
if - else
O if pode ocorrer sem o correspondente else, caso

em que, se a condio for falsa, nada ser executado.
if (x < 0)
x = -x;
Quando mais de uma instruo deve ser executada

dentro do if ou do else, utilizamos chaves { } para
delimitar o bloco.
if (x < 0) {
printf(O valor de x negativo: %d, x);
x = -x;
printf(Agora positivo: %d, x);
}
62
if else
O else corresponde sempre ao ultimo if encontrado.

Usar chaves quando desejar outra associao
if (n > 0)
if(a > b)
z = a;
else
z = b;
63
if (n > 0) {
if(a > b)
z = a;
}
else
z = b;
if else if - else
64
Comandos de deciso mltipla.

if (condio)
comando;
else if (condio)
comando;
else if (condio)
comando;
else
comando;
if else if - else
printf(Entre com o conceito: );
scanf(%c, &let_nota); fflush(stdin);
if (let_nota == A)
printf("A nota est entre 9,0 e 10,0\n");
else if (let_nota == B)
else if (let_nota == C)
else if (let_nota == D)
printf("Como voc vai explicar essa\n");
else {
printf("Claro que no tive nada a ver com
isso.\n");
65
printf("Deve ter sido culpa do professor.\n");
if else
Exerccios:
1) Implemente um programa que leia 3 inteiros no teclado, ordene-os e mostre
em ordem crescente na tela;
2) A taxa de juros aplicada em fundos depositados em um banco determinada
pelo tempo em que estes ficam depositados. Para um banco em particular, a
seguinte tabela usada:
Tempo em depsito
Taxa de juro
Maior ou igual a 5 anos
0,095
Menor que 5 anos mas maior ou igual a 4 anos 0,09
Menor que 2 anos mas maior ou igual a 1 ano
0,065
Menor que 1 ano
0,055
Usando esta informao, escreva um programa em C que leia o tempo os fundos
so mantidos em depsito e informe a taxa de juros correspondente.
66
Operador ? :
Forma compacta de expressar uma instruo if else

(condio) ? expresso1 : expresso2;
max =
(num1 > num2) ? num1 : num2;
equivalente:
if (num1 > num2)
max = num1;
else
max = num2;
Exemplo:
ABS = (num < 0) ? - num : num;
67
Comando Switch
switch <varivel> {
case <constante 1> :
<comandos>;
[break;]
<comandos>;
[break;]
<comandos>;
[break;]
[default :
<comandos>;]
}
68
<varivel> deve ser uma
varivel do tipo int ou char;
break serve para terminar a

seqncia de comandos em
execuo, por serem opcionais,
se forem suprimidos permitem
que o case a seguir seja
executado, sem haver qualquer
quebra na seqncia do
processamento.
switch
printf ("\nEscolha uma opo: ");
scanf ("%d", &opcao);
switch (opcao) {
case 1:
printf ("Opcao 1 foi digitada.\n");
case 2:
printf ("opcao 2 foi digitada\n");
break;
case 3:
printf("opcao 3 foi digitada\n");
break;
case 4:
printf("opcao 4 foi digitada\n");
break;
default:
printf("opcao Invlida\n");
}
69
Estruturas de Repetio
Permitir repetio da execuo do cdigo que

se encontra dentro do bloco:
for
while
do - while
70
Comando for
Forma geral.
for(inicializao; expresso teste; atualizao)
comando;
Interpretao: realize a inicializao e ento repita o

comando enquanto a expresso teste for verdadeira,
atualizando ao final de cada interao
#include <stdio.h>
int main ( ){
int numero;
for(numero = 0; numero < 10;
printf ( %d, numero);
return 0;
numero +=
2 )
}
71
Comando for
Qualquer uma das parter do lao pode ser omitida (ou

mesmo todas elas): for ( ; ; ) lao infinito
Qualquer uma das partes pode ser composta de mais
de uma expresso:
for(x = 0, y = 15;
....
72
y > 0; y--, x +=2)
Cuidado com:
for(x = 0; x < 1000; x++);
pois um lao vazio
Um comando break encerra a execuo do lao;
Um comando continue encerra a interao corrente do
lao;
break - continue
int main(){
int x;
for(x = 10; x > 0; x--){
if(x == 3)
break;
if(x == 7)
continue;
printf("\nValor de X: %d\n",
x);
}
printf("\nEncerrou laco com x valendo %d\n", x);
return 0;
}
73
for
Exerccios:
1) Implemente um programa em C que leia 5 inteiros no teclado, e
informe na sada qual o maior e qual o menor;
2) Faa um programa em C que mostre a tabela ASCII para a faixa
de valores entre 32 e 255, no seguinte formato:
valor smbolo
32
?
...
valor smbolo
33
?
valor smbolo
34
?
valor smbolo
35
?
3) Implemente dois programas em C usando laos for que gere as

seguintes sadas:
a)****
b)
######
****
######
****
######
****
######
74
Comando while
Forma geral.
while(expresso teste)
comando;
Interpretao: enquanto a expresso teste for

verdadeira repita o comando (pr-testado).
#include <stdio.h>
#include <stdio.h>
int main ( ){
int main ( ){
int numero = 0;
char tecla = \0;
while(numero < 100){
printf(Nmero: %d, numero);
while(tecla != q)
numero++;
tecla = getch();
}
return 0;
return 0;
}
}
75
Comando while
76
Cuidado com:
while( x < 1000);
pois um lao vazio;
Um comando break encerra a execuo do lao;
Um comando continue encerra a interao corrente do
lao;
#include <stdio.h>
int main ( ){
int numero = 1;
while(numero < 10){
if(numero > 5){
numero++;
continue;
}
printf(\nNmero: %d, numero);
numero++;
}
printf(\nNmero Final: %d, numero);
return 0;
}
Comando do-while
Forma geral.
do
comando;
while(expresso teste);
77
Interpretao: repita o comando enquanto a expresso

teste for verdadeira (ps-testado).
Comando do-while
#include <stdio.h>
int main( ) {
char opcao;
do{
printf(\n\n\t\t\tMenu Principal\n\n\n);
printf(\t\t[1] - Instrucoes\n\n);
printf(\t\t[2] - Inserir Funcionario\n\n);
printf(\t\t[3] - Alterar Funcionario\n\n);
printf(\t\t[4] - Excluir Funcionario\n\n);
printf(\t\t[5] - Pesquisa\n\n);
printf(\t\t[6] - Sair\n\n);
printf(\t\t\tOpcao [ ]\b\b);
do
opcao = getch( );
while(opcao < 1 || opcao > 6);
} while(opcao != 6);
return(0);
}
78
Diretivas de Pr-Processamento
A linguagem C oferece mecanismos que permitem

manter definies unificadas que so compartilhadas
entre diversos arquivos.
A base destes mecanismos o pr-processamento de
cdigo,
a primeira
fase
na compilao
do programa.
As diretivas
do C so identificadas
por comearem por
#. As diretivas
que estudaremos so definidas
pelo padro ANSI:
Essencialmente, o pr-processador um processador
de macros para uma linguagem de alto nvel.
As diretivas do C so identificadas por comearem
por #. Algumas das diretivas definidas pelo padro
ANSI so:
#include
#define #undef
#if
#ifndef
#ifdef
#endif
#else
#elif
79
#include
diz ao compilador para incluir, na hora da
compilao, um arquivo especificado. Sua forma
geral :
As diretivas do C so identificadas por comearem por #. As diretivas que estudaremos so definidas pelo padro ANSI:
#include <nome_do_arquivo>
ou
#include caminho_e_nome_do_arquivo"
A primeira utilizada para bibliotecas da linguagem e

a segunda para incluso arquivos de cabealho
80
#define
#define nome_da_macro sequncia_de_caracteres
Quando voc usa esta diretiva, voc est dizendo ao

compilador para que, toda vez que ele encontrar o
nome_da_macro no programa a ser compilado, ele deve
substitu-lo pela sequncia_de_caracteres fornecida.
Um outro uso da diretiva #define o de simplesmente
definir uma macro.
#define nome_da_macro
81
Neste caso o objetivo estamos definindo uma macro

para ser usada como uma espcie de flag. Isto quer dizer
que estamos definindo um valor como sendo
"verdadeiro"
para depois podermos test-lo.
Tambm possvel definir macros com argumentos.

#define max(A,B) ((A>B) ? (A):(B))
#define min(A,B) ((A<B) ? (A):(B))
...
x = max(i,j);
y = min(t,r);
Embora parea uma chamada de funo, o uso de max

(ou min) simplesmente substitui, em tempo de
compilao, o cdigo especificado.
Cada ocorrncia de um parmetro formal (A ou B, na
definio) ser substitudo pelo argumento real
correspondente.
x = ((i>j) ? (i):(j));
y = ((i<j) ? (i):(j));
82
Cuidado com as macros com argumentos.

Exemplo 1
x = max(p++,r++);
/* x = ((p++ > r++) ? (p++):(r++)) */
Exemplo 2
#define dobro(X) X*X
...
y = dobro(y+z)
/* y = a+b*a+b y = (a*b) + a + b */
Quando voc utiliza a diretiva #define nunca deve haver

espaos em branco no identificador:
#define PRINT (i) printf( %d \n", i)
/* no funcionar corretamente */
83
Diretivas de compilao condicional: Elas so muito

parecidas com os comandos de execuo condicional do
C. As duas primeiras diretivas so as #ifdef e #endif.
Suas formas gerais so:
#ifdef nome_da_macro
sequncia_de_declaraes
#endif
A seqncia de declaraes ser compilada apenas se o

nome da macro estiver definido.
#define PORT_0 0x378
...
/* Linhas de codigo qualquer... */
...
#ifdef PORT_0
#define PORTA PORT_0
#include "../sys/port.h
#endif
84
A diretiva #ifndef funciona ao contrrio da diretiva

#ifdef. Sua forma geral :
#ifndef nome_da_macro
sequncia_de_declaraes
#endif
A seqncia de declaraes ser compilada se o nome

da macro no tiver sido definido
#ifndef PORT_0
#include "../sys/port.h
#endif
85
As diretiva #if, #else e #elif funcionan respectivamente

como o if, else e else if. Observe o exemplo:
#define SISTEMA DOS
...
/*linhas de codigo..*/
...
#if SISTEMA == DOS
#define CABECALHO "dos_io.h
#else
#define CABECALHO "unix_io.h
#endif
#include CABECALHO
86
Funes Matemticas
Algumas funes matemticas de math.h:
87
Trigonomtricas: sin, cos, tan, asin, acos, atan,

atan2.
Relacionadas a exponencial: exp, pow, sqrt, log,
log10, sinh, cosh, tanh.
Outras: fabs, ceil, floor, fmod.
Exemplo
#include<stdio.h>
#include<math.h>
int main()
{
double Total, j, m;
int n;
printf("Valor do bem:
");
scanf("%lf", &Total);
printf("Taxa de juros anual (em %%): ");
scanf("%lf", &j); j /= 100*12;
printf("Numero de meses:
");
scanf("%d", &n);
m = Total * j / (pow(1+j,n) - 1);
printf("Investimento mensal:
%.2f", m);
return 0;
}
88
Bibliografia
89
SEBESTA, R. W. Conceitos de Linguagem de

Programao. 4 ed. Porto Alegre: Bookman
Companhia Ed. 2000.
KERNIGHAM, Brian W. & RITCHIE, Dennis
M. C: A Linguagem de Programao. Rio de
Janeiro: Ed. Campus. 1986.
SCHILDT, Herbert. C Completo e Total. 3.
Ed. So Paulo: Makron Books. 1996.
Apostilas e sites da Internet

02 Linguagem I 2007 02

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

02 Linguagem I 2007 02

Загружено:

Авторское право:

Доступные форматы

Linguagem de

1967 Martin Richards

1970 Ken Thompson

1972 Dennis Ritchie

funes), permitindo o uso de variveis locais;

Linguagem compilada (normalmente)

apenas o arquivo modificado e no todos os arquivos;

#include <stdio.h> int main(){printf("Hello, world!\n"); return 0;}

Portabilidade garantida dentro do padro ANSI

Linguagem enxuta (apenas 32 palavras reservadas)

Transfere poder e consequentemente

/* Programa 1: Imprime Hello World! na tela

Blocos so delimitados por { e }

A funo main sempre a primeira a ser executada

aux_1: %d", aux_1, aux_1);

short, long - para inteiros

unsigned, signed para inteiros

unsigned - para char

long para double

Utilizados para nomear variveis, funes,

Qualquer valor que permanece inalterado ao longo da

As constantes caracter participam das operaes com

Formalmente uma varivel definida como uma

nome: identificador usado para referenciar a varivel;

Variveis precisam ser declaradas.

<tipo> nome [= valor inicial];

No incio de um bloco do programa (varivel local):

for(x = 0; x < 10; x++){

Fora de qualquer bloco de programa (varivel global):

} Regional Integrada do Alto Uruguai e das Misses Linguagem de Programao I 2007/01

Vetores e matrizes: Vetores so usados para tratamento de

De acordo com a especificao ANSI o tamanho de um

/* Erro: no existe o elemento vet[200] */

O espao de memria, em bytes, ocupado por um vetor

Em C uma string um vetor

Para atribui uma constante string a um vetor de

Funes Bsicas de E/S

C possui trs arquivos que so automaticamente

Funes Bsicas de E/S

printf: imprime o texto na sada padro

printf(O caracter %c o primeiro do alfabeto., a);

Ponto flutuante em notao cientfica

mais curto entre %e e %f

Decimal sem sinal

possvel controlar a quantidade mnima de smbolos a ser

printf(Contador = [%8d], cont );

printf(Contador = [%04d], cont );

printf(Contador = [%-4d], cont );

printf(Contador = [%8.4d], cont );

Pode-se usar o controle do nmero de smbolos a ser

far arredondamento necessrio a fim de que

%o, %i, %d, %u

preenche com q zeros esquerda do dado. Onde

Imprimir somente os n primeiros caracteres

Valores em ponto flutuante so arredondados;

printf("Resultado: [%10.2f]", teste);

printf("Resultado: [%10s]", texto);

Resultado: [testando tamanho]

printf("Resultado: [%10.5d]", dist);

printf("Resultado: [%10.6s]", texto);

Alguns caracteres especiais:

'\n': mudana de linha.

Outros caracteres especiais podem ser inseridos com: