Linguagem C
86 pág.

Linguagem C


DisciplinaAlgoritmos e Estrutura de Dados I708 materiais7.916 seguidores
Pré-visualização18 páginas
2.4 apresenta a tabela 
verdade dos operadores lógicos utilizando 1s e 0s. 
 
Tabela 2.3 Operadores relacionais e lógicos. 
Operadores relacionais Operadores lógicos 
> Maior que && AND 
>= Maior ou igual || OR 
< Menor ! NOT 
<= Menor ou igual 
== Igual 
!= Diferente 
 
É permitido combinar diversas operações em uma expressão, por exemplo: 
10>5&&!(10<9)||3<=4 Verdadeiro 
 
Tabela 2.4 Tabela verdade operadores lógicos. 
p q p&&q p||q !p 
0 0 0 0 1 
0 1 0 1 1 
1 1 1 1 0 
1 0 0 1 0 
 
2.6.5 Bit a Bit 
A linguagem C oferece um completo conjunto de operadores bit a bit, isto é, testar, 
atribuir ou deslocar os bits efetivos em um byte (tabela 2.5). A tabela 2.6 apresenta a tabela verdade 
dos operadores bit a bit. 
Tabela 2.5 Operadores bit a bit. 
& AND 
| OR 
^ XOR 
~ Complemento de um 
>> Deslocamento à esquerda 
<< Deslocamento à direita 
 
Tabela 2.6 Tabela verdade operadores bit a bit. 
p q p&q p|q p^q 
0 0 0 0 0 
0 1 0 1 1 
1 1 1 1 0 
1 0 0 1 1 
 
 25
2.6.6 Outros Operadores 
Tabela 2.7 Outros operadores. 
?: Exp1 ? Exp2 : Exp3 
& \u201co endereço de\u201d 
* \u201co valor do endereço de\u201d 
sizeof(f) Retorna o tamanho em bytes de f 
, Separa seqüência de operações 
. 
-> 
Referência a elementos 
individuais de estruturas e 
uniões. 
() Organizar precedência. 
[] Indexação de matrizes. 
 
1. #include <stdlib.h> 
2. #include <stdio.h> 
3. 
4. int main(void) 
5. { 
6. int x, y; 
7. printf(\u201cDigite valor de x=\u201d); 
8. scanf(&x); 
9. printf(\u201cDigite valor de y=\u201d); 
10. scanf(&y); 
11. print((x>y)? \u201cx>y\n\u201d:((x=y)? \u201cx=y\n\u201d: \u201cx<y\n\u201d) 
12. return(0); 
13. } 
 
2.6.7 Precedência 
Tabela 2.8 Precedência dos operadores em C. 
Maior () [] -> 
 ! ~ ++ -- * & sizeof 
 * / % 
 + - 
 << >> 
 < <= > >= 
 == != 
 & 
 ^ 
 | 
 && 
 ?: 
Menor = += -= *= 
 
 
 
 
 26
3. FLUXO DE CONTROLE 
3.1 Comando de Seleção: if...else/switch 
if (<condicao>) 
 <expressão>; 
else 
 <expressão>; 
switch (<expressão>) 
{ 
case constante1 : 
 <seq. de comandos> 
break; 
case constante2 : 
 <seq. de comandos> 
break; 
. 
. 
. 
default : 
 <seq. de comandos> 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int x, y; 
 printf(\u201cDigite valor de x=\u201d); 
 scanf(\u201c%d\u201d,&x); 
 printf(\u201cDigite valor de y=\u201d); 
 scanf(\u201c%d\u201d,&y); 
 if (x>y) 
 printf(\u201cx>y\n\u201d); 
 else 
 { 
 if (x=y) 
 printf(\u201cx=y\n\u201d); 
 else 
 printf(\u201cx<y\n\u201d); 
 } 
 return(0); 
} 
 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int x; 
 printf(\u201cDigite valor de x=\u201d); 
 scanf(\u201c%d\u201d,&x); 
 switch (x) 
 { 
 case 0: 
 printf(\u201cx=0\n\u201d); 
 break; 
 case 1: 
 printf(\u201cx=1\n\u201d); 
 break; 
 case 2: 
 printf(\u201cx=2\n\u201d); 
 break; 
 case 3: 
 printf(\u201cx=3\n\u201d); 
 break; 
 default: 
 printf(\u201c3<x<0\z\u201d); 
 } /*Fim switch*/ 
 return(0); 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 char y; 
 printf(\u201cEscolha a, b, c ou d:\u201d); 
 y=getchar(); 
 switch (x) 
 { 
 case \u2019a\u2019: 
 printf(\u201cEscolhido a\n\u201d); 
 break; 
 case \u2019b\u2019: 
 printf(\u201cEscolhido b\n\u201d); 
 break; 
 case \u2019c\u2019: 
 printf(\u201cEscolhido c\n\u201d); 
 break; 
 case \u2019d\u2019: 
 printf(\u201cEscolhido d\n\u201d); 
 break; 
 default: 
 printf(\u201cEscolha invalida\n\u201d); 
 } /*Fim switch*/ 
 return(0); 
} 
 
3.2 Comando de Iteração: for/while/do...while 
for (<inicialização>, <condição>, <incremento>) 
 <seq. de comando> 
