Programação de Computadores I Apostila de C

Programação de Computadores I Apostila de C
A Linguagem C
• Criada em 1972 por D. M. Ritchie e K. Thompson. Tornou-se uma das mais

importantes e populares, principalmente pela portabilidade e flexibilidade. Foi
projetada para o desenvolvimento de programas estruturados e modulares.
A forma de um programa em C
• A linguagem C, como todas as outras linguagens de programação, consiste de

palavras reservadas e regras de sintaxe que se aplicam a cada palavra reservada.
Uma palavra reservada é essencialmente um comando e, na maioria das vezes, as
palavras reservadas de uma linguagem definem o que pode ser feito e como pode
ser feito.
• Na linguagem C são 32 palavras reservadas. Todas as palavras reservadas do C
são minúsculas. Uma palavra reservada não pode ser usada para nenhum outro
propósito em um programa. A tabela abaixo mostra as palavras reservadas
conforme definido pelo padrão ANSI para a linguagem C.
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
• A linguagem C é baseada no conceito de funções. Um programa C é um conjunto

de funções. Uma biblioteca é um arquivo contendo as funções padrão que seu
programa pode usar. Essas funções incluem todas as operações de entrada e
saída (E/S) e também outras rotinas úteis para realizar as tarefas mais
comumente necessárias.
Compiladores
• A única linguagem que o computador entende é a linguagem de máquina.
Programas escritos em C (programa fonte) devem ser traduzidos para a
linguagem de máquina. O programa que faz esta tradução é chamado
compilador. O compilador lê o programa fonte inteiro e o traduz para um
programa com a extensão .obj (programa objeto).
• Quando se usa uma função que não faz do programa que você escreveu (ou seja,
que pertence a uma das bibliotecas do C), é necessário agregar ao programa
objeto as rotinas correspondentes à essas funções. Este trabalho é feito por um
programa chamado link-editor que, além de adicionar as rotinas necessárias ao
programa objeto, cria um programa com a extensão .exe (programa executável).
O programa executável está em linguagem de máquina e pode ser executado
diretamente pelo computador.
1
Como criar um programa executável

1. Digitar seu programa com auxilio de um processador de textos. Gravar em disco
atribuindo a ele um nome com a extensão .c. O programa gerado é chamado
programa fonte.
2. Compilar o programa fonte criando um programa com a extensão .obj em disco.
O programa gerado é chamado programa objeto.
3. Link-editar o programa objeto criando um programa com a extensão .exe em
disco. O programa gerado é chamado programa executável.
Estrutura Básica de um Programa em C
Utilizaremos como referência o compilador DEV C++ 5.0. Procure baixar e

instalar no seu computador. Tente pelo blog da disciplina ou procure no
Google.
A função main()
• Um programa em C consiste de uma ou várias funções. A função main() deve

existir em algum lugar de seu programa e marca o início da execução do
programa.
main() ⇐ primeira função a ser executada

{ ⇐ início do corpo da função
} ⇐ término do corpo da função
• Os parênteses após o nome indicam que esta é uma função. Toda função C deve
ser iniciada por um abre-chaves ({) e encerrada por um fecha-chaves (}). O nome
da função, os parênteses e as chaves são os únicos elementos obrigatórios de
uma função.
• Vamos adicionar uma instrução ao nosso programa:
main()
{
printf(“Primeiro programa”);
}
• Todas as instruções devem estar dentro das chaves e são executadas na ordem
em que as escrevemos. As instruções em C são sempre encerradas por um ponto-
e-vírgula (;).
A função printf()
• A função printf() é uma das funções de E/S que podem ser usadas em C. Esta
função é usada por programas que realizam saída para a tela do computador.
• A função printf() está definida na biblioteca stdio.h. Então, para que o seu
programa possa utilizar a função printf() é necessário incluir a biblioteca
stdio.h ao seu programa.
2
• A função system(“pause”) está definida na biblioteca stdlib.h. Esta função

causa uma pausa na execução do programa para que a saída de dados seja lida.
Se não utilizar esta função a tela de saída do DEV C (tela de fundo preto) apenas
piscará na hora da execução. Em versões mais atuais o system(“pause”) é
opcional.
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“Primeiro programa”);
system(“pause”);
}
• No interior dos parênteses estão as informações passadas pela função main()
para a função printf(). Essas informações são chamadas de argumento da
função.
• Sintaxe: printf(“expressão de controle”, lista de argumentos);
• A expressão de controle pode conter caracteres que serão exibidos na tela e
códigos de formatação que indicam o formato em que os argumentos devem ser
impressos.
• Exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“Este é o número dois: %d”, 2);
}
• Neste exemplo, o código de formatação %d solicita ao printf() imprimir o
segundo argumento em formato decimal.
• A função printf() pode receber um número variável de argumentos, isto é, a
expressão de controle e mais tantos argumentos quantas especificações de
formato a expressão de controle contiver. Cada argumento deve ser separado
por uma vírgula (,).
• A tabela abaixo mostra alguns códigos de formatação que podem ser utilizados
pelo printf():
código significado
%d Decimal
3
%f ponto flutuante
%c Caractere simples
%s cadeia de caracteres
• O código de formatação pode ser colocado em qualquer lugar na expressão de
controle:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“O numero %d e’ decimal, %f e’ ponto flutuante”, 10, 10.78);
}
• Imprimindo cadeia de caracteres:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%s esta’ a %d milhões de milhas \n do sol”, “Venus”, 67);
}
• Além do código de formatação, a expressão de controle contém um conjunto de
caracteres estranho: \n. O \n é um código especial que informa a printf() que o
restante da impressão deve ser feito em uma nova linha.
• Os caracteres que não podem ser obtidos diretamente do teclado para dentro do
programa (como a mudança de linha) são escritos em C com a combinação do
sinal \ (barra invertida) com outros caracteres, como mostra a tabela abaixo:
códigos especiais significado

\n nova linha
\r retorno do cursor
\t tabulação horizontal
\b retrocesso
\v Tabulação vertical
\a sinal sonoro
\0 nulo
• Programa com mais de uma instrução:
#include <stdio.h>
#include <stdlib.h>
4
main()
{
printf(“A letra %c ”, ‘j’);
printf(“pronuncia-se %s ”, “jota”);
}
• Note que ‘j’ é delimitado por aspas simples enquanto “jota” é delimitado por
aspas duplas. Isto indica ao compilador como diferenciar um caracter de uma
cadeia de caracteres.
Constantes e Variáveis
• Na linguagem C, constantes referem-se a valores fixo que não podem ser

