2DA
2NA
Datas Importantes Datas Importantes
22 de Fevereiro
29 de Fevereiro
14 de Março
21 de Março
28 de Março
4 de Abril
11 de Abril
18 de Abril
25 de Abril
02 de Maio
9 de Maio
16 de Maio
23 de Maio
30 de Maio
06 de Junho
13 de Junho
20 de Junho
27 de Junho
Programação
23 de Fevereiro
01 de Março
15 de Março
22 de Março
29 de Março
5 de Abril
12 de Abril
19 de Abril
26 de Abril
03 de Maio
10 de Maio
17 de Maio
24 de Maio
31 de Maio
07 de Junho
14 de Junho
21 de Junho
28 de Junho
1. Apresentação do Curso
2. Introdução
3. Operadores e AP
4. Laços e AP
5. Comandos de Decisão e AP
6. Funções e AP
7. Macros
8. AP
9. 1a. Prova e Entrega do 1o.TP
10. Matrizes e Strings
11. Métodos de Ordenação
12. Métodos de Ordenação
13. AP
14. Estruturas
15. AP
16. Arquivos
17. AP
18. 2a.Prova
02 de Agosto
09 de Agosto
16 de Agosto
23 de Agosto
30 de Agosto
06 de Setembro
13 de Setembro
20 de Setembro
27 de Setembro
04 de Outubro
11 de Outubro
18 de Outubro
25 de Outubro
01 de Novembro
08 de Novembro
22 de Novembro
29 de Novembro
1.
2.
3.
4.
5.
6.
7.
2o. Semestre
01 de Agosto
08 de Agosto
15 de Agosto
22 de Agosto
29 de Agosto
05 de Setembro
12 de Setembro
19 de Setembro
26 de Setembro
03 de Outubo
10 de Outubro
17 de Outubro
24 de Outubro
31 de Outubro
07 de Novembro
14,21 de Novembro
28 de Novembro
Ponteiros
Ponteiros e AP
Ponteiros e AP
Introdução
Listas
Listas
Pilhas
8. Pilhas
9. 3a.Prova e Entrega 2o. TP
10. Filas
11. Filas
12. AP
13.Pesq.em Memória Principal
14.Arvores Binárias
15.Hashing
16. Pesq. em Memória Secundaria
17. 4a prova
Laços
• Laço
for
•Laço while
•Laço do-while
•Os Comandos
break e Continue
•O Comando goto
Laço for
Sintaxe :
for(inicialização;teste;incremento)
• As três expressões acima,
podem ser compostas por
qualquer expressão válida em C.
Ex.:
main( )
{
int conta;
for( conta=0;conta<10;conta++)
printf(“conta=%d\n”, conta);
}
Laço for
Sintaxe :
for(inicialização;teste;incremento)
• No exemplo anterior, usamos a
forma mais simples para as três
expressões do laço for. Qualquer uma
das expressões do laço pode conter
várias instruções separadas por
vírgula.
Ex.:
main( )
{
int x,y;
for ( x=0, y=0; x+y<100; x+=1, y+=1)
printf(“x+y=%d\n”, x+y);
}
Laço for Aninhado
Quando um laço esta dentro de outro laço,
dizemos que o laço interior está aninhado
Ex.:
main( )
{
int i, j, k;
printf (“\n”);
for ( k=0; k<=1; k++) {
printf ( “\n”);
for (i=1; i<5; i++)
printf (“Tabuada do %3d”, i+4*k+1);
printf (“\n”);
for ( i=1; i<=9; i++) {
for ( j=2+4*k; j<=5+4*k; j++)
printf (“%3d x %3d = %3d “ , j, i, j*i);
printf (“\n”);
}
}
}
Laço for Aninhado
Saída do Programa:
Tabuada do 2
Tabuada do 3 ...
2x1=2
3x1=3
...
2x2=4
3x2=6
...
2x3=6
3x3=9
...
2x4=8
3 x 4 = 12
...
.
.
.
.
.
.
Tabuada do 6
Tabuada do 7 ...
6x1=6
6 x 2 = 12
.
.
.
7x1=7
7 x 2 = 14
.
.
.
...
...
Laço while
Sintaxe: while ( expressão de teste )
instrução;
Se a expressão de teste for
verdadeira ( diferente de zero ), as
instruções são executadas uma vez e a
expressão de teste é validada
novamente.
Ex.:
main ( )
{
int conta=0;
int total=0;
while ( conta < 10 ) {
total += conta;
printf (“conta=%d,
total=%d\n”, conta++, total );
}
}
Laço while
Sintaxe: while ( expressão de teste )
instrução;
Saída :
conta=0 , total =0
conta=1 , total =1
conta=2 , total =3
conta=3 , total =6
conta=4 , total =10
conta=5 , total =15
conta=6 , total =21
conta=7 , total =28
conta=8 , total =36
conta=9 , total =45
Laço while aninhado
Ex.:
main ( )
{
int num;
long resposta;
while (1) {
printf (“\n Digite o numero: “);
scanf ( “%d”, &num);
resposta=1;
while ( num >1)
resposta*=num--;
printf (“O fatorial é: %ld\n”,resposta);
}
}
Laço do-while
Sintaxe: do {
instrução;
} while (expressão de teste);
Neste laço a expressão de validação se encontra
após as instruções, o que significa que estas
serão executadas pelo menos uma vez.
Ex.:
main ( )
{
int num;
long resposta;
do {
printf (“\nDigite o numero:”);
scanf (“%d”, &num);
resposta=1;
while (num >1 )
resposta *= num--;
printf (“O fatorial é: %ld\n”, resposta);
} while ( 1 ) ;
}
Comando break e continue
O comando break é usado em qualquer
estrutura de Laço C para interromper
sua execução.
Ex.:
main ( )
{
int num;
long resposta;
while ( 1 ) {
printf (“\nDigite o numero:”);
scanf (“%d”, &num);
resposta=1;
while (num >1 )
resposta *= num--;
printf (“O fatorial é: %ld\n”, resposta);
break
}
}
Comando break e continue
O comando “continue” força a próxima
interação do laço e pula o código que
estiver abaixo.
Comando goto
goto parte 1; // rotulo
parte1:
printf ( “Análise dos Resultados\n”);
não é muito recomendável a utilização
de goto em programas.
Comandos
de Decisões
•O
Comando if
•Comando if-else
•Operadores Lógicos
||&&!
•O Comando else-if
•O Comando switch
•O Operador Condicional
Ternário ? :
Comando if
O comando if é usado em decisões simples
Sintaxe:
if ( expressão de teste )
instrução;
Ex.:
main ( )
{
char ch;
ch = getche ( );
if ( ch == ‘ p’)
printf (“\n Você Digitou a Tecla %c.”, ch);
}
Resultado:
Você Digitou a Tecla p.
Comando if aninhado
O comando if pode estar dentro de outro
comando if. Dizemos então que o if interno
está aninhado.
Ex.:
main ( )
{
char ch;
printf (“\n Digite uma letra de ‘a’ a ‘z’:”);
ch = getche ( );
if ( ch >= “a”)
if ( ch <= “z”)
printf (“\n Você Digitou certo”);
}
Comando if-else
Nos exemplos anteriores o comando if
executará uma única instrução ou um grupo de
instruções, se a expressão de teste for
verdadeira. Não fará nada se a expressão for
falsa.
O comando else associado ao if, executará um
grupo de instruções, se a expressão de teste for
falsa.
Ex.:
main ( )
{
char ch;
ch = getche ( );
if ( ch == “p”)
printf (“\n Você Digitou certo”);
else
printf (“\n Você não precionol a tecla p.”);
}
Comandos if-else aninhados
Nos exemplos anteriores o comando if
executará uma única instrução ou um grupo de
instruções, se a expressão de teste for
verdadeira. Não fará nada se a expressão for
falsa.
Ex.:
main ( )
{
int x,y;
for (y=1;y<24;y++)
{
for (x=1;x<24;x++)
if (x==y)
printf (“\xDB”);
else if (x==24-y)
printf (“\xDB”);
else
printf (“\xBO);
printf (“\n”);
}
}
Operadores Lógicos
A linguagem C oferece 3 operadores chamados
lógicos:
&& lógico E
||
lógico OU
!
Lógico de negação
Operadores lógicos são aplicados a expressões
relacionais.
Se EXP1 e EXP2 são duas expressões simples,
então:
EXP1 && EXP2 é verdadeiro se as duas
expressões forem TRUE.
EXP1 | | EXP2 é verdadeiro se apenas uma
das duas for verdadeira.
! EXP1 é verdadeira se EXP1 for falsa e
vice-versa.
Ex.:
main ( )
{
int x,y;
for (y=1;y<24;y++)
{
for (x=1;x<24;x++)
if (x==y | | x==24-y)
printf (“\xDB”);
else printf (“\xBO”);
printf (“\n”);
}
}
Operadores
Precedências
Operadores
Tipos
! - ++ -* / %
+ < > <= >=
== !=
&&
||
= += -= *= /= %=
unários; não lógicos
aritméticos
aritméticos
relacionais
relacionais
lógico E
lógico OU
aritméticos atribuição
Comando else-if
Utilizamos o comando else-if quando desejamos
realizar um série de testes aninhados.
Ex.:
main ( )
{
char ch;
ch = getche ( );
if ( ch == “p”)
printf (“\n Você Digitou a letra p.”);
else
if ( ch == “m”)
printf (“\n Você Digitou a tecla m.”);
}
Comando break
associado ao if
Utilizamos o comando break quando ocorre
uma condição repentina onde é necessário
deixar o laço antes da expressão do laço se
torna falsa.
Ex.:
main ( )
{
char ch=“”;
while ( ch != “q”) {
ch = getche ( );
if ( ch == “p”) {
printf (“\n Você Digitou a letra p.”);
break;
}
else
if ( ch == “m”)
printf (“\n Você Digitou a tecla m.”);
}
Comando switch
Similar ao else-if mas tem maior flexibilidade
e formato limpo e claro.
Sintaxe :
switch ( expressão constante)
case constante1:
instruções;
break;
case constante2:
instruções;
break;
....
default :
instruções;
Comando switch
main ( ) {
float num1, num2;
char op;
while(1) {
printf ( “Digite um num., operador, numer\n”);
scanf (“%f %c %f”,&num1,&op,&num2);
switch (op) {
case ‘+’:
printf (“ =%f”, num1+num2);
break;
case ‘-’:
printf (“ =%f”, num1-num2);
break;
case ‘*’:
case ‘x’:
printf (“ =%f”, num1*num2);
break;
case: ‘/’:
case ‘\’:
printf (“=%f”, num1/num2);
break;
default:
printf (“ Operador Desconhecido”);
}
printf (“\n\n”);
}
}
Operador Condicional
Ternário ?:
Sintaxe:
Ex.:
condição ? Expr1 : Expr2
max = ( Num1 > Num2) ? Num1 : Num2;
esta expressão é equivalente a:
if ( Num1 > Num2)
max= Num1;
else
max=Num2;
Funções
• Funções
e Estruturas de
um Programa
•Funções que retoram um
Valor
•Argumentos chamada por
Valor
•Funções Recursivas
Funções e Estruturas de um
Programa
• Dividem grandes tarefas de computação em
tarefas menores;
• Geram reaproveitamento de código;
• Unidade de código de programa autônoma;
• A programação em “C”geralmente consiste
em várias pequenas funções;
• Minimiza a duplicidade de códigos ;
Funções Simples
São funções que não recebem e nem geram
parâmetros.
Ex.:
int linha( );
main ( )
{
linha( );
printf(“\xDB Um Programa em C \xDB\n”);
linha ( );
}
linha ( )
{
int j;
for (j=1;j<=20;j++)
printf(“\xDB”);
printf(“\n”);
}
Estruturas das Funções em C
São funções que têm a forma semelhante a da
função main ( ):
Sintaxe:
retorno nome da função (argumentos)
{
Lista de Comandos;
...
}
onde : retorno = tipo da variável de retorno
nome da função = nome representativo
argumentos = parâmetros da função
lista de comandos = instruções
Chamando Funções em C
Do mesmo modo que chamamos uma função
de uma biblioteca C (printf ( ) , scanf ( ),
getch ( ) , etc ) chamamos nossas próprias
funções como linha ( ).
Ex.:
...
linha ( );
...
Variáveis Locais em C
Cada função pode chamar outras funções. A
função linha ( ) chama a função printf ( ) e a
função main ( ) chama linha ( ), scanf ( ) e
getch ( ) .
As variáveis que são declaradas dentro de uma
função são chamadas de variáveis locais e são
conhecidas somente dentro de seu próprio
bloco.
Variáveis locais existem apenas durante a
execução do bloco de código onde estão
declaradas.
A variável j criada na função linha ( ) é
conhecida somente em linha ( ); e é invisível
à função main ( ).
Funções que retornam
um Valor em C
Você já usou uma função deste tipo, getche ( )
que devolve, à função que chama, o valor do
primeiro caracter pressionado no teclado.
O próximo programa cria uma função que lê
um caracter do teclado e, se for maiúsculo,
converte-o em minúsculo.
char minusculo ( );
main ( )
{ char ch;
printf (“Digite ‘a’ e depois ‘b’:”);
ch=minusculo( );
printf (“\n Você pressionou %c.”,ch);
}
char minusculo ( )
{ char ch;
ch=geche( );
if (ch >=‘A’ && ch <=‘Z’)
ch+=‘a’-’A’;
return ( ch );
}
O Comando Return ( )
O comando return causa a atribuição de
qualquer expressão entre parênteses à função
contendo o return.
A variável ch é local a minúsculo, mas
o valor de ch é mandado para main ( ) pelo
comando return. E este valor pode ser
atribuido a uma variável, como no nosso
exemplo, ou fazer parte de alguma expressão.
char minusculo( );
main ( )
{ char ch;
printf (“Digite ‘a’ e depois ‘b’:”);
ch=minusculo( );
printf (“\n Você pressionou %c.”,ch);
}
Entretanto existem limitações para o return
pois este comando pode retornar somente um
único valor.
Passando dados à função
Chamada.
O mecanismo usado para transmitir
informações à uma função é chamado
argumento.
Nós já utilizamos argumentos nas
funções printf ( ) e scanf ( ).
int abs ( x );
main ( )
{ printf (“%d %d %d\n”,abs(0), abs(-3),
abs(10) );
}
abs ( x )
int x;
{
return( (x<0)? -x:x);
}
ou
abs ( int x )
{
return( (x<0)? -x:x);
}
Passando variáveis como
argumento
Podemos também passar variáveis
da função que chama ao invés de um valor.
Ex.:
int abs ( int );
main ( )
{
int a=-3;
printf (“%d %d %d\n”, abs(a) );
}
abs ( int x )
{
return( (x<0)? -x:x);
}
E ainda, podemos passar vários argumentos
para uma determinada função.
Ex.:
retangulo (int largura, int altura)
{
instruções ....
}
Argumentos
chamada por valor
Em C, todos os argumentos de uma
função são passados “por valor”.
Isto significa que à função chamada
é dada uma cópia dos valores dos argumentos,
e ela cria outras variáveis temporárias para
armazenar estes valores.
Ex.:
int abs ( int );
main ( )
{
int a=-3;
printf (“%d %d %d\n”, abs(a) );
}
abs ( int x )
{
return( (x<0)? -x:x);
}
Funções Recursivas
Uma função é dita recursiva se é
definida em termos de si mesma. Isto é, uma
função é recursiva quando dentro dela está
presente uma chamada a ela própria.
Ex.:
main ( )
{
int num;
long fac( int );
while (1){
printf (“Digite um numero:” );
scanf(“%d”, &num);
printf (“\nFatorial de %d é %1d”
num, fac(num) );
}
}
long fac ( int n)
{ long resposta;
return( (n==0)? 1:resposta=(fac(n-1)*n));
}