while (<condição>) 
{ 
 <seq. de comando> 
} 
do 
{ 
 <seq. de comando> 
} while (<condição>); 
 
 27
 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int i; 
 for (i=0; i<10; i++) 
 printf(\u201c%d \u201d,i); 
 return(0); 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int i; 
 i=0; 
 while (i<10) 
 { 
 printf(\u201c%d \u201d,i); 
 } 
 return(0); 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int i; 
 i=0; 
 do 
 { 
 printf(\u201c%d \u201d,i); 
 } while (i<10); 
 return(0); 
} 
 
3.3 Comando de Desvio 
Na linguagem C há quatro comandos que realizam um desvio incondicional: 
\u2022 return: É usado para retorno de uma função. A função será finalizada tão logo encontre o 
primeiro return; 
\u2022 goto: É um comando de desvio que deve ser utilizado com precaução pois pode causar 
vazamento do fluxo de informação; 
\u2022 break: Este comando possui duas formas de uso. A primeira é utilizada para terminar um case 
em um comando switch. A segunda forma é utilizada para forçar uma terminação imediata de 
um laço. O comando break provoca uma saída apenas do laço mais interno; 
\u2022 exit: Este comando provoca uma terminação imediata do programa inteiro, forçando um retorno 
ao sistema operacional; 
\u2022 continue: É um comando similar ao break porém em vez de forçar a terminação do laço, 
continue força que ocorra a próxima iteração do laço, pulando qualquer código intermediário. 
Para o laço for, continue faz com que o teste condicional e a porção de incremento do laço 
sejam executados. Para os laços while e do-while, o controle do programa passa para o teste 
condicional. 
return (<expressão>); goto <rótulo>; 
... 
<rótulo>: 
void exit(int codigo_de_retorno); 
 
 28
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int x; 
 x=1; 
 volta1: 
 x++; 
 if (x<50) 
 { 
 printf(\u201d%d\n\u201d,x); 
 goto volta1; 
 } 
 return(0); 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 int x; 
 for (x=0; x<50; x++) 
 { 
 printf(\u201d%d\n\u201d,x); 
 if (x==25) break; 
 } 
 return(0); 
} 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 char s[80], *str; 
 int esp; 
 printf(&quot;Digite uma string:&quot;); 
 gets(s); 
 str=s; 
 for (espaco=0; *str; str++) 
 { 
 if (*str!=' ') continue; 
 esp++; 
 } 
 printf(&quot;%d espacos\n&quot;, esp); 
 return (0); 
} 
3.4 Outros Comandos 
Um comando de expressão é uma expressão válida em C seguida por ponto-e-vírgula, 
por exemplo: 
soma(); /* Chamada de função */ 
a=sqrt(pow(b,2)+pow(c,2)); /* Comando de atribuição */ 
b+raiz(z); /* Comando válido, que não faz nada */ 
; /* Comando vazio */ 
 
 
 
 
 
 
 
 29
4. ENTRADA E SAÍDA 
As funções printf() e scanf() realizam entrada e saída formatada, isto é, permite a 
leitura e a escrita de dados em vários formatos. 
O printf() é uma função de I/O, que permite escrever no dispositivo padrão (tela). A 
expressão de controle pode conter caracteres que serão exibidos na tela e os códigos de formatação 
(tabela 3.1) que indicam o formato em que os argumentos devem ser impressos. Cada argumento 
deve ser separado por vírgula. 
O scanf() também é uma função de I/O implementada em todos compiladores C. Ela é o 
complemento de printf() e nos permite ler dados formatados (tabela 4.1) da entrada padrão 
(teclado). Sua sintaxe é similar a printf(). 
int printf(const char *str, ...); int scanf(const char *str, ...); 
 
Tabela 4.1 Comandos de formato para printf() e scanf(). 
Código Formato 
%c Caractere 
%d Inteiros decimais com sinal 
%i Inteiros decimais com sinal 
%e Notação científica 
%f Ponto flutuante decimal 
%o Octal sem sinal 
%s String de caracteres 
%u Inteiros decimais sem sinal 
%x Hexadecimal sem sinal 
%p Apresenta um ponteiro 
 
1. #include <stdlib.h> 
#include <stdio.h> 
 
int main(void) 
{ 
 char c; 
 int x; 
 float y; 
 c=\u2019d\u2019; 
 x=c; 
 y=19.234; 
 printf(\u2019%c\n\u2019, c); 
 printf(\u2019%d\n\u2019, x); 
 printf(\u2019%f\n\u2019, y); 
 printf(\u2019%.3f\n\u2019, y); 
 printf(\u2019%.2f\n\u2019, y); 
 printf(\u2019%.1f\n\u2019, y); 
 return(0); 
} 
 
4.1 Exercícios 
1. Faça um programa que receba três números inteiros, calcule e mostre a soma desses números. 
2. Faça um programa que receba três notas, calcule e mostre a média aritmética dessas notas. 
3. Faça um programa que receba três notas e seus respectivos pesos, calcule e mostre a média 
ponderada dessas notas. As notas deverão estar na faixa entre 0 e 10. 
 30
4. Faça um programa que receba o valor de um depósito e o valor