Material Programação em C I

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Material Prog I CC - Aluno/01 - Apostila C.zip
NOTURNO - Apostila C/Apostila C/Apostila C - Capitulo01.doc
Programação de Computadores I Notas de Aula
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.
Como criar um programa executável
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.
Compilar o programa fonte criando um programa com a extensão .obj em disco. O programa gerado é chamado programa objeto.
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
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.
#include <stdio.h>
main() 
{ 
 printf(“Primeiro programa”); 
} 
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>
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
			%f
			ponto flutuante
			%c
			caracter simples
			%s
			cadeia de caracter
			%e
			notação científica
			%o
			octal
			%u
			decimal sem sinal
			%x
			hexadecimal
			%ld
			decimal longo
			%lf
			ponto flutuante longo
O código de formatação pode ser colocado em qualquer lugar na expressão de controle:
#include <stdio.h>
main() 
{ 
 printf(“O numero %d e’ decimal, %f e’ ponto flutuante”, 10, 10.78); 
} 
Imprimindo cadeia de caracteres:
#include <stdio.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>
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
			void
			0
			0
			sem valor
Modificadores de Tipos
Com exceção do tipo void, os tipos básicos de dados podem ter vários modificadores precedendo-os. Um modificador é usado para alterar o significado do tipo base para adequá-los melhor às necessidades das várias situações. 
Os modificadores são signed, unsigned, long, e short, a tabela abaixo mostra as combinações possíveis dos tipos básicos e modificadores do C. 
			tipo
			bits
			escala
			char
			8
			-128 a 127
			unsigned char
			8
			0 a 255
			signed char
			8
			-128 a 127
			int
			16
			-32768 a 32767
			unsigned int
			16
			0 a 65535
			signed int
			16
			-32768 a 32767
			short int
			16
			-32768 a 32767
			unsigned short int
			16
			0 a 65535
			signed short int
			16
			-32768 a 32767
			long int
			32
			-2147483648 a 2147483647 
			signed long int
			32
			-2147483648 a 2147483647 
			unsigned long int
			32
			0 a 4294967295
			float
			32
			3.4E-38 a 3.4E+38
			double
			64
			1.7E-308 a 1.7E+308
			long double
			80
			3.4E-4932 a 1.1E+4932
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>
main() 
{ 
 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>
main() 
{ 
 printf(“Os alunos sao %3d.\n”, 350); 
 printf(“Os alunos sao %4d.\n”, 350); 
 printf(“Os alunos sao %5d.\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>
main() 
{ 
 printf(“%.4f\n”, 3456.789); 
 printf(“%.3f\n”, 3456.789); 
 printf(“%.2f\n”, 3456.789); 
 printf(“%.1f\n”, 3456.789); 
} 
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>
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>
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
Além de especificar o tamanho do campo, podemos complementar o campo todo ou parte dele com zeros à esquerda. Exemplo:
#include <stdio.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 caracter pode ser representado de diversas maneiras: o próprio caracter entre aspas simples ou sua representação decimal, hexadecimal ou octal segundo a tabela ASCII.
A tabela ASCII tem 256 códigos decimais numerados de 0 a 255. Cada código decimal corresponde à um caracter distinto, por exemplo, o decimal 65 corresponde ao caracter A. 
O exemplo:
#include <stdio.h>
main() 
{ 
 printf(“%d %c %x %o \n”, ‘A’,‘A’,‘A’,‘A’ ); 
} 
imprime:
65 A 41 101
O exemplo:
#include <stdio.h>
main() 
{ 
 printf(“%c %c %c %c \n”, ‘A’,65,0x41,0101); 
} 
imprime:
A A A A
Um octal em C sempre é iniciado por 0 e um hexadecimal por 0x para que o compilador saiba diferenciá-los de números decimais.
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.c */
/* Programa para imprimir o resultado de uma corrida*/
#include <stdio.h> /* Biblioteca que contem a funcao printf() */
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); 
} 
Asteriscos dentro de comentários podem ser colocados livremente:
/*****************************************************
* Programa: corrida.c
* 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 */
�PAGE �1�
�PAGE �1�
NOTURNO - Apostila C/Apostila C/Apostila C - Capitulo02.doc
Programação de Computadores I Notas de Aula
Capítulo 2 – Operadores
A função scanf()
A função scanf() é outra das funções de E/S implementadas em todos os compiladores 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.
Toda variável ocupa uma certa localização na memória, e seu endereço é o do primeiro byte ocupado por ela. 
Um inteiro ocupa 2 bytes. Se você declarou a variável n como inteira a atribuiu a ela o valor 2, quando n for referenciada devolverá 2. Entretanto, se você referenciar n precedido de & (&n) devolverá o endereço do primeiro byte onde n está armazenada.
O programa seguinte imprime o endereço de n e o valor armazenado em n:
#include <stdio.h>
main() 
{ 
 int n = 2;
 printf(“Endereco: %u, Valor: %d”, n, &n); 
} 
Um endereço de memória é visto como um número inteiro sem sinal, por isso usamos %u.
A tabela abaixo mostra os códigos de formatação da função scanf()
			código
			Significado
			%c
			caracter simples
			%d
			inteiro decimal
			%e
			notação científica
			%f
			ponto flutuante
			%o
			inteiro octal
			%s
			cadeia de caracteres
			%u
			decimal sem sinal
			%x
			hexadecimal
			%l
			inteiro longo
			%lf
			double
Vamos escrever um programa para exemplificar a utilização da função scanf(). O programa também mostra a saída formatada printf():
#include <stdio.h>
main() 
{ 
 char ch;
 printf(“Digite um caracter e veja-o em decimal, ”);
 printf(“octal e hexadecimal \n”);
 scanf(“%c”, &ch);
 printf(“\n %c corresponde a %d em decimal, %o em octal e %x em 
 hexadecimal.\n”, ch, ch, ch, ch);
} 
As funções getche() e getch()
O C oferece funções que lêem um caracter no instante em que é digitado sem esperar [enter]. Essas funções estão definidas na biblioteca conio.h. 
A função getche() lê o caracter do teclado e o imprime na tela imediatamente. Esta função não aceita argumentos e devolve o caracter lido para a função que a chamou.
#include <stdio.h>
#include <conio.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>
#include <conio.h>
main() 
{ 
 char ch;
 printf(“Digite um caracter: ”);
 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>
main() 
{ 
 char ch;
 printf(“Digite um caracter: ”);
 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>
main() 
{ 
 char ch;
 printf(“Digite um caracter: ”);
 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.
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>
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>
main() 
{ 
 int ftemp, ctemp;
 printf(“Informe a temperatura em graus Fahrenheit: ”);
 scanf(“%d”, &ftemp);
 ctemp = (ftemp–32)*5/9;
 printf(“Temperatura em graus Celsius
e’: %d\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>
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): ”);
 scanf(“%d”, &num);
 printf(“O meu numero e’: %d\n”, 9999-num);
 printf(“Informe o quarto número (4 algarismos): ”);
 scanf(“%d”, &num);
 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;
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>
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>
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.
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>
main() 
{ 
 int total = 0;
 int cont = 10;
 printf(“Total: %d\n”, total);
 total += cont;
 printf(“Total: %d\n”, total);
 total *= cont;
 printf(“Total: %d\n”, total);
}
Operadores relacionais e lógicos
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>
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)
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 AND q
			p OR q
			NOT p
			0
			0
			0
			0
			1
			0
			1
			0
			1
			1
			1
			1
			1
			1
			0
			1
			0
			0
			1
			0
O próximo programa ilustra a ação dos operadores lógicos:
#include <stdio.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.
�PAGE �1�
�PAGE �7�
NOTURNO - Apostila C/Apostila C/Apostila C - Capitulo03.doc
Programação de Computadores I
Notas de Aula
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 <conio.h>
main() 
{ 
 char ch;
 ch = getche();
 if( ch == ‘p’)
 printf(“\nVoce pressionou a tecla p.”);
} 
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.
Vamos reescrever o programa anterior acrescentando outras instruções ao corpo do comando if:
#include <stdio.h>
#include <conio.h>
main() 
{ 
 if( getche() == ‘p’) {
 printf(“\nVoce pressionou a tecla p.”);
 printf(“\nPressione qualquer tecla para terminar.”);
 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 <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)
 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 <conio.h>
main() 
{ 
 char ch;
 ch = getche();
 if( ch == ‘p’)
 printf(“\nVoce pressionou a tecla p.”);
 else
 printf(“\nVoce nao pressionou a tecla p.”);
}
O programa seguinte é uma versão muito simples do jogo de adivinhar o “número mágico”:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
main()
{
 int magico, palpite;
 srand((unsigned) time(NULL));
 magico = rand()%10;
 printf("\nAdivinhe o numero magico [0-9]: ");
 scanf("%d", &palpite);
 if( palpite == magico )
	printf("Certo! ");
 else
	printf("Errado! ");
 printf("O numero magico eh: %d\n", magico);
}
O programa produz um número mágico usando o gerador de números aleatórios rand(), que devolve um número arbitrário entre 0 e RAND_MAX. A função srand() evita que rand() gere sempre o mesmo número aleatório, para tanto deve sempre utilizar uma semente diferente. rand(), srand e RAND_MAX estão definidos na biblioteca stdlib.h.
A função time() retorna a hora local em segundos e está definida na biblioteca time.h.
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>
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);
}
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>
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);
}
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.
Vamos utilizar o if-else-if para melhorar o programa do “número mágico”:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
main()
{
 int magico, palpite;
 srand((unsigned) time(NULL));
 magico = rand()%10;
 printf("\nAdivinhe o numero magico [0-9]: ");
 scanf("%d", &palpite);
 if( palpite == magico ) {
	printf("Certo! ");
 printf("O numero magico eh: %d\n", magico);
 }
 else if( palpite > magico )
 printf(“Errado, muito alto\n”); 
 else printf(“Errado, muito baixo\n”); 
}
Operador condicional ternário: ?
O operador condicional ? nos dá uma maneira compacta de expressar uma instrução if-else simples.
Sintaxe: condição ? expressão1 : expressão2;
A condição é avaliada e ser for verdadeira a expressão toda assume o valor da expressão1, se for falsa a expressão assume o valor da expressão2.
Exemplo:
#include <stdio.h>
main() 
{ 
 int num1, num2, max;
 printf(“\nInforme dois numeros: ”);
 scanf(“%d %d”, &num1, &num2);
 max = (num1 > num2) ? num1 : num2;
 printf(“\nO maior numero eh: %d”, max); 
}
Esta expressão é equivalente à construção if-else seguinte:
if( num1 > num2 )
 max = num1;