alterados pelo programa.
• O modo como cada constante é representada depende do seu tipo. Constantes
caracter são colocadas entre aspas simples, por exemplo, ‘j’. Constantes cadeia
de caracter (ou string) são colocadas entre aspas duplas, por exemplo, “Venus” e
“jota”. Constantes inteiro são especificadas como números sem componente
fracional, por exemplo, 10 e 67. Constantes ponto flutuante requerem o uso de
ponto decimal seguido pelo componente fracional do número, por exemplo,
10.78.
• As variáveis são o aspecto fundamental de qualquer linguagem de computador.
Uma variável em C é um espaço de memória reservado para armazenar um certo
tipo de dado e tendo um nome para referenciar o seu conteúdo. Uma variável
pode conter, a cada instante, valores diferentes.
Tipos de Variáveis
• O tipo de uma variável informa a quantidade de memória, em bytes, que ela irá
ocupar e a forma como o seu conteúdo será armazenado.
• Em C exitem 5 tipos de variáveis básicas: caracter, inteiro, ponto flutuante,
ponto flutuante duplo e sem valor. As palavras reservadas usadas para declarar
variáveis desses tipos são: char, int, float, double e void, respectivamente. Nos
computadores da linha IBM-PC a tabela seguinte é válida:
tipo bit bytes escala

char 8 1 -128 a 127
int 16 2 -32768 a 32767
float 32 4 3.4E-38 a 3.4E+38
double 64 8 1.7E-308 a 1.7E+308
5
Nomes de Variáveis
• A escolha de nomes significativos para suas variáveis pode ajudá-lo a entender o

que o programa faz e prevenir erros.
• Você pode usar quantos caracteres quiser para um nome de variável com o
primeiro sendo obrigatoriamente uma letra ou sublinhado (_) e os demais
podendo ser letras, números ou outros sublinhados.
• Uma variável não pode ter o mesmo nome de uma palavra reservada do C e não
deverá ter o mesmo nome de uma função. Em C maiúsculas e minúsculas são
tratadas como diferentes e distintas umas das outras. Por isso, cont, Cont e CONT
são três variáveis distintas.
Declarações de Variáveis
• Uma declaração de variável é uma instrução para reservar uma quantidade de

memória apropriada para armazenar o tipo especificado e indicar que o seu
conteúdo será referenciado pelo nome da variável.
• Uma declaração de variável consiste em um tipo seguido do nome da variável.
Exemplo:
int num;
• Em C todas as variáveis devem ser declaradas. Se você tiver mais de uma variável
do mesmo tipo, poderá declará-las de uma única vez, separando seus nomes por
vírgulas.
int num1, num2, num3;
Inicialização de Variáveis
• É possível combinar uma declaração de variável com o operador de atribuição

para que a variável tenha um valor no instante de sua declaração.
• A forma geral de inicialização é:
tipo nome_da_variável = constante;
• Exemplos:
int num = 2;
char letra = ‘a’;
• Vejamos um exemplo completo:
#include <stdio.h>
#include <stdlib.h>
main()
6
{
int evento = 5;
char corrida = ‘C’;
float tempo = 27.25;
printf(“O tempo vitorioso na eliminatória %c ”, corrida);
printf(“\nda competição %d foi %f.”, evento, tempo);
}
Tamanho de Campos na Impressão
• Em printf() é possível estabelecer o tamanho mínimo para a impressão de um

campo.
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“Os alunos sao %3d.\n”, 350);
}
• A saída será:
Os alunos são 350.
Os alunos são 350.
Os alunos são 350.
• Podemos usar tamanho de campos com números em ponto flutuante para obter
precisão e arredondamento.
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%.4f\n”, 3456.789);
printf(“%.3f\n”, 3456.789);
printf(“%.2f\n”, 3456.789);
printf(“%.1f\n”, 3456.789);
7
}
• A saída será:
3456.7890
3456.789
3456.79
3456.8
• Os tamanhos de campos podem ser usados para alinhamento à direita. Exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%10.2f %10.2f %10.2f\n”, 8.0, 15.3, 584.13);
printf(“%10.2f %10.2f %10.2f\n”, 834.0, 1500.55, 4890.21);
}
• A saída será:
8.00 15.30 584.13
834.00 1500.55 4890.21
• O sinal de menos (-) precedendo a especificação do tamanho do campo justifica

os campos à esquerda. Exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%-10.2f %-10.2f %-10.2f\n”, 8.0,15.3,584.13);
printf(“%-10.2f %-10.2f %-10.2f\n”,834.0,1500.55,4890.21);
}
• A saída será:
8.00 15.30 584.13
834.00 1500.55 4890.21
8
• Além de especificar o tamanho do campo, podemos complementar o campo todo

ou parte dele com zeros à esquerda. Exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%04d\n”,21);
printf(“%06d\n”,21);
printf(“%6.4d\n”,21);
printf(“%6.2d\n”,21);
}
• A saída será:
0021
000021
0021
21
Imprimindo Caracteres
• Em C um caractere pode ser representado de diversas maneiras: o próprio

caractere entre aspas simples ou sua representação decimal, segundo a tabela
ASCII.
• A tabela ASCII tem 256 códigos decimais numerados de 0 a 255. Cada código
decimal corresponde a um caractere distinto, por exemplo, o decimal 65
corresponde ao caractere A.
• O exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%d %c \n”, ‘A’,‘A’ );
}
• imprime:
65 A
9
• O exemplo:
#include <stdio.h>
#include <stdlib.h>
main()
{
printf(“%c %c \n”, ‘A’,);
}
imprime:
• A A
Comentários
• Comentários podem ser colocados em qualquer lugar de seu programa.

Comentários começam com barra-asterisco (/*) e terminam por asterisco-barra
(*/). O compilador irá ignorar tudo o que encontrar entre estes dois símbolos.
• Inserir comentários em seus programas é fundamental para que se tenha uma
boa documentação. A documentação auxilia no entendimento do programa.
• Vejamos um exemplo anterior com os devidos comentarios:
/* corrida.cpp/
/* Programa para imprimir o resultado de uma corrida*/
#include <stdio.h> /* Biblioteca que contem a funcao printf() */
#include <stdlib.h>
main() /* Funcao principal */
{
int evento = 5; /* declara a variavel evento e a inicializa */
char corrida = ‘C’;/* declara a variavel corrida e a
inicializa */
float tempo = 27.25; /* declara a variavel tempo e a
inicializa */
/* Imprime o resultado da corrida */
printf(“O tempo vitorioso na eliminatória %c ”, corrida);
printf(“\nda competição %d foi %f.”, evento, tempo);
}
10
• Asteriscos dentro de comentários podem ser colocados livremente:
/*****************************************************
* Programa: corrida.cpp
* Programador:
* Data:
* Programa para imprimir o resultado de uma corrida
******************************************************/
• Não são permitidos os símbolos /* ou */ no interior de um comentário:
/* Estou escrevendo /* um comentário ilegal */
11
Capítulo 2 – Operadores
A função scanf()
• A função scanf() é outra das funções de E/S implementadas em todos os

compiladores C e nos permite ler dados formatados da entrada padrão (teclado).
• Sintaxe: scanf(“expressão de controle”, lista de argumentos);
• Por enquanto, assuma que a expressão de controle pode conter apenas códigos
de formatação, que indica à função que deve ser lido um valor do tipo indicado
pelo código.
• A lista de argumentos deve consistir nos endereços das variáveis que irão
armazenar os valores lidos. C possui um operador para tipos básicos chamado
operador de endereço e referenciado pelo símbolo & que fornece o endereço do
operando.
O operador de endereço (&)

• A memória do seu computador é divida em bytes, e estes bytes são numerados de
0 até o limite de memória de sua máquina. Estes números são chamados de
endereços. Um endereço é o nome que o computador usa para identificar a
variável.
Em programação I precisaremos de utilizar & todas as vezes que utilizarmos scanf.
As funções getche() e getch()

• O C oferece funções que lêem um caractere no instante em que é digitado sem
esperar [enter]. Essas funções estão definidas na biblioteca conio.h.
• A função getche() lê o carcter do teclado e o imprime na tela imediatamente.
Esta função não aceita argumentos e devolve o caractere lido para a função que a
chamou.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
char ch;
printf(“Digite um caracter: ”);
ch = getche();
printf(“\n A tecla pressionada foi: %c”, ch);
}
• A função getch() lê o caracter do teclado mas não imprime o caracter lido na
tela. Esta função não aceita argumentos e devolve o caracter lido para a função
que a chamou.
#include <stdio.h>
12
#include <stdlib.h>
#include <conio.h>
main()
{
char ch;
ch = getch();
printf(“\n A tecla pressionada foi: %c”, ch);
}
As funções getchar() e putchar()

• A função getchar() está definida na biblioteca stdio.h e lê um caracter do
teclado só terminando a leitura quando a tecla [enter] é pressionada.
• A função putchar(), também definida na biblioteca stdio.h, aceita um
argumento cujo valor será impresso na saída padrão (tela).
#include <stdio.h>
#include <stdlib.h>
main()
{
char ch;
ch = getchar();
putchar(ch);
}
• Um argumento de uma função pode ser outra função. Por exemplo, o programa
anterior pode ser escrito como:
#include <stdio.h>
#include <stdlib.h>
main()
{
char ch;
putchar(getchar());
}
Operadores
• Um operador é um símbolo que diz ao compilador para realizar manipulações

matemáticas e lógicas específicas. A linguagem C oferece três classes de
operadores: aritméticos, relacionais e lógicos e de atribuição.
13
Operador de atribuição
• Em C, o sinal de igual (=) não tem a mesma interpretação dada em matemática.
Representa a atribuição da expressão à direita ao nome da variável à esquerda.
Por exemplo:
num = 20;
• Neste exemplo o valor 20 é atribuído a variável num. C aceita várias atribuições
numa mesma instrução:
num1 = num2 = num3 = 20;
• Neste exemplo o valor 20 é atribuído as variáveis num1, num2 num3.
Operadores aritméticos
• C oferece 5 operadores aritméticos binários (operam sobre dois operandos) e um
operador aritmético unário (opera sobre um operando).
operador operação
+ adição
- subtração e menos unário
* multiplicação
/ divisão
% resto da divisão inteira
Operadores binários: + - / *
• Representam as operações aritméticas básicas de soma, subtração, divisão e
multiplicação respectivamente. Estes operadores podem ser aplicados a
qualquer tipo de dado interno permitido pelo C.
• Exemplo 1: programa que calcula a idade em dias
#include <stdio.h>
#include <stdlib.h>
main()
{
float anos, dias;
printf(“Informe sua idade em anos: ”);
scanf(“%f”, &anos);
dias = anos*365;
printf(“Sua idade em dias e’: %.0f \n”, dias);
}
• Exemplo 2: programa que converte temperatura Fahrenheit em seus
correspondentes graus Celsius.
#include <stdio.h>
14
#include <stdlib.h>
main()
{
int ftemp;
float ctemp;
printf(“Informe a temperatura em graus Fahrenheit: ”);
scanf(“%d”, &ftemp);
ctemp = (ftemp–32)*5.0/9;
printf(“Temperatura em graus Celsius e’: %.2f\n”, ctemp);
}
• Exemplo 3: programa para adivinhar a soma de 5 números. O usuário digita um
número qualquer e o computador informa o resultado da soma dos 5 números
dos quais o primeiro o usuário já forneceu. O usuário digita o segundo número e
o computador mostra o terceiro. O usuário digita o quarto número e o
computador mostra o quinto.
#include <stdio.h>
#include <stdlib.h>
main()
{
int num, aux;
printf(“Informe um número de ate’ 4 algarismos: ”);
scanf(“%d”, &num);
aux = 19998 + num;
printf(“O resultado da nossa conta sera’: %d\n”, aux);
printf(“Informe o segundo número (4 algarismos): ”);
printf(“O meu numero e’: %d\n”, 9999-num);
printf(“Informe o quarto número (4 algarismos): ”);
printf(“O meu numero e’: %d\n”, 9999-num);
}
Operador menos unário: -

• Este operador é utilizado somente para indicar a troca do sinal algébrico do
valor. Por exemplo:
num = -8;
num1 = -num;
• Depois destas duas instruções, o conteúdo de num1 será 8.
Operador módulo: %
• O operador módulo aceita apenas operandos inteiros. Resulta o resto da divisão
do inteiro à sua esquerda pelo inteiro à sua direita. Por exemplo:
num = 17%5;
15
• Depois desta instrução, o conteúdo de num será 2.
Operadores de incremento (++) e decremento (--)

• A linguagem C permite dois operadores bastante úteis geralmente não
encontrados em outras linguagens. São eles os operadores de incremento (++) e
decremento (--).
• O operador de incremento (++) adiciona um ao seu operando, enquanto o
operador de decremento (--) subtrai um do seu operando.
• Estes operandos trabalham de dois modos. O primeiro modo é chamado pré-
fixado e o operador aparece antes do nome da variável. O segundo é o modo pós-
fixado em que o operador aparece seguindo o nome da variável.
• Em ambos os casos, a variável é incrementada (++) ou decrementada (--). Porém
quando ++n é usado numa instrução, n é incrementada antes de seu valor ser
usado, e quando n++ estiver numa instrução, n é incrementada depois de seu
valor ser usado.
#include <stdio.h>
#include <stdlib.h>
main()
{
int n, x;
n = 5;
x = n++;
printf(“x=%d n=%d\n”, x, n);
}
• Quando o programa acima for executado a saída será: x = 5 n = 6 . Isto porque o
valor de n é atribuído a x e depois n é incrementado de 1.
#include <stdio.h>
#include <stdlib.h>
main()
{
int n, x;
n = 5;
x = ++n;
printf(“x=%d n=%d\n”, x, n);
}
• Quando o programa acima for executado a saída será: x = 6 n = 6 . Isto porque o
valor de n é incrementado de 1 e depois seu valor é atribuído a x.
• Quando um desses operadores aparece sozinho numa instrução (como em
num++;) não faz diferença o uso do modo pré-fixado ou pós-fixado.
16
Precedência dos operadores aritméticos

• A tabela abaixo mostra a precedência dos operadores aritméticos;
mais alta ++ --
- (unário)
*/%
mais baixa +-
• Operadores do mesmo nível de precedência são avaliados pelo compilador da

esquerda para a direita. Parênteses podem ser usados para alterar a ordem de
avaliação. Os parênteses forçam uma operação, ou conjunto de operações, para o
nível mais alto de precedência.
Operadores aritméticos de atribuição: +=, -=, *=, /=, %=

• Cada um destes operadores é usado com uma variável a sua esquerda e uma
expressão à sua direita. A operação consiste em atribuir um novo valor à
variável que dependerá do operador e da expressão à direita.
• Se x é uma variável, exp uma expressão e op um operador aritmético (+,-.*,/ ou
%), então x op= exp; equivale a x = x op exp;
• Exemplos:
i += 2; equivale a i = i+2;
x *= y+1; equivale a x = x*(y+1);
t /= 2.5; equivale a t = t/2.5;
p %= 5; equivale a p = p%5;
d -= 3; equivale a d = d-3;
• As expressões com estes operadores são mais compactas e normalmente
produzem um código de máquina mais eficiente.
#include <stdio.h>
#include <stdlib.h>
main()
{
int total = 0;
int cont = 10;
printf(“Total: %d\n”, total);
total += cont;
total *= cont;
}
Operadores relacionais e lógicos
17
• Nos termos operador relacional e lógico, relacional refere-se aos relacionamentos

que podem haver entre dois valores e lógico à maneira como esses
relacionamentos podem ser conectados.
• A chave para o conceito de operadores relacionais e lógicos é a idéia de
verdadeiro e falso. Em C, verdadeiro é qualquer valor diferente de zero e falso é
zero. Expressões que operadores relacionais e lógicos retornarão 0 para falso e 1
para verdadeiro.
• Operadores relacionais:
operador ação
> maior que
>= maior ou igual que
< menor que
<= menor ou igual que
== igual
!= diferente
• Os operadores relacionais são usados para determinar o relacionamento de uma
quantidade com outra. Eles sempre retornam 0 ou 1, dependendo do resultado
do teste. O programa seguinte ilustra o uso de cada operação e exibe o resultado
de cada uma como 0 ou 1:
#include <stdio.h>
#include <stdlib.h>
main()
{
int i, j;
printf(“Informe dois numeros: ”);
scanf(“%d%d”, &i, &j);
printf(“%d == %d eh %d\n”, i, j, i==j);
printf(“%d != %d eh %d\n”, i, j, i!=j);
printf(“%d <= %d eh %d\n”, i, j, i<=j);
printf(“%d >= %d eh %d\n”, i, j, i>=j);
printf(“%d < %d eh %d\n”, i, j, i>j);
printf(“%d < %d eh %d\n”, i, j, i<j);
}
• Os operadores relacionais podem ser aplicados a qualquer dos tipos de dados

básicos. No próximo capítulo você verá outras aplicações para os operadores
relacionais.
• Operadores lógicos:
operador ação
&& AND (E)
|| OR (OU)
! NOT (NÃO)
18
• Os operadores lógicos são usados para dar suporte às operações lógicas básicas
de AND, OR e NOT, de acordo com a tabela esta verdade. A tabela usa 1 para
verdadeiro e 0 para falso.
p q p && q p || q !p
V V V V F
V F F V F
F V F V V
F F F F V
• O próximo programa ilustra a ação dos operadores lógicos:
#include <stdio.h>
#include <stdlib.h>
main()
{
int i, j;
printf(“Informe dois numeros (cada um sendo 0 ou 1): ”);
scanf(“%d%d”, &i, &j);
printf(“%d AND %d eh %d\n”, i, j, i&&j);
printf(“%d OR %d eh %d\n”, i, j, i||j);
printf(“NOT %d eh %d\n”, i, !i);
}
• Tanto operadores lógicos como os relacionais têm menor precedência que os

operadores aritméticos. Isto significa que a expressão 10 > 1+12 é avaliada como
10 > (1+12).
• A tabela abaixo mostra a precedência relativa dos operadores relacionais e
lógicos:
mais alta !
> >= < <=
== !=
&&
mais baixa ||
• Assim como nas expressões aritméticas é possível usar parênteses para alterar a
ordem natural de avaliação em uma expressão relacional e/ou lógica.
19
Capítulo 3 – Comandos de Decisão
• A linguagem C oferece quatro estruturas de decisão: if, if-else, switch e o

operador condicional.
O comando if
• O comando if instrui o computador a tomar uma decisão simples.