else
 max = num2;
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(expressão constante) {
 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.c fazendo uso do comando switch.
#include <stdio.h>
main() 
{ 
 float num1, num2;
 char op;
 printf(“\nDigite uma expressão
no formato: num op num: ”);
 scanf(“%f %c %f”, &num1, &op, &num2);
 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>
main() 
{ 
 float num1, num2;
 char op;
 printf(“\nDigite uma expressão no formato: num op num: ”);
 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 ‘/’:
 printf(“ = %f”, num1/num2); break;
 default:
 printf(“\nOperador desconhecido”);
}
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 <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");
	 printf("Informe a primeira letra do nome do vendedor: ");
	 vendedor = getche();
	 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");
 	 printf("Informe a primeira letra do nome do vendedor: ");
	 vendedor = getche();
	 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");
	 }
 }
 }
�PAGE �1�
�PAGE �2�
NOTURNO - Apostila C/Apostila C/Apostila C - Capitulo04.doc
Programação de Computadores I 	 Notas de Aula
Capítulo 4 – Comandos de Iteração
Comandos de iteraçã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>
main() 
{ 
 int cont;
 for(cont = 0; cont < 10; cont++)
 printf(“cont = %d\n”, cont);
} 
O programa executa 10 vezes a instrução printf(). Vamos mudar o programa acima para que imprima os números de 9 a 0.
#include <stdio.h>
main() 
{ 
 int cont;
 for(cont = 9; cont >= 0; cont--)
 printf(“cont = %d\n”, cont);
} 
O próximo programa imprime os números de 0 a 9 de 3 em 3:
#include <stdio.h>
main() 
{ 
 int cont;
 for(cont = 0; cont < 10; cont+=3)
 printf(“cont = %d\n”, cont);
} 
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>
main() 
{ 
 int x, y;
 for(x = 0, y = 0; x+y < 100; x++, y++)
 printf(“%d ”, x+y);
} 
Podemos usar caracteres em vez de inteiros para controlar o laço. Este programa imprimirá as letra minúsculas do alfabeto e seus respectivos códigos decimais da tabela ASCII:
#include <stdio.h>
main() 
{ 
 char ch;
 for(ch = ‘a’; ch <= ‘z’; ch++)
 printf(“O valor ASCII de %c e’ %d \n”, ch, ch);
} 
Podemos usar chamadas a funções em qualquer uma das expressões do laço. Este programa lê caracter a caracter e imprime o caracter seguinte a partir do código ASCII:
#include <stdio.h>
main() 
{ 
 char ch;
 for(ch = getche(); ch != ‘x’; ch = getche())
 printf(“Depois do %c vem o %c\n”, ch, ch+1);
} 
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. 
#include <stdio.h>
main() 
{ 
 char ch;
 for(; (ch = getche()) != ‘x’; )
 printf(“O valor ASCII de %c e’ %d \n”, ch, ch+1);
} 
Se a condição de teste não está presente é considerada permanentemente verdadeira.
#include <stdio.h>
main() 
{ 
 char ch;
 for( ;; )
 printf(“Laco infinito\n”);
} 
O corpo do laço pode ser vazio, entretanto o ponto-e-vírgula permanece:
#include <stdio.h>
main() 
{ 
 char ch;
 for( ; (ch = getche()) != ‘x’; printf(“ %c ”, ch+1))
 ;
} 
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>
main() 
{ 
 int cont, total;
 for(cont = 0, total = 0; cont < 10; cont++) {
total += cont;
 printf(“cont = %d, total = %d\n”, cont, total);
 }
} 
Laço for aninhados
Quando um laço está dentro de outro laço, dizemos que o laço interior está aninhado. Para mostrar esta estrutura preparamos um programa que imprime a tabuada.
#include <stdio.h>
main()
{
 int i, j, k;
 printf("\n");
 for( k = 0; k <= 1; k++){
 printf("\n");
 	for( i = 1; i < 5; i++ )
	 printf("Tabuada do %d ", i+4*k+1);
	printf("\n");
	for( i = 1; i <= 10; i++ ) {
	 for( j = 2+4*k; j <= 5+4*k; j++ )
		printf("%2d x%2d = %2d ", j,i,j*i);
	 printf("\n");
	}
 }
}
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>
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 */
 }
} 
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.
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 <conio.h>
main() 
{ 
 int cont = 0; 
 printf(“Digite uma frase: ”);
 while( getche() != ‘\r’ ) 
 cont++;
 printf(“\nO numero de caracteres eh: %d \n”, cont);
} 
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 <conio.h>
main() 
{ 
 int num; 
 float fat;
 while(1){
 printf(“\nInforme um numero: ”);
 scanf(“%d”, &num);
 fat = 1;
 while( num > 1 ) 
 fat *= num--;
 printf(“\nO fatorial eh: %f \n”, fat);
 }
} 
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.
Laços while aninhados
Laços aninhados permitem gerar programas interessantes. Por exemplo, considere o seguinte programa que testa sua capacidade de adivinhação.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
 char ch, c;
 char opcao = ‘s’;
 int tentativas;
 while( opcao == ‘s’ ) {
 ch = rand()%26 + ‘a’;
 tentativas = 1;
 printf(“\nInforme uma letra [a-z]: “);
 while( (c = getche()) != ch ) {
 printf(“\nVoce errou. Tente novamente.\n\n”);
 tentativas++;
 }
 printf(“\nVoce acertou em %d tentativas”, tentativas);
 printf(“\nQuer jogar novamente [s/n]: “);
 opcao = getche();
 }
}
A expressão rand()%26 produz um número entre 0 e 25. A este número é somado o caracter ‘a’ para gerar letras entre a e z.
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>
main() 
{ 
 int num; 
 float fat;
 do{
 printf(“\nInforme um numero: ”);
 scanf(“%d”, &num);
 fat = 1;
 while( num > 1 ) 
 fat *= num--;
 printf(“\nO fatorial eh: %f \n”, fat);
 printf(“\nContinua [s/n]: ”);
 }while( getche() == ‘s’ );
} 
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 <conio.h>
main() 
{ 
 int num; 
 float fat;
 while(1){
 printf(“\nInforme um numero: ”);
 scanf(“%d”, &num);
 fat = 1;
 while( num > 1 ) 
 fat *= num--;
 printf(“\nO fatorial eh: %f \n”, fat);
 break;
 }
} 
Com a modificação, o programa calcula o fatorial de um único número.
�PAGE �1�
�PAGE �1�
NOTURNO - Apostila C/Apostila C/Apostila C - Capitulo05.doc
Programação de Computadores I 	 Notas de Aula
Capítulo 5 – Matrizes
Uma matriz é 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 as matrizes 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.
Matrizes podem ter várias dimensões. As matrizes mais comuns são as unidimensionais e as bidimensionais.
Matrizes Unidimensionais
As matrizes unidimensionais são conhecidas como vetores. 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;
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>
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);
 } 
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:
#include <stdio.h>
#define MAX 10
main() 
{ 
 float notas[MAX], soma = 0.0;
 int i;
 for(i = 0; i < MAX; i++) {
 printf(“Informe a nota do aluno %d: ”, i);
 scanf(“%f”, &notas[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.
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>
#define MAX 50
main() 
{ 
 float notas[MAX], soma = 0.0;
 int i = 0;
 do{
 printf(“Informe a nota do aluno %d: ”, i);
 scanf(“%f”, &notas[i]);
 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>
#define MAX 50
main() 
{ 
 float notas[MAX], soma = 0.0;
 int i = 0;
 do{
 if( i >= MAX ) {
 printf(“\nBuffer cheio\n”);
 i++;
 break; /* sai do laco do-while */
 }
 printf(“Informe a nota do aluno %d: ”, i);
 scanf(“%f”, &notas[i]);
 if(notas[i] > 0) 
 soma += notas[i];
 }while(notas[i++] ( 0);
 
 printf(“Media das notas: %.2f”, soma/(i-1));
 } 
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>
#define 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.
Strings
O uso mais comum de vetores é como uma string de caracteres. Uma string é usada para armazenar e manipular textos como palavras, nomes e sentenças. 
Uma string é um vetor do tipo char terminada pelo caracter ‘\0’ (null). Por essa razão, você precisa declarar strings como sendo um caracter mais longo que a maior string que elas devem guardar. Isso reserva espaço para o null no final da string. A terminação ‘\0’ é importante, pois é a única maneira que as funções possuem para poderem reconhecer onde é o fim da string.
Strings constantes
Sempre que o compilador encontrar qualquer coisa entre aspas duplas, ele reconhece que se trata de uma string constante, isto é, os caracteres entre as aspas mais o caracter null. 
No exemplo, “Saudacoes!” é uma string constante:
printf(“%d”, “Saudacoes!”);
A função scanf()
Uma das maneiras de receber uma string do teclado é através da função scanf() pelo formato %s.
#include <stdio.h>
main() 
{ 
 char nome[15];
 printf(“Digite seu nome: ”);
 scanf(“%s”, nome);
 printf(“Bom dia %s\n“, nome);
} 
A instrução scanf lê cada caracter não branco e os armazena a partir do endereço nome. O processo termina quando um caracter branco é encontrado.
Você deve ter notado que não usamos o operador & precedendo a string nome, isto porque o nome de um vetor corresponde ao seu endereço inicial não é necessário utilizar o operador &.
A função scanf() é bastante limitada para a leitura de strings, porque scanf() utiliza qualquer espaço em branco para terminar a entrada. O resultado é que não existe uma forma de digitar um texto de múltiplas palavras numa única variável usando scanf().
A função gets()
A função gets() é uma função mais conveniente para a leitura de strings. Esta função lê caracteres até encontar o caracter de nova linha (‘\n’) que é gerado pressionando-se
a tecla [Enter]. Todos os caracteres anteriores ao ‘\n’ são armazenados na string, inclusive espaços e tabulações.
A função gets() é definida na biblioteca stdio.h.
#include <stdio.h>
main() 
{ 
 char nome[80];
 printf(“Digite seu nome: ”);
 gets(nome);
 printf(“Bom dia %s\n“, nome);
} 
Inicializando strings
O compilador oferece uma forma de inicialização de strings bastante simples. Basta colocar a string constante entre aspas duplas e atribuí-la a variável. O uso desta forma causa a inclusão automática do caracter ‘\0’ no final da string.
#include <stdio.h>
main() 
{ 
 char saudacao[] = “Bom dia “;
 char nome[80];
 printf(“Digite seu nome: ”);
 gets(nome);
 printf(“%s %s\n“, saudacao, nome);
} 
Outras funções de manipulação de strings
Vários compiladores oferecem, em suas bibliotecas, funções para manipular strings. Aqui veremos 4 delas: strlen(), strcat(), strcmp() e strcpy().
A função strlen()
A função strlen() aceita um endereço de string como argumento e retorna o tamanho da string armazenada a partir deste endereço até um caracter antes de ‘\0’. A função strlen() é definida na biblioteca string.h.
#include <stdio.h>
#include <string.h>
main() 
{ 
 char palavra[80];
 printf(“Digite uma palavra: ”);
 gets(palavra);
 printf(“Sua palavra possui %d letras\n“, strlen(palavra));
} 
A função strcat()
A função strcat() concatena uma cadeia de caracteres em outra. Isto significa que ela acrescenta uma cadeia ao final de outra. A função strcat() é definida na biblioteca string.h.
strcat() toma dois endereços de strings como argumentos e concatena a segunda na primeira. A segunda cadeia não é alterada. Esta função não verifica se a segunda cadeia cabe no final da primeira. 
#include <stdio.h>
#include <string.h>
main() 
{ 
 char saudacao[90] = “Bom dia, ”;
 char nome[80];
 printf(“Digite o seu nome: ”);
 gets(nome);
 strcat(saudacao, nome);
 printf(“\n%s“, saudacao);
} 
A função strcmp()
A função strcmp() é utilizada para comparar duas cadeias de caracteres. A função strcmp() é definida na biblioteca string.h.
strcmp() recebe dois endereços de strings e retorna um número inteiro que indica a diferença numérica do primeiro caracter diferente da primeira cadeia com o da segunda. Então, se este número for:
			menor que zero
			(
			str1 é menor que str2
			igual a zero
			(
			str1 é igual a str2
			maior que zero
			(
			str1 é maior que str2
 Neste contexto, “menor que” ou “maior que” indica que, se str1 e str2 forem colocados em ordem alfabética, o que aparecer primeiro é o menor.
#include <stdio.h>
#include <string.h>
main() 
{ 
 char solucao[] = “branco”;
 char resposta[40];
 printf(“Qual e’ a cor do cavalo branco de Napoleao? ”);
 gets(resposta);
 while( strcmp(resposta, solucao) != 0 ) {
 printf(“\nResposta incorreta. Tente novamente: “);
 gets(resposta);
 }
 printf(“\nCorreto!“);
} 
Veja um exemplo que imprime o valor retornado por strcmp() em várias situações:
#include <stdio.h>
#include <string.h>
main() 
{ 
 printf(“\n%d”, strcmp(“A”, “A”));
 printf(“\n%d”, strcmp(“A”, “B”));
 printf(“\n%d”, strcmp(“B”, “A”));
 printf(“\n%d”, strcmp(“C”, “A”));
 printf(“\n%d”, strcmp(“gato”, “gata”));
} 
A função strcpy()
A função strcpy() recebe dois endereços de strings como argumentos e copia o conteúdo da segunda na primeira. A função strcpy() é definida na biblioteca string.h.
#include <stdio.h>
#include <string.h>
main()
{
 char msg1[30] = "Bom dia pessoal!";
 char msg2[30] = "Boa tarde pessoal!";
 printf("\n%s", msg1);
 strcpy(msg1, msg2);
 printf("\n%s", msg1);
 }
A função strchr()
A função strchr() recebe como argumentos uma string e um caracter e retorna um ponteiro para a primeira ocorrência do caracter na string. Isto significa que, se o caracter faz parte da string a função retorna verdadeiro, caso contrário retorna falso. A função strchr() é definida na biblioteca string.h.
#include <stdio.h>
#include <string.h>
main()
{
 char palavra[80], c;
 printf("Digite uma palavra: ");
 gets(palavra);
 printf("Digite uma letra: ");
 c = getche();
 if( strchr(palavra, c) )
 printf("\nO caracter foi encontrado na palavra.");
 else
 printf("\nO caracter nao foi encontrado na palavra.");
}
A função strstr()
A função strstr() recebe como argumentos duas string e retorna um ponteiro para a primeira ocorrência da segunda string na primeira string. Isto significa que, se a segunda string faz parte da primeira a função retorna verdadeiro, caso contrário retorna falso. A função strstr() é definida na biblioteca string.h.
#include <stdio.h>
#include <string.h>
main()
{
 char frase[80], palavra[20];
 printf("Digite uma frase: ");
 gets(frase);
 printf("Digite uma palavra: ");
 gets(palavra);
 if( strstr(frase, palavra) )
 printf("\nA palavra foi encontrada na frase.");
 else
 printf("\nA palavra nao foi encontrada na frase.");
}
As funções strncat(), strncmp(), strncpy()
Estas funções são semelhantes às funções strcat(), strcmp() e strcpy(), respectivamente. A diferença é que elas trabalham com um número fixo de caracteres. Todas recebem um terceiro argumento indicando o número de caracteres a processar. Por exemplo, a função strncat() concatena n caracteres da segunda cadeia na primeira; strcmp() compara n caracteres das cadeias; e strncpy() copia n caracteres da segunda cadeia para a primeira.
Exemplo utilizando strncat():
#include <stdio.h>
#include <string.h>
main()
{
 char destino[50] = "Estados";
 char fonte[] = " Unidos da America";
 strncat(destino, fonte, 7);
 printf("%s\n", destino);
 }
Exemplo utilizando strncmp():
#include <stdio.h>
#include <string.h>
main()
{
 char str1[50] = "Estados Unidos da America";
 char str2[50] = "Estados Unidos";
 if( strncmp(str1, str2, 14) == 0 )
 printf("\nAs strings sao iguais");
 else
 printf("\nAs strings sao diferentes");
}
Exemplo utilizando strncpy():
#include <stdio.h>
#include <string.h>
main()
{
 char str1[] = "Estados Unidos da America";
 char str2[50];
 strncpy(str2, str1, 14);
 printf("\n%s", str2);
 }
Matrizes Bidimensionais
Na verdade, em C, o termo duas dimensões não faz sentido, pois todas as matrizes são armazenadas na memória de forma linear. Usaremos este termo para indicar matrizes em que os elementos são vetores.
Matrizes bidimensionais são armazenadas na forma linha-coluna. As linhas representam os elementos da matriz bidimensional e as colunas representam os elementos do vetor. Lembre-se que cada elemento da matriz bidimensional é um vetor.
Declaração de uma matriz
A forma geral para se declarar uma matriz é:
tipo nome_matriz[mum_linhas][num_colunas];
Aqui, tipo declara o tipo base do vetor, isto é,
o tipo de cada elemento do vetor. E, num_linhas define o número de elementos da matriz e num_colunas define o número de elementos do vetor.
Por exemplo:
int matriz[4][5];
O exemplo declara uma matriz com 4 linhas, cada linha contendo 5 colunas. Assim, matriz possui 4 linhas numeradas de 0 até 3 e 5 colunas numeradas de 0 até 4. Em matriz podemos armazenar 4*5 = 20 inteiros.
			
			0
			1
			2
			3
			4
			0
			1
			2
			3
			4
			5
			1
			6
			7
			8
			9
			10
			2
			11
			12
			13
			14
			15
			3
			16
			17
			18
			19
			20
Referenciando elementos de uma matriz
Precisamos de um modo para referenciar os elementos de uma matriz individualmente. Isto é feito especificando a posição do elemento dentro da matiz, ou seja, especificando a linha e a coluna em que ele se encontra.
Por exemplo, se quisermos referenciar o valor 8 da matriz acima basta escrever matriz[1][2], pois o valor 8 está armazenado na coluna 2 da linha 1.
Outro exemplo, se quiser armazenar o valor 21 na coluna 1 da linha 3, use:
matriz[3][1] = 21;
Também podemos obter o valor já armazenado em um elemento da matriz. O exemplo abaixo adiciona dois valores armazenados em matriz e atribui a soma à variável soma:
soma = matriz[0][0] + matriz[0][1];
 Ao invés de usarmos constantes para indicar a linha e a coluna da matriz que desejamos referenciar, podemos utilizar variáveis. Neste caso os valores armazenados nas variáveis determinam a posição da matriz que estamos referenciando.
int i = 1, j = 4
printf(“%d”, matriz[i][j]);
Neste exemplo a função printf() imprime o valor 10 que está armazenado na coluna 4 da linha 1 de matriz.
O seguinte programa usa uma matriz para armazenar as notas de cada aluno de uma turma. O programa assume que o professor tem três turmas e um máximo de 30 alunos por turma.
#include <stdio.h>
#define TURMA 3
#define ALUNOS 30
main() 
{ 
 float notas[TURMA][ALUNOS];
 float media[TURMA] = {0.0, 0.0, 0.0};
 int i, j;
 for(i = 0; i < TURMA; i++) {
 printf(“\n\nTurma %d \n”, i+1);
 for(j = 0; j < ALUNOS; j++) {
 printf(“Informe a nota do aluno %d: ”, j+1);
 scanf(“%f”, &notas[i][j]);
 media[i] += notas[i][j]; 
 }
 }
 for(i = 0; i < TURMA; i++) { 
 media[i] = media[i]/ALUNOS;
 printf(“\nMedia da turma %d: %.2f”, i+1, media[i]);
 }
} 
Inicializando matrizes
As matrizes são inicializadas da mesma maneira que os vetores, isto é, os elementos são colocados entre as chaves depois do sinal de igual e separados por vírgulas. Como cada elemento de uma matriz é por sua vez um vetor, então cada elemento deve estar entre chaves e os elementos internos devem ser separados por vírgula.
Para inicializar uma matriz como com os valores do nosso primeiro exemplo use:
#include <stdio.h>
main() 
{ 
 int matriz[4][5] = { {1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15}, 
 {16,17,18,19,20} };
 int i, j;
 
 for(i = 0; i < 4; i++) {
 for(j = 0; j < 5; j++)
 printf(“%2d ”, matriz[i][j]);
 printf(“\n”);
 }
} 
Matriz de strings
Como uma string é um vetor de caracteres, uma matriz de strings é na realidade uma matriz bidimensional.
O programa seguinte solicita que seja informada uma data e imprime o dia da semana correspondente:
#include <stdio.h>
#include <conio.h>
#define ESC 27
main()
{
 char diasemana[7][14]={ "Domingo", "Segunda-feira", "Terça-feira",
 "Quarta-feira", "Quinta-feira",
 "Sexta-feira", "Sabado" };
 int dia, mes, ano;
 float f;
 do{
 printf("\nDigite a data na forma dd mm aaaa: ");
 scanf("%d%d%d", &dia, &mes, &ano);
 f = ano + dia + 3 * (mes - 1) - 1;
 if( mes < 3 )
 ano--;
 else
 f -= int(0.4 * mes + 2.3);
 
 f += int(ano/4) - int((ano/100 + 1) * 0.75);
 f = int(f)%7;
 printf("%s \n", diasemana[int(f)]);
 }while(getche() != ESC);
}
Observe como a matriz de strings é inicializada. Cada palavra entre aspas é um vetor de caracteres, ou seja, uma string.
�PAGE �1�
�PAGE �11�
Material Prog I CC - Aluno/01 - Tutorial do CodeBlocks.pdf
 
Tutorial Code Blocks 
Instalação: 
Compilador: Code :: Blocks (MinGW) 
Site: http://www.codeblocks.org/downloads/binaries 
Versão: 
codeblocks-10.05mingw-setup.exe 27 May 2010 74.0 MB BerliOS or Sourceforge.net 
 
Link instalação: http://sourceforge.net/projects/codeblocks/files/Binaries/10.05/Windows/codeblocks-
10.05mingw-setup.exe/download 
(Aguarde 5 segundos) 
Passo 1: Após baixar o programa, inicie a instalação com o arquivo executável (codeblocks-10.05mingw-
setup.exe) – Click Next > 
 
Passo 2: Aceite o termo de licença de uso: Click – I Agree (Eu Concordo) 
 
 
Passo 3: Marque todos os componentes – Click Next > 
 
Passo 4: Escolher o Local de Instalação – Pode deixar o padrão escolhido automaticamente. 
 
Passo 5: Iniciará a instalação – Aguarde! 
 
 
Passo 6: Aparecerá uma tela: Você deseja rodar o programa agora? Click > YES 
 
Passo 7: A instalação definirá automaticamente o COMPILADOR: GNU GCC Compiler – Click OK 
 
Passo 8: Feche a janela de apresentação do Code Blocks 
 
 
Passo 9: Associação de arquivos – Associa a criação de arquivos em Linguagem C e C++ – Click OK 
 
Passo 10: Instalação completa – Click Next 
 
Passo 11: Instalação completa – Click Finish 
 
 
Criação de um projeto novo: 
PASSO 1: Criar um novo projeto C clicando no Link Create a new Project. 
 
PASSO 2: Escolher New from Template: Console Application. Click GO 
 
PASSO 3: Tela de aplicação do tipo Console 
 
 
PASSO 4: Escolha a Linguagem de Programação – Linguagem C – Click Next 
 
PASSO 5: Nomear o título do projeto e definir um local para salvar o projeto. CRIAR PASTA NOVA 
 
PASSO 6: IMPORTANTE: SALVAR UM PROJETO POR PASTA. Click Next 
 
 
PASSO 7: Escolher o COMPILADOR – Deixar as configurações padrões – Click Finish 
 
PASSO 8: Abrir o Ambiente de Programação (Algoritmo) clicando no ícone main.c 
 
Material Prog I CC - Aluno/02 - Lista de exerc�cios - Algoritmos - 01.pdf.pdf
PROGRAMAÇÃO DE COMPUTADORES I 
Prof. Erlon Pinheiro 
LISTA DE EXERCÍCIOS 4 
 
OBS.: NOS PROBLEMAS ABAIXO FAÇA OS ALGORITMOS EM PORTUGOL. 
 
1. Ler dois valores inteiros para as variáveis A e B e efetuar as operações de 
adição, subtração, multiplicação e divisão de A por B, apresentando ao 
final os resultados obtidos. 
 
2. Efetuar a leitura de um número inteiro e apresentar o resultado do 
quadrado deste número. 
 
3. Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em 
graus Célsius. A fórmula de conversão é: C � (F – 32) * (5 / 9), onde F é 
a temperatura em Fahrenheit e C é a temperatura em Célsius. 
 
4. Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula: 
VOLUME � 3.14159 * R * R * ALTURA. 
 
5. Faça um algoritmo que receba dois números inteiros,