• Sintaxe: if(expressão de teste)
instrução;
• Se a expressão de teste for verdadeira (algo diferente de 0), o comando if
executa a instrução. Caso contrário a instrução não será executada.
• O programa seguinte mostra o uso do comando if:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
char ch;
puts("Tecle algo: ");
ch = getche();
if( ch == 'p')
printf("\nVoce pressionou a tecla p.\n\n");
system("pause");
}
• Se você pressionar p o programa imprimirá “Você pressionou a tecla p”. Se você
pressionar qualquer outra tecla, o programa não fará absolutamente nada.
Múltiplas instruções no corpo do comando if
• Caso múltiplas instruções sejam necessárias no corpo do comando if elas devem

estar entre chaves.
20
• Vamos reescrever o programa anterior acrescentando outras instruções ao

corpo do comando if:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
if( getche() == ‘p’) {
printf(“\nVoce pressionou a tecla p.”);
printf(“\nEsta versão não detecta outra tecla.”);
printf(“\n Tecle algo para continuar... ”);
getche();
}
}
• No exemplo acima incluímos a função getche() na expressão de teste. O if
compara o caracter retornado por getche() com a letra p e, se forem iguais, a
expressão assume um valor verdadeiro, e o bloco de instruções é executado.
Comandos if aninhados
• Um comando if pode estar dentro de outro comando if. Dizemos que o if interno
está aninhado. Exemplo:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
char ch;
printf(“Digite uma letra entre a e z: ”);
ch = getche();
if( ch >= ‘a’)
if( ch <= ‘z’)
printf(“\nVoce digitou certo!”);
}
• Este programa somente imprimirá a frase se você digitar uma letra minúscula.
O comando if-else
• Nos exemplos anteriores o comando if executará a instrução (ou instruções), se a

expressão de teste for verdadeira. Não fará nada se a expressão de teste for falsa.
• O comando else, quando associado ao if, executará uma instrução (ou
instruções) se a expressão de teste do comando if for falsa.
• Sintaxe: if(expressão de teste)
21
instrução_1;
else
instrução_2;
• O programa seguinte imprime uma mensagem caso a expressão de teste do if
seja falsa:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
char ch;
ch = getche();
if( ch == ‘p’)
printf(“\nVoce pressionou a tecla p.”);
else
printf(“\nVoce nao pressionou a tecla p.”);
}
Comandos if-else aninhados
• Utilizaremos o programa calc.c para exemplificar a utilização de comandos if-

else aninhados. Este programa simula uma calculadora simples com 4 operações.
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
char op;
printf(“\nDigite uma expressão no formato: num op num: ”);
scanf(“%f %c %f”, &num1, &op, &num2);
if( op == ‘+’ )
printf(“ = %f”, num1+num2);
else
if( op == ‘-’ )
printf(“ = %f”, num1-num2);
else
if( op == ‘*’ )
printf(“ = %f”, num1*num2);
else
if( op == ‘/’ )
printf(“ = %f”, num1/num2);
}
22
O comando if-else-if
• Uma construção comum em programação é a forma if-else-if. Para exemplificar

vamos reescrever o programa calc.c.
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
char op;
if( op == ‘+’ )
printf(“ = %f”, num1+num2);
else if( op == ‘-’ )
printf(“ = %f”, num1-num2);
else if( op == ‘*’ )
printf(“ = %f”, num1*num2);
else if( op == ‘/’ )
printf(“ = %f”, num1/num2);
}
• As expressões de teste são avaliadas de cima para baixo. Assim que uma
expressão verdadeira é encontrada, o comando associado a ela é executada.
O comando switch
• O comado switch teste sucessivamente o valor de uma expressão contra uma
lista de constantes inteiras ou caracteres. Quando o valor coincide, os comandos
associados àquela constante são executados.
• Sintaxe: switch(variável de controle)
{
case constante1:
instruções; break;
case constante2:
instruções; break;
default:
instruções;
}
• O comando break causa uma saída imediata do switch. Se não existir um

comando break seguindo as instruções de um caso, o programa segue
executando todas as instruções dos casos abaixo.
• Se nenhum caso for satisfeito e existir um caso default, a execução começará
nele, senão o programa processará as instruções seguintes ao bloco switch. Um
default é opcional.
• Reescreveremos o programa calc.cpp fazendo uso do comando switch.
23
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
char op;
switch( op )
{
case ‘+’:
printf(“ = %f”, num1+num2); break;
case ‘-’:
printf(“ = %f”, num1-num2); break;
case ‘*’:
printf(“ = %f”, num1*num2); break;
case ‘/’:
printf(“ = %f”, num1/num2); break;
default:
printf(“\nOperador desconhecido”);
}
• O próximo exemplo mostrará casos sem break. Nesta versão você poderá digitar
o sinal * ou x para multiplicação.
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
char op;
switch( op )
{
case ‘+’:
printf(“ = %f”, num1+num2); break;
case ‘-’:
printf(“ = %f”, num1-num2); break;
case ‘*’:
case ‘x’:
printf(“ = %f”, num1*num2); break;
case ‘/’:
printf(“ = %f”, num1/num2); break;
default:
printf(“\nOperador desconhecido”);
}
}
24
• O próximo programa mostra um exemplo com switch’s aninhados. É um banco de dados

simples que mostra o desempenho dos vendedores de cada região.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
char regiao, vendedor;
printf("As regioes sao: Leste, Oeste e Norte\n");
printf("Informe a primeira letra da regiao: ");
regiao = getche();
switch( regiao )
{
case 'l':
printf("\nOs vendedores sao: Rafael, Joao e Mariana\n");
printf("Informe a primeira letra do nome do vendedor: ");
vendedor = getche();
switch( vendedor )
{
case 'r': printf("\nVendas: R$ 10.000,00\n"); break;
case 'j': printf("\nVendas: R$ 12.000,00\n"); break;
case 'm': printf("\nVendas: R$ 14.000,00\n");
}
break;
case 'o':
printf("\nOs vendedores sao: Ronaldo, Lisa e Hilton\n");
switch( vendedor )
{
case 'r': printf("\nVendas: R$ 10.000,00\n"); break;
case 'l': printf("\nVendas: R$ 9.500,00\n"); break;
case 'h': printf("\nVendas: R$ 13.000,00\n");
}
break;
case 'n':
printf("\nOs vendedores sao: Tomas, Jaime e Raquel\n");
switch( vendedor )
{
case 't': printf("\nVendas: R$ 5.000,00\n"); break;
case 'j': printf("\nVendas: R$ 9.000,00\n"); break;
case 'r': printf("\nVendas: R$ 14.000,00\n");
}
}
}
25
Capítulo 4 – Comandos de Repetição
• Comandos de repetição (também chamados laços) permitem que um conjunto de

instruções seja executado até que ocorra uma certa condição.
• Em C exitem três estruturas principais de laços: o laço for, o laço while e o laço
do-while.
O laço for
• O laço for é útil principalmente quando queremos repetir algo um número fixo
de vezes.
• Sintaxe: for(inicialização; teste; incremento)
instrução;
• Os parênteses seguindo a palavra reservada for contêm três expressões
separadas por ponto e vírgula. A expressão como um todo é chamada de
expressão do laço e é dividida em: expressão de inicialização, expressão de teste
e expressão de incremento.
• Em sua forma mais simples, a inicialização é uma instrução de atribuição e é
sempre executada uma única vez antes do laço ser iniciado.
• O teste é uma instrução de condição que controla o laço. Essa expressão é
avaliada como verdadeira ou falsa toda vez que o laço for iniciado ou reiniciado.
Se verdadeira, o corpo do laço é executado. Quando a expressão se tornar falsa o
laço é terminado.
• O incremento define a maneira como a variável de controle do laço será alterada
cada vez que o laço é repetido. Esta instrução é executada, toda vez,
imediatamente após a execução do corpo do laço.
• O programa seguinte imprime os números de 0 a 9 utilizando um laço for na sua
forma mais simples:
#include <stdio.h>
#include <stdlib.h>
main()
{
int cont;
for(cont = 0; cont < 10; cont++)
printf(“cont = %d\n”, cont);
system("pause");
}
• O programa executa 10 vezes a instrução printf(). Vamos mudar o programa
acima para que imprima os números de 9 a 0.
26
#include <stdio.h>
#include <stdlib.h>
main()
{
int cont;
for(cont = 9; cont >= 0; cont--)
system("pause");
}
• O próximo programa imprime os números de 0 a 9 de 3 em 3:
#include <stdio.h>
#include <stdlib.h>
main()
{
int cont;
for(cont = 0; cont < 10; cont+=3)
system("pause");
A flexibilidade do laço for
• Nos exemplos anteriores usamos a forma mais simples para as três expressões
do laço for. Entretanto elas não são restritas apenas as estas formas. C permite
muitas outras possibilidades que mostraremos nos próximos exemplos.
• Qualquer uma das expressões de um laço for pode conter várias instruções
separadas por vírgulas. O exemplo abaixo imprime os números de 0 a 98 em
incremento de 2.
#include <stdio.h>
#include <stdlib.h>
main()
{
int x, y;
for(x = 0, y = 0; x+y < 100; x++, y++)
printf(“%d ”, x+y);
system("pause");
27
• Qualquer uma das três expressões de um laço for pode ser omitida, embora os
ponto-e-vírgula devam permanecer. Se a expressão de inicialização ou a de
incremento forem omitidas, elas serão simplesmente desconsideradas.
• Se a condição de teste não está presente é considerada permanentemente
verdadeira.
#include <stdio.h>
#include <stdlib.h>
main()
{
char ch;
for( ;; )
printf(“Laco infinito\n”);
system("pause");
}
• O corpo do laço pode ser vazio, entretanto o ponto-e-vírgula permanece:
#include <stdio.h>
#include <stdlib.h>
main()
{
char ch;
for( ; (ch = getche()) != ‘x’; printf(“ %c ”, ch+1))
;
system("pause");
Múltiplas instruções no corpo de um laço for
• Os exemplos anteriores usam somente uma instrução no corpo do laço for. Duas
ou mais instruções podem ser colocadas se estiverem entre chaves.
#include <stdio.h>
#include <stdlib.h>
main()
{
int cont, total;
for(cont = 0, total = 0; cont < 10; cont++)
{
total += cont;
printf(“cont = %d, total = %d\n”, cont, total);
}
system("pause");
28
Laço for aninhados
Quando um laço está dentro de outro laço, dizemos que o laço interior está
aninhado.
O laço while
• O segundo laço disponível em C é o laço while.

• Sintaxe: while(expressão de teste)
{
instrução;
}
• Se a expressão de teste for verdadeira, o corpo do laço while é executado uma
vez e a expressão de teste é avaliada novamente. Este ciclo de teste e execução é
repetido até que a expressão de teste se torne falsa.
• O corpo do laço while pode ter uma única instrução terminada por ponto-e-
vírgula, várias instruções entre chaves ou ainda nenhuma instrução mantendo o
ponto-e-vírgula.
• O próximo exemplo mostra com utilizar um laço while de maneira semelhante
ao laço for.
#include <stdio.h>
#include <stdlib.h>
main()
{
int cont = 0, total = 0; /* expressao de inicializacao */
while( cont < 10 ) /* expressao de teste */
{
total += cont;
printf(“cont = %d, total = %d\n”, cont, total);
cont++; /* expressao de incremento */
}
system("pause");
}
• Em situações em que o número de iterações é préviamente conhecido, como no
exemplo acima, o laço for é a escolha mais natural.
29
• O laço while é apropriado em situações em que o laço pode ser terminado

inesperadamente por condições desenvolvidas dentro do laço.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
int cont = 0;
char op = ‘S’ ;
printf("Digite S para continuar ou N para parar a impressão dos numeros: ”);

scanf(" %c ", &op) ;
while( op == ‘S’ )
{
printf(“\n\ Numero %d.\n \n”, cont);
printf("Continuar ? [S] ou [N]: ”);
scanf(" %c ", &op) ;
}
system("pause");
}
• O programa seguinte calcula o fatorial de um número. O fatorial de um inteiro N

é o produto de todos os inteiros entre 1 e N. Por exemplo, fatorial de 5 é
1x2x3x4x5 = 120. O fatorial de 0 por definição é 1.
#include <stdio.h>
#include <stdlib.h>
main()
{
int num;
float fat;
while(1)
{
printf(“\nInforme um numero: ”);
fat = 1;
while( num > 1 )
fat *= num--;
printf(“\nO fatorial eh: %f \n”, fat);
}
system("pause");
}
• O laço while mais externo é um laço infinito (expressão de teste é sempre

verdadeira). Você deverá pressionar as teclas [Ctrl][Break] para terminar a
execução.
30
Laços while aninhados
• Laços aninhados permitem gerar programas interessantes.
O laço do-while
• O último laço em disponível em C é o laço do-while que cria um ciclo repetido

até que a expressão de teste seja falsa.
• A diferença entre os laços while e do-while é que no do-while a expressão de
teste é avaliada depois do laço ser executado. Assim, o laço do-while é sempre
executado pelo menos uma vez.
• Sintaxe:
do
{
instrução;
}
while(expressão de teste);
• Embora as chaves não sejam necessárias quando apenas uma instrução está
presente no corpo do laço do-while, elas são usadas para aumentar a
legibilidade.
• O programa seguinte mostra uma variação do programa fatorial visto
anteriormente.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
int num;
float fat;
do
{
fat = 1;
while( num > 1 )
fat *= num--;
printf(“\nContinua [s/n]: ”);
}
while( getche() == ‘s’ );
system("pause");
}
31
O comando break
• O comando break pode ser usado no corpo de qualquer laço C. Causa a saída
imediata do laço. Se o break estiver em estruturas de laços aninhados, afetará
somente o laço que o contém e os laços internos a este.
• Como exemplo voltaremos ao programa fatorial que usa um laço infinito, e
inserimos uma instrução break.
#include <stdio.h>
#include <stdlib.h>
main()
{
int num;
float fat;
while(1)
{
fat = 1;
while( num > 1 )
fat *= num--;
break;
}
system("pause");
}
• Com a modificação, o programa calcula o fatorial de um único número.
32
Capítulo 5 – Vetores
• Um vetor é uma coleção de variáveis do mesmo tipo que é referenciada por um

único nome. Um elemento específico em uma matriz é acessado através de um
índice.
• Em C, todas os vetores consistem em posições contíguas na memória. O endereço
mais baixo corresponde ao primeiro elemento e o mais alto ao último elemento.
• Vetores podem ter várias dimensões. Os vetores mais comuns são as
unidimensionais e os bidimensionais ou matrizes (que serão apresentados na
disciplina de Programação de Computadores II no segundo período).
Vetores Unidimensionais
• Os vetores precisam ser declarados, como qualquer outra variável, para que o
compilador conheça o tipo do vetor e reserve espaço de memória suficiente para
armazená-lo.
Declaração de um vetor
• A forma geral para se declarar um vetor é:

tipo nome_var[tamanho];
• Aqui, tipo declara o tipo base do vetor, isto é, o tipo de cada elemento do vetor. E,
tamanho define quantos elementos o vetor irá guardar.
• Por exemplo:
float notas[50];
• A palavra float declara que todo elemento do vetor é do tipo float, notas é o
nome dado ao vetor e [50] indica que o vetor terá 50 elementos do tipo float. Por
definição um vetor é composto por elementos de um único tipo.
Referenciando elementos de um vetor

• Uma vez declarado o vetor, precisamos de um modo de referenciar seus
elementos individualmente. Isto é feito especificando a posição do elemento do
vetor que queremos referenciar entre colchetes seguindo o nome do vetor.
• Os elementos do vetor são sempre numerados por índices iniciados por 0. O
vetor do nosso exemplo tem 50 elementos de notas[0] até notas[49].
• Assim, notas[2] referencia o terceiro elemento do vetor notas, pois o primeiro
elemento é notas[0] e o segundo elemento é notas[1].
• Por exemplo, se quiser armazenar o valor 9.5 no terceiro elemento do vetor
notas, use:
notas[2] = 9.5;
33
• Também podemos obter o valor já armazenado em um elemento do vetor. O

exemplo abaixo adiciona o valor contido no terceiro elemento do vetor notas ao
valor armazenado em uma variável chamada soma:
soma = soma + notas[2];
• Ao invés de usarmos constantes para indicar a posição do vetor que desejamos
referenciar, como a constante 2 no exemplo acima, podemos utilizar uma
variável. Neste caso o valor armazenado na variável determina a posição do
vetor que estamos referenciando.
int i = 5;
printf(“%f”, notas[i]);
• Neste exemplo a função printf imprime o valor armazenado no sexto elemento
do vetor notas.
• Vejamos um exemplo completo. O programa abaixo calcula a média aritmética
das notas de uma classe de 50 alunos.
#include <stdio.h>
#include <stdlib.h>
main()
{
float notas[50];
float soma = 0.0;
int i;
for(i = 0; i < 50; i++)

{
printf(“Informe a nota do aluno %d: ”, i);
scanf(“%f”, &notas[i]);
}
for(i = 0; i < 50; i++)
soma = soma + notas[i];
printf(“Media das notas: %.2f”, soma/50);

system(“PAUSE”);
}
Segunda versão: Uma versão mais elaborada e organizada.
(Fazer em sala)
• Na função scanf() utilizamos o operador & junto ao elemento do vetor pois

notas[i] é uma variável como outra qualquer.
• O segundo laço for adiciona os valores contidos nos elementos do vetor à
variável soma. Quando todas as notas forem adicionadas, o resultado é então
dividido pelo número de elementos para encontrar a média.
• Vamos tentar melhorar o exemplo anterior:
34
#include <stdio.h>
#include <stdlib.h>
#define MAX 10 // define uma macro MAX como constante de valor 10
main()
{
float notas[MAX], soma = 0.0;
int i;
for(i = 0; i < MAX; i++)

{
soma += notas[i];
}
printf(“Media das notas: %.2f”, soma/50);
}
• A eliminação de um dos laço for torna o programa mais rápido. Outra
modificação neste programa foi o uso da diretiva #define para declarar MAX
como uma constante de valor 10. Quando o compilador encontra #define, ele
substitui cada ocorrência de MAX no programa por 10.
• Nós usamos MAX na declaração do vetor. O uso de constantes para dimensionar
vetores é comum em C pois, se com o passar do tempo quisermos aumentar ou
diminuir este valor, precisamos apenas trocar o 10 da diretiva #define pelo
número desejado e a troca refletirá em qualquer lugar do programa onde MAX
aparece. Particularmente, usaremos a declaração de constantes usando a palavra
reservada const, ou seja: const int MAX = 10;
Lendo um número desconhecido de elementos
• O programa seguinte suporta uma classe de até 50 alunos e pode aceita qualquer
número de notas.
#include <stdio.h>
#include <stdlib.h>
const int tam = 50;
main()
{
float notas[tam], soma = 0.0;
int i = 0;
do
35
{
if(notas[i] > 0)
soma += notas[i];
}
while(notas[i++] >= 0);
printf(“Media das notas: %.2f”, soma/(i-1));

}
• O laço for foi substituído pelo laço do-while. Este laço repete até que seja
fornecido um valor menor que zero. Quando o último item for digitado, a
variável i terá alcançado um número acima do número total de itens (pois é
contado o número negativo que o usuário fornece para finalizar a entrada).
Portanto, para encontrar o número de itens válidos devemos subtrair 1 do valor
contido em i.
Checando limites
• A linguagem C não realiza verificação de limites em vetores, isto é, C não avisa

quando o limite de dimensionamento de um vetor foi excedido. Como
programador você tem a responsabilidade de providenciar a verificação dos
limites sempre que necessário para evitar erros.
• Então vamos mudar o nosso exemplo para evitar que o usuário digite dados para
elementos do vetor acima do limite:
#include <stdio.h>
#include <stdlib.h>
const int tam = 50;

main()
{
float notas[tam], soma = 0.0;
int i = 0;
do
{
if( i >= tam )
{
printf(“\nBuffer cheio\n”);
i++;
break; /* sai do laco do-while */
}
if(notas[i] > 0)
soma += notas[i];
}
while(notas[i++] ≥ 0);
printf(“Media das notas: %.2f”, soma/(i-1));

}
36
• Agora quando i atingir 50, a mensagem “Buffer cheio” será impresso e o

comando break fará com que a execução saia do laço do-while e passe para a
segunda parte do programa.
Inicializando vetores
• A inicialização de uma variável é feita na instrução de sua declaração e é uma

maneira de especificarmos valores iniciais prefixados.
• O programa seguinte exemplifica a inicialização de um vetor. O usuário fornece
o preço em centavos e ele calcula quantas moedas de 50 centavos, 25 centavos,
10 centavos, 5 centavos e 1 centavo equivalem à quantia fornecida.
#include <stdio.h>
#include <stdlib.h>
const int tam = 5;
main()
{
int moedas[tam] = {50, 25, 10, 5, 1};
int i, valor, quant;
printf(“Informe o valor em centavos: ”);

scanf(“%d”, &valor);
for(i = 0; i < tam; i++)

{
quant = valor/moedas[i];
printf(“Moeda: %2d quantidade: %2d\n“, moedas[i], quant);
valor %= moedas[i];
}
}
• O vetor moedas contém os valores das várias moedas possíveis. Para inicializar
moedas a lista de valores é colocada entre chaves e os valores são separados por
vírgula.
• Os valores são atribuídos na seqüência, isto é, moedas[0] = 50, moedas[1] = 25 e
assim por diante até moedas[4] = 1.
37

Programação de Computadores I Apostila de C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programação de Computadores I Apostila de C

Enviado por

Direitos autorais:

Formatos disponíveis

Programação de Computadores I Apostila de C

• Criada em 1972 por D. M. Ritchie e K. Thompson. Tornou-se uma das mais

• A linguagem C, como todas as outras linguagens de programação, consiste de

• A linguagem C é baseada no conceito de funções. Um programa C é um conjunto

Como criar um programa executável

Utilizaremos como referência o compilador DEV C++ 5.0. Procure baixar e

• Um programa em C consiste de uma ou várias funções. A função main() deve

main() ⇐ primeira função a ser executada

• A função system(“pause”) está definida na biblioteca stdlib.h. Esta função

• Imprimindo cadeia de caracteres:

códigos especiais significado

• Na linguagem C, constantes referem-se a valores fixo que não podem ser

tipo bit bytes escala

• A escolha de nomes significativos para suas variáveis pode ajudá-lo a entender o

• Uma declaração de variável é uma instrução para reservar uma quantidade de

• É possível combinar uma declaração de variável com o operador de atribuição

• Vejamos um exemplo completo:

Tamanho de Campos na Impressão

• Em printf() é possível estabelecer o tamanho mínimo para a impressão de um

• O sinal de menos (-) precedendo a especificação do tamanho do campo justifica

• Além de especificar o tamanho do campo, podemos complementar o campo todo

• Em C um caractere pode ser representado de diversas maneiras: o próprio

• Comentários podem ser colocados em qualquer lugar de seu programa.

#include <stdio.h> /* Biblioteca que contem a funcao printf() */

• Asteriscos dentro de comentários podem ser colocados livremente:

• Não são permitidos os símbolos /* ou */ no interior de um comentário:

/* Estou escrevendo /* um comentário ilegal */

• A função scanf() é outra das funções de E/S implementadas em todos os

O operador de endereço (&)

As funções getche() e getch()

As funções getchar() e putchar()

• Um operador é um símbolo que diz ao compilador para realizar manipulações

• Exemplo 1: programa que calcula a idade em dias

Operador menos unário: -

• Depois desta instrução, o conteúdo de num será 2.

Operadores de incremento (++) e decremento (--)

Precedência dos operadores aritméticos

• Operadores do mesmo nível de precedência são avaliados pelo compilador da

Operadores aritméticos de atribuição: +=, -=, *=, /=, %=

Operadores relacionais e lógicos

• Nos termos operador relacional e lógico, relacional refere-se aos relacionamentos

• Os operadores relacionais podem ser aplicados a qualquer dos tipos de dados

• Tanto operadores lógicos como os relacionais têm menor precedência que os

Capítulo 3 – Comandos de Decisão

• A linguagem C oferece quatro estruturas de decisão: if, if-else, switch e o

• O comando if instrui o computador a tomar uma decisão simples.

Múltiplas instruções no corpo do comando if

• Caso múltiplas instruções sejam necessárias no corpo do comando if elas devem

• Vamos reescrever o programa anterior acrescentando outras instruções ao

• Nos exemplos anteriores o comando if executará a instrução (ou instruções), se a

Comandos if-else aninhados

• Utilizaremos o programa calc.c para exemplificar a utilização de comandos if-

• Uma construção comum em programação é a forma if-else-if. Para exemplificar

• O comando break causa uma saída imediata do switch. Se não existir um

• O próximo programa mostra um exemplo com switch’s aninhados. É um banco de dados

Capítulo 4 – Comandos de Repetição

• Comandos de repetição (também chamados laços) permitem que um conjunto de

A flexibilidade do laço for

Múltiplas instruções no corpo de um laço for

Laço for aninhados

• O segundo laço disponível em C é o laço while.

• O laço while é apropriado em situações em que o laço pode ser terminado

printf("Digite S para continuar ou N para parar a impressão dos numeros: ”);