Академический Документы
Профессиональный Документы
Культура Документы
Algoritmos e Linguagem
de Programação C
Autores:
Thales Coelho Borges Lima
Márcio Henrique Zuchini
Fábio Alexandre G. Casotti
Débora Pretti Ronconi
Algoritmos e Linguagem de Programação
i
1. Sistema de Computadores.........................................................................................2
1.1 Arquitetura Típica: Hardware e Software..................................................................2
1.2 Componentes básicos de um computador...................................................................3
1.2.1 Memórias.................................................................................................................................3
1.2.1.1 Memória ROM.................................................................................................................3
1.2.1.2 Memória RAM.................................................................................................................4
1.2.2 Dispositivos de Entrada e Saída...............................................................................................4
1.2.3 Unidade Aritmética e Lógica..................................................................................................4
1.2.4 Unidade de Controle................................................................................................................4
1.3 Processador...................................................................................................................5
1.3.1 A família PC............................................................................................................................5
1.3.2 O exterior de um micro............................................................................................................6
1.4 Bits, Bytes e Palavras...................................................................................................6
1.5 Sistemas de Numeração................................................................................................7
1.5.1 Sistema Binário........................................................................................................................7
1.5.1.1 Conversão do sistema binário para o sistema decimal.....................................................8
1.5.1.2 Conversão do sistema decimal para o sistema binário.....................................................8
1.5.2 Sistema octal de numeração.....................................................................................................9
1.5.2.1 Conversão do sistema octal para o decimal......................................................................9
1.5.2.2 Conversão do sistema octal para o binário.......................................................................9
1.5.2.3 Conversão do sistema binário para octal..........................................................................9
1.5.2.4 Conversão do sistema decimal para octal.......................................................................10
1.5.3 Sistema Hexadecimal.............................................................................................................10
1.5.3.1 Conversão do sistema hexadecimal para o decimal.......................................................11
1.5.3.2 Conversão do sistema hexadecimal para o binário........................................................11
1.5.3.3 Conversão do sistema binário para o hexadecimal........................................................11
1.5.3.4 Conversão do sistema decimal para o hexadecimal.......................................................11
2. Algoritmos e Programas.........................................................................................12
3. Dados e Tipos de Dados..........................................................................................20
3.1 Dados Numéricos.........................................................................................................20
3.2 Dados não-numéricos.................................................................................................20
3.3 Código ASCII..............................................................................................................21
3.4 Operadores para manipulação de dados...................................................................21
3.4.1 Operadores Aritméticos.........................................................................................................21
3.4.2 Operadores de Relação...........................................................................................................22
3.4.3 Operadores Lógicos................................................................................................................22
3.5 Variáveis......................................................................................................................23
3.5.1 Identificadores.......................................................................................................................23
3.6 Constantes....................................................................................................................24
3.7 Operação de atribuição...............................................................................................24
3.7.1 Expressões..............................................................................................................................24
3.7.1.1 Prioridade dos operadores em uma expressão ..............................................................25
3.8 Funções Embutidas.....................................................................................................25
3.9 Comandos de Entrada e Saída...................................................................................26
3.9.1 Comando LEIA......................................................................................................................26
3.9.2 Comando ESCREVA.............................................................................................................26
4. Estruturas de Decisão.............................................................................................28
4.1 Bloco de Comandos.....................................................................................................30
4.2 Comandos Ses Aninhados ( Encaixados ).................................................................31
Algoritmos e Linguagem de Programação
ii
9. Vetores e Matrizes...................................................................................................57
9.1 Matriz de uma dimensão - Vetores............................................................................57
9.2 Matriz com Duas Dimensões......................................................................................58
9.3 Cadeia ( Strings ).........................................................................................................58
9.3.1 Lendo uma string ...................................................................................................................59
9.3.2 Exibindo uma string...............................................................................................................59
9.3.3 Funções para manipulação de strings em C..........................................................................59
9.3.3.1 Função strcpy()................................................................................................................59
9.3.3.2 Função strcat().................................................................................................................60
9.3.3.3 Função strcmp()...............................................................................................................60
9.3.3.4 Função strlen().................................................................................................................60
10. Funções e estrutura de um Programa em C........................................................61
10.1 Regra de escopo das funções....................................................................................62
10.1.1 Variáveis Locais...................................................................................................................62
10.1.2 Variáveis globais..................................................................................................................63
10.1.3 Parâmetros formais...............................................................................................................63
10.2 Funções que retornam valores.................................................................................64
10.2.1 Valores de Retorno...............................................................................................................64
10.3 Argumentos das Funções..........................................................................................65
10.3.1 Chamada por Valor e Chamada por Referência..................................................................65
10.3.1.1 Como criar uma chamada por referência em C............................................................66
10.4 Protótipos de Funções...............................................................................................66
11. Ponteiros................................................................................................................66
11.1 Operadores de Ponteiros..........................................................................................67
11.2 Aritmética com ponteiros..........................................................................................67
11.3 Ponteiros e vetores.....................................................................................................67
11.4 Passando vetores e matrizes para dentro de uma função em C.............................68
12. Arquivos.................................................................................................................69
12.1 Operações com Arquivos em Disco em C................................................................69
12.1.1 Leitura e Gravação em Alto Nível.......................................................................................69
12.1.2 Arquivos Texto e Binário.....................................................................................................69
12.1.3 Abrindo um Arquivo em Disco............................................................................................69
12.1.4 Escrevendo em um arquivo..................................................................................................70
12.1.5 Fechando um arquivo...........................................................................................................70
12.1.6 Lendo Dados de um Arquivo...............................................................................................71
12.1.7 Fim de Arquivo....................................................................................................................72
12.1.8 Gravando uma cadeia de caracteres ( bytes )......................................................................72
12.1.9 Lendo uma cadeia de caracteres ( bytes ) em um arquivo..................................................72
12.1.9.1 Enviando uma string para a impressora........................................................................73
12.1.10 Gravando um arquivo de forma Formatada.......................................................................73
12.1.11 Lendo um arquivo Formatado............................................................................................73
12.1.12 Lendo e Gravando Registros em um Arquivo...................................................................74
12.1.12.1 Gravando estruturas.....................................................................................................74
12.1.13 Gravando vetores ...............................................................................................................75
12.1.14 Lendo estruturas de um arquivo.........................................................................................75
Algoritmos e Linguagem de Programação
iv
Algoritmos e Linguagem de Programação
1
Algoritmos
Algoritmos e Linguagem de Programação
2
1. Sistema de Computadores
1.2.1 Memórias
São dispositivos para o armazenamento de dados. É a parte do computador onde os
programas e dados são armazenados. A memória é dividida em memória interna ou
principal e memória externa. Os programas e dados a serem executados pelo
computador, residem na memória principal.
A memória principal é constituída de unidades básicas e de mesmo tamanho,
denominada de palavras, sendo que cada palavra tem um endereço correspondente,
para que possa ser acessada de forma única. Cada palavra pode armazenar um pedaço
de informação. As palavras de uma memória contém o mesmo número de bits, que é
a unidade básica. Um bit ( dígito binário ) pode conter o valor 0 ou 1.
A memória externa é constituída de dispositivos capazes de armazenar os
programas, mesmo que o computador não esteja ligado. O custo de memórias
externas é bem menor se comparado com o custo da memória principal, e sua
capacidade de armazenamento é bem superior ao da memória principal. Como
exemplo de memórias externas, podemos citar: os discos rígidos (winchester), os
discos flexíveis (disquetes), as fitas magnéticas, etc.
Figura 1.A
1.3 Processador
O processador é a parte do computador que tem a função de executar os programas
(conjunto de instruções). São de responsabilidade do processador:
- Ler e escrever informações na memória;
- Reconhecer e executar um conjunto de comandos ou instruções;
- Informar a todas as partes do computador o que deve ser feito a cada momento.
É o componente mais importante de um micro. É um chip que realiza todo o
controle do computador: comanda a leitura/escrita de dados nos discos, lê e grava
dados na memória, executa programas, recebe dados de dispositivos como o mouse e
teclado, e transmite dados para dispositivos como impressoras e vídeo.
O microprocessador executa diversas operações matemáticas como: adição,
subtração, multiplicação, divisão e operações lógicas como: OR, AND e NOT.
Também realiza comparações entre dois números para saber qual é o maior, menor ou
se são iguais. Executa decisões em função de comparação. Além de operações
numéricas, podem ser realizadas operações com caracteres, como exemplo, procurar
uma palavra em um texto, trocar todas as ocorrências de um caracter por outro e
outras operações comuns em processamento de texto.
O usuário não comanda diretamente o microprocessador, e sim os programas. Os
programas contém as instruções que são executadas pelo microprocessador.
1.3.1 A família PC
Em 1981, a IBM lançou o 1º Computador pessoal IBM-PC (Personal Computer)
que possuía um microprocessador INTEL 8088 de 4,77 MHz e 64 kbytes de
memória. Mais tarde, a IBM acoplou um disco rígido de 10 Mbytes e passou a
chamá-lo de IBM PC XT (Extended Technology).
Após a INTEL lançou o microprocessador 80286 que passou a ser utilizado no
IBM PC AT (Advanced Technology) com 8 Mhz. Era 6 vezes mais veloz que o 8088.
Em seguida surgiram microprocessadores 80386, 80486 e o PENTIUM.
Algoritmos e Linguagem de Programação
6
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1
0 0 0 0 0 0 1 0
.
.
.
1 1 1 1 1 1 1 1
Decimal Binário
0 0
1 1
2 10
3 11
Algoritmos e Linguagem de Programação
8
4 100
5 101
6 110
4 9 _ 2__
1 24
1º resto: 1
2 4 _ 2__
0 12
2º resto: 0
1 2 _ 2__
0 6
3º resto: 0
6 _ 2__
0 3
4º resto: 0
3 _ 2__
1 1
5º resto: 1
Assim, o número 49 em binário é dado por 110001. Para verificar vamos converter o
número binário 11001 para a base 10:
Algoritmos e Linguagem de Programação
9
Decimal Octal
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 10
9 11
10 12
11 13
12 14
13 15
1 20 _ 8__
0 15 _ 8__
7 1
Portanto, 120 em decimal corresponde a 170 em octal.
O outro método consiste em converter o número decimal para binário e depois
para octal.
Decimal Hexadecimal
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 A
11 B
12 C
13 D
14 E
15 F
16 10
17 11
18 12
19 13
20 14
1000 _16__
8 62 _16__
14 3
Portanto o número é 3E8, pois 14 corresponde a E em hexadecimal.
O segundo método consiste em converter o número para binário e depois para
hexadecimal.
Algoritmos e Linguagem de Programação
12
2. Algoritmos e Programas
2.1. Programas
figura 2.1
2.2. Algoritmos
Solução em
Forma de
Passo Difícil Algoritmo
Fase de
Implementação
Programa de
Computador
figura 2.2
• descer da escada
• guardar a escada
Observamos que o algoritmo para trocar uma lâmpada
queimada passou de 2 para oito passos, após o detalhamento de
cada passo do primeiro algoritmo. Analisando o segundo algoritmo,
vemos que ele constitue de uma seqüência de instruções mais
detalhadas para a execução da tarefa. Portanto, conclui-se que o
algoritmo deve ser formado por um conjunto de passos simples e
bem definidos de forma que possa ser entendido diretamente pelo
agente que irá executá-lo. Suponhamos que o agente seja um
computador. Como o computador não tem conhecimento prévio, o
conjunto de passos de um algoritmo devem estar bem detalhados
de forma que o computador possa reconhece-los e executá-los e
produzir os resultados esperados.
2.2.4.2. Fluxograma
Consiste em uma descrição gráfica do algoritmo. Um
fluxograma mostra a lógica do algoritmo, enfatiza os passos
individuais e suas interconexões.
O fluxograma possui 4 símbolos para representar as
instruções básicas:
Algoritmos e Linguagem de Programação
17
representa um cálculo
entrada de dados
uma decisão
saída de dados
Início
Figura 2.3
Início
nota1, nota2
média =
(nota1+nota2)
2
média>=5?
média média
"Reprovado" "Aprovado"
Fim
Figura 2.4
Início
[ Declaração de variáveis ]
[ Comandos ]
Fim
Algoritmos e Linguagem de Programação
19
Exemplo:
Início
N1,N2,M: real [ declaração das variáveis ]
leia( N1, N2 ) [ lê os dados que são atribuídos às
variáveis N1 e N2 ]
M = ( N1 + N2 )/2 [ avalia a expressão e atribui o
resultado à variável M ]
escreva( "Média: ", M ) [ exibe o resultado, imprimindo a
constante "Média: " e
o valor da variável M ]
Fim
1Para diferenciar valores do tipo caracter com o tipo cadeia, usaremos apóstrofos
( ' ) para delimitar o tipo caracter e aspas ( " ) para cadeia.
Algoritmos e Linguagem de Programação
21
• Dados lógicos ou booleanos: Este tipo de dado pode assumir dois valores:
verdadeiro ou falso.
Resumindo, podemos classificar os tipos de dados como:
Operador Ação
- subtração e o menos unário
+ adição
* multiplicação
/ divisão
Algoritmos e Linguagem de Programação
22
% módulo
Estes operadores são operadores binários, pois envolvem dois elementos. São
aplicados a tipos de dados numéricos. Se somarmos dois números do tipo real ,
teremos como resultado um número real. O mesmo comentário vale para os números
inteiros. Devemos ter cuidado com relação a operação de divisão de números inteiros
pois, se o resultado não for um número inteiro, o resultado será truncado ou
arredondado. Como exemplo, seja a divisão de dois números inteiros: 8/5. O
resultado é 1.6. Como este número não é um número inteiro, o resultado final será 1
(se for truncado) ou 2 ( se for arredondado ).
Se misturarmos tipos diferentes de operandos em operações numéricas, o resultado
será sempre expresso como o tipo do maior operando. Assim, se multiplicarmos um
número inteiro com um número real, o resultado será um número do tipo real, pois o
computador reserva mais espaço para alocar um número real.
O operador módulo é aplicado somente a dados numéricos do tipo inteiro e dá
como resultado, o resto de uma divisão de dois números.
Refere-se às relações que os valores podem ter uns com os outros. São usados para
fazer comparações entre dois valores (operadores binários). Podem ser aplicados a
qualquer tipo de dado básico. O resultado de uma operação relacional é um resultado
booleano: verdadeiro ou falso. Os símbolos que representam os operadores
relacionais são:
Operador Ação
> Maior que
>= Maior ou igual
< Menor
<= Menor ou igual
== Igual a
!= Diferente
A B AEB A OU B NÃO A
V V V V F
V F F V F
F V F V V
F F F F V
se um apenas um dos valores for verdadeiro. O resultado será falso se e somente se,
todos os valores forem falsos.
3.5 Variáveis
b
A área do triângulo é definida por: c = a * b. Podemos definir três variáveis para
representar os dois lados (a e b) e a área do retângulo (c) e atribuir diversos valores
aos lados para obter a área correspondente.
3.5.1 Identificadores
3.6 Constantes
São valores fixos que não podem ser alterados no programa. As constantes podem
ser de qualquer tipo de dado. A forma como são representadas no programa e no
algoritmo, dependem de seu tipo. As constantes do tipo caracter e cadeia são
representadas utilizando delimitadores. A seguir, temos alguns exemplos:
3.7.1 Expressões
Exemplo:
A = 5+10*12-4/2
Primeiramente, o valor da expressão é avaliado e o resultado é então atribuído à
variável A.
Algoritmos e Linguagem de Programação
25
A expressão também pode conter variáveis, sendo que os valores contidos nestas
variáveis devem ser previamente atribuídos. Portanto:
C = 12
D = 32
A = C + D * 19
As variáveis contidas na expressão são substituídas pelos seus valores. A expressão
C+D*19 corresponde na verdade a 12+32*19.
Onde a lista de saída pode exibir o valor de uma variável, o resultado de alguma
expressão, ou o valor de uma constante. Por exemplo:
N1 = 8.34
N2 = 9.12
N3 = 7.34
MEDIA = ( N1 + N2 + N3 ) / 3
ESCREVA ( " A média é: ", media )
↓ ↓
constante variável
Ou:
ESCREVA( N1+N2+N3 )
↓
expressão
4. Estruturas de Decisão
Até o momento, vimos como executar um algoritmo executando
suas instruções seqüencialmente, ou seja, da primeira instrução até
a última do algoritmo. O computador tem a habilidade de tomar
decisões e determinar quais ações serão executadas durante a
execução de um programa.
As estruturas de decisão, tornam possível selecionar uma ação
de um conjunto de alternativas que foram especificadas, podendo
então mudar o curso de execução de um programa.
A Unidade Aritmética e Lógica é a parte do computador onde
as instruções aritméticas e lógicas são executadas. A parte lógica,
permite selecionar uma determinada ação de um conjunto de
possíveis opções, possibilitando a elaboração do comando de
decisão nas linguagens de programação.
O comando de decisão é especificado em uma expressão lógica
que retorna um valor booleano ( verdadeiro ou falso ). Como
exemplo, sejam duas variáveis numéricas A e B cujos valores são
diferentes e queremos determinar qual variável contém o maior
valor. A figura 4.1 mostra a estrutura de um comando de decisão
através de um fluxograma:
S N
A>B
figura 4.1
SE ( condição ) ENTÃO
comando 1
SENÃO
comando 2
SE ( condição ) ENTÃO
comando 1
início
c: caracter
leia( c )
se (c = = ‘a’)
ESCREVA ( “Você pressionou a tecla a” )
fim.
Algoritmos e Linguagem de Programação
30
SE ( condição ) ENTÃO
{
comando 1.1
comando 1.2
comando 1.3
.
.
.
}
SENÃO
{
comando 2.1
comando 2.2
comando 2.3
.
.
.
}
SE ( condição ) ENTÃO
comando 1
comando 2
comando 3
Algoritmos e Linguagem de Programação
31
INÍCIO
c: inteiro
leia ( c )
se ( c >= 0 ) então
se ( c <= 9 ) então
escreva ( “Você digitou um número entre 0 e 9”)
FIM.
INÍCIO
maior_valor, n1, n2, n3: inteiro
se ( n1 > n2 ) então
se ( n1 > n3 ) então
maior_valor = n1
senão
maior_valor = n3
senão
se ( n2 > n3 ) então
maior_valor = n2
senão
maior_valor = n3
escreva (“O maior valor é: “,maior_valor
FIM
SE ( condição 1 ) ENTÃO
SE ( condição 2 ) ENTÃO
comando 1
SENÃO
Algoritmos e Linguagem de Programação
32
comando 2
INÍCIO
nome: cadeia
salário_bruto, salário_líquido: real
leia ( nome, salário_bruto )
se ( salário_bruto <= 2.000 ) então
salário_líquido = salário_bruto - salário_bruto * 0.15
senão
se ( salário_bruto <= 4.000 ) então
salário_líquido = salário_bruto - salário_bruto *
0.25
senão
salário_líquido = salário_bruto - salário_bruto *
0.35
escreva ( “NOME: “, nome )
escreva ( “SALÁRIO LÍQUIDO: “, salário_líquido )
FIM.
se (condição 1) então
se (condição 2) então
se (condição 3) então
se (condição 4) então
comando 1
senão
comando 2
senão
comando 3
senão
Algoritmos e Linguagem de Programação
33
comando 4
senão
comando 5
Para(inicialização; condição;incremento)
comando
Início
a: inteiro
Para(a=1;a<=100;a=a+1)
Escreva(a)
Fim
Início
a: inteiro
Para(a=100;a>=1;a=a-1)
Escreva(a)
Fim
Início
a: inteiro
Para(a=0;a<=100;a=a+5)
Escreva(a)
Fim
Início
a,b: inteiro
Para(a=1;a<=100;a=a+1)
{
b= a*a
Escreva(a)
Escreva(b)
}
Fim
Algoritmos e Linguagem de Programação
36
enquanto (condição) {
comando
}
Enquanto a condição for verdadeira, o comando será
executado. O laço somente termina quando o resultado da
condição tornar falsa. Assim, como no laço Para, a condição é uma
expressão booleana que retorna um valor verdadeiro ou falso, após
ser avaliada.
Para este comando de repetição, deve haver pelo menos um
comando a ser executado, que altere o valor da condição para falso
pois, do contrário, o comando ficará executando infinitamente.
Exemplo:
Início
a: inteiro
a=1
Enquanto(a<=10){
Escreva (a)
a=a+1
}
Fim
faça {
comando
} enquanto (condição)
Algoritmos e Linguagem de Programação
37
Início
a:inteiro
a=1
Faça {
Escreva(a)
a=a+1
} Enquanto(a<=10)
Fim
Para(a=1;a<10;a=a+1)
Enquanto(a != 5)
comando
Exemplo 1:
Enquanto(c<10)
Para(i=0; i<10;i=i+3)
comando
Exemplo 2:
Para(i=1; i<=3;i=i+1)
Para(j=1; j<=4;j=j+1)
comando
Exemplo 3:
Faça{
Para(i=0; i<3;i=i+1)
comando
Algoritmos e Linguagem de Programação
38
c=c+1
} Enquanto( c<3)
2 Algumas linguagens (como C, Pascal ) admite o índice definido como sendo do tipo caracter.
3 Em C, o primeiro elemento de um vetor é referenciado pelo índice 0. Portanto os valores que o
índice pode ter vai de 0 até número máximo de elementos - 1.
Algoritmos e Linguagem de Programação
40
Início
nome1, nome2, nome3, nome4, nome5: cadeia
media, nota1, nota2, nota3, nota4, nota5: real
leia( nome1, nota1, nome2, nota2, nome3, nota3, nome4, nota4,
nome5, nota5 )
media = (nota1+ nota2+ nota3+ nota4+ nota5)/5
se ( nota1 >= media ) então
escreva( nome1 )
se ( nota2 >= media ) então
escreva( nome2 )
se ( nota3 >= media ) então
escreva( nome3 )
se ( nota4 >= media ) então
escreva( nome4 )
se ( nota5 >= media ) então
escreva( nome5 )
fim.
Observe que este algoritmo só é válido para uma classe com 5
alunos. Como ficaria o algoritmo para uma classe com 100 alunos?
Utilizando a mesma abordagem teríamos que declara 100 variáveis
para os nomes dos alunos e mais 100 para as respectivas notas,
além dos 100 comandos de decisão. Portanto, devemos associar as
notas e os nomes dos alunos a um conjunto referenciado pôr
apenas um nome, que nada mais é do que dois vetores: um
contendo os nomes e o outro com as notas. O algoritmo acima
usando vetor ficará:
Início
nome: vetor de [5] de cadeia
nota: vetor de [5] de real
media, soma: real
i : inteiro
soma = 0
para i de 1 até 5, passo 1, faça
{
leia ( nome[i], nota[i] )
soma = soma + nota[i]
}
media = soma/5.0
para i de 1 até 5, passo 1, faça
se ( nota[i] > media ) então
escreva( nota[i] )
fim.
Com este algoritmo, podemos trabalhar com uma classe com
qualquer número de alunos, mudando apenas o valor final da
variável de controle de fluxo.
Algoritmos e Linguagem de Programação
41
nome_da_matriz: matriz[número_de_linhas][número_de_colunas]
de tipo_de_dados
Para realizar uma operação sobre todos os elementos de uma matriz, devemos
usar dois comandos de repetição: um associado às linhas e o outro às colunas. O
exemplo abaixo, mostra como ler valores de entrada e atribuir à matriz.
início
mat: matriz[4][6] de inteiro
linha, coluna: inteiro
para linha de 1 até 4, passo 1, faça
para coluna de 1 até 6, passo 1, faça
leia( mat[linha][coluna] )
fim.
Linguagem de
Programação
C
Algoritmos e Linguagem de Programação
43
Linguagem de Programação C
7. Fundamentos de C
Um programa em C, consiste de um conjunto de uma ou mais funções que
especificam as operações que devem ser realizadas. Todo programa em C inicia-se
chamando uma função especial denominada main(). Esta função marca o início de
um programa C, ou seja, o programa começará a ser executado a partir desta função.
Portanto, todo programa em C, deve ter uma função main() de onde outras funções
podem ser chamadas. Estas outras funções podem ser funções escritas pelo próprio
programador ou funções contidas em bibliotecas da linguagem.
O caracter abre-chave "{", marca o início da função main() e o caracter fecha-
chave "}", indica o término da função. Assim, todas as instruções devem estar
delimitadas pelas chaves e são executadas na ordem que estão escritas no programa.
Quando o compilador chega ao final da função main(), termina-se a execução do
programa.
Todas as instruções em C, são finalizadas pelo caracter ponto-e-vírgula ";". O
ponto-e-vírgula é um terminador de comandos
Abaixo, tem-se a forma geral de um programa em C:
main()
{ /* Início do Programa */
comando 1;
comando 2;
.
.
.
comando n;
}/* Término do Programa */
7.1 Variáveis
Variáveis, são objetos de dados básicos manipulados pelo programa. para dar
nomes às variáveis em C, deve-se obedecer alguns critérios:
• O primeiro caracter dever ser sempre uma letra ou o caracter sublinhado "_".
• Os demais caracteres podem ser letras, números ou o caracter sublinhado.
• Como C é uma linguagem sensível ao caso, nomes de variáveis com letras
maiúsculas serão diferentes de nomes com letras minúsculas. Assim, cont e CONT,
são nomes de variáveis diferentes.
• Os nomes de variáveis não podem ser iguais a nomes de palavras reservadas e
também não podem ser iguais a nomes de funções ou rotinas pertencentes às
bibliotecas padrões.
Algoritmos e Linguagem de Programação
44
Tipo Escala
signed char -128 a 127
unsigned char 0 a 255
signed int -32768 a 32767
unsigned int 0 a 65535
long int -2147483648 a 2147483647
short int -32768 a 32767
int a;
main()
{
int b;
float f;
char c1, c2;
double d1;
}
7.3 Constantes
São valores fixos que não podem ser alterados no programa. As constantes
podem ser de qualquer tipo de dado básico.
Uma constante do tipo caracter ( char ) é um único caracter escrito entre
apóstrofos, como exemplo 'a', '1', etc. Uma constante do tipo inteira é um número na
escala descrita nas tabelas acima. Uma constante do tipo long int deve ser escrita
terminada com a letra L. Assim, como exemplo, 1233L. Um número do tipo float
5Este assunto será abordado com maiores detalhes na parte referente a funções.
Algoritmos e Linguagem de Programação
46
Exemplos:
int a = 100;
float f1 = 12.0, f2 = 13.0, f3;
char b = ‘B’;
7.5 Operadores
São símbolos que informam ao compilador executar determinadas
manipulações matemáticas, relacionais e lógicas. C é um linguagem rica em
operadores ( cerca de 40 ).
Operador Ação
- subtração e menos unário
+ adição
* multiplicação
/ divisão
% resto da divisão ( módulo )
Algoritmos e Linguagem de Programação
47
Operador Ação
> maior
>= maior ou igual
< menor
<= menor ou igual
== igual
!= diferente
Algoritmos e Linguagem de Programação
48
Operador Ação
&& E
|| OU
! NEGAÇÃO
Maior !
> >= < <=
= = !=
&&
Menor ||
if ( (sq=x*x) < 0 )
7.6 Expressões
Uma expressão é um conjunto de operandos (constantes e variáveis) e
operadores. É a parte que está a direita do operador de atribuição. A expressão será
avaliada e resultará em um valor que será atribuído a uma variável (parte esquerda do
comando de atribuição).
1. Todo char e short int é convertido para int e todo float é convertido
para double.
2. Para todos os pares de operandos, ocorre o seguinte: se o maior dos
operandos for long double, o outro será convertido para long double, se for double
o outro operando será double, se for float o outro será float.
Após ser aplicada a regra de conversão, cada par de operandos será do mesmo
tipo.
7.6.2 Casts
É uma construção que força uma expressão ser de um dado tipo. A forma geral
é:
(tipo) expressão
Onde tipo é um tipo de dado. Por exemplo: seja i uma variável inteira e quiser
transformar um resultado para double. Portanto: (double) i/3. O cast é considerado
um operador unário.
Os casts podem ser muito úteis. Como exemplo, suponha que se deseja usar um
número inteiro para controle de um loop, mas que a execução de um cálculo com este
inteiro, seja um número decimal.
Observação: Seja x uma variável inteira. Se fizermos (float) (x/3), o
computador executará a divisão de inteiros ( portanto truncando o resultado) e este
resultado será convertido para float. Exemplo:
Seja x uma variável inteira e f uma variável do tipo float.
x = 10;
f = (float) (x/3).
A variável f, conterá o valor 3 e não o valor 3.333..., como era de se esperar.
Código Significado
%d Exibir um número inteiro
%f Exibir um número float no formato decimal
%e Exibir um float em notação de pto flutuante
%ld Exibir um inteiro longo
%lf Exibir um double no formato decimal
%le Exibir um double em pto flutuante
%c Exibir um caracter
%s Exibir uma cadeia
%o Exibir um número em octal
%x Exibir um número em hexadecimal
%u Exibir um número inteiro sem sinal
8.1.1 Comando if
Instrui ao computador executar um comando baseado na avaliação de uma
expressão booleana. Se o resultado da expressão for verdadeiro o comando será
executado, caso contrário o comando será ignorado. A forma geral do comando if é:
if ( expressão booleana )
comando;
if ( expressão booleana ) {
comando 1;
comando 2;
comando 3;
.
.
.
comando N;
} /* end if */
if ( expressão booleana )
comando 1;
else
comando 2;
if ( expressão booleana ) {
comando 1;
comando 2;
comando 3;
.
.
.
comando N;
Algoritmos e Linguagem de Programação
52
} else {
comando 1;
comando 2;
comando 3;
.
.
.
comando N;
} /* end else */
comando N;
Este comando é avaliado de cima para baixo. Assim que uma condição é
verdadeira, o comando será executado e o resto do comando será ignorado. Se
nenhuma das condições for verdadeira, o comando associado ao último else será
executado.
switch ( variável ) {
case constante 1:
seqüência de comandos;
break;
case constante 2:
seqüência de comandos;
break;
case constante 3:
seqüência de comandos;
break;
.
.
.
default:
seqüência de comandos;
} /* end switch */
main() {
int x;
for ( x=1 ; x<=10; x++ )
printf(“X: %d”,x );
} /* end main */
A forma como a variável de controle de fluxo é alterada pode ser qualquer tipo
de comando de atribuição. Exemplo:
main() {
int x;
for ( x=0 ; x<=100; x=x+5 )
printf(“X: %d”,x );
} /* end main */
main() {
int x,y;
for ( x=0, y=0 ; x+y <100; x++, y++ )
printf(“X+Y: %d”,x+y );
} /* end main */
Este trecho de programa ficará repetindo até que o número 100 seja digitado.
Cada vez que o laço se repete, o valor de x é testado, mas nunca será incrementado.
Quando o número 100 for digitado, a expressão booleana será falsa e o laço termina.
for(;;)
comando 1;
Para sair de um laço for infinito, utiliza-se o comando break, que ocasiona o
término do laço.
while ( condição )
comando;
while ( condição ) {
comando1;
comando2;
comando3;
Algoritmos e Linguagem de Programação
56
.
.
.
comandoN;
}
do {
comando 1;
comando 2;
.
.
.
comando n;
} while ( condição )
As chaves não são necessárias quando tiver apenas um comando a ser executado
dentro do do-while. São utilizadas para aumentar a legibilidade do código.
8.3.1 Break
O comando break, além de ser usado no comando switch, é utilizado para
suspender a execução de um loop, ignorando o teste condicional. Quando encontrar
um comando break dentro de um laço, este será imediatamente encerrado, passando a
executar o comando que estiver após deste comando de repetição, conforme o
exemplo:
main()
{
int a;
for(a=0;a<1000;a++) {
printf(“%d”, a);
if (a = = 30 )
break;
} /* end for */
8.3.2 Continue
O comando continue não encerra a execução do laço, mas força a execução da
próxima repetição, ignorando todos os comandos que estiverem depois. Seja o
exemplo:
main()
Algoritmos e Linguagem de Programação
57
{
int x;
for(x=0;x<=200;x++) {
if(x%3==0)
continue;
printf(“%d”, x);
}
}
Se x for um múltiplo de 3, o comando continue será executado, passando para a
próxima iteração, ignorando o comando printf.
9. Vetores e Matrizes
É um conjunto de variáveis do mesmo tipo de dados ( homogêneas )
referenciadas pelo mesmo nome. São diferenciadas através de um número
denominado de índice, ou seja, o índice é utilizado para acessar um elemento da
matriz. Uma matriz ou um vetor, consiste de alocações adjacentes de memória. Uma
matriz pode ter uma ou mais dimensões. Uma matriz de uma dimensão é denominada
de vetor.
tipo_de_dados nome_da_variável[tamanho];
main()
{
int vet[10], i;
for( i=0;i<10;i++)
vet[i] = i*2;
}
tipo_de_dado nome_da_matriz[número_de_linhas][número_de_colunas];
Uma matriz utiliza dois índices. O primeiro indica a linha e o segundo a coluna.
Portanto, para referenciar um elemento de uma matriz em C, basta usar o nome da
matriz seguido pelos índices relativos à linha e coluna. O elemento na linha 1, coluna
1 é acessado como: nome_da_matriz[0][0].
Podemos definir uma matriz com mais de duas dimensões. A forma geral é
dada por:
tipo_de_dado nome_da_variável[tam1][tam2]...[tamN];
gets( nome_da_variável );
#include<stdio.h>
#include<string.h>
6 Para usar as funções de manipulação de strings, devemos incluir a cabeçalho string.h que contém
os protótipos destas funções.
Algoritmos e Linguagem de Programação
60
main() {
char str[10],str1[10];
strcpy(str, “teste”);
strcpy(str1, str);
}
Este trecho de programa, primeiramente, copia a cadeia constante “teste” para a
variável str. Também coloca ao final de teste o caracter ‘\0’. O segundo comando
strcpy, copia o valor contido na strin str para a string str1.
#include<stdio.h>
#include<string.h>
main() {
char str1[10], str2[10];
strcpy(str1, “teste1”);
strcpy(str2, “teste2”);
strcat(str1, str2);
}
#include<stdio.h>
#include<string.h>
main() {
char str1[10];
gets(str1);
if ( !strcmp( str1, “senha”) );
printf(“senha correta”);
}
Exemplo:
#include<stdio.h>
Algoritmos e Linguagem de Programação
61
#include<string.h>
main() {
char str1[10];
strcpy( str1, “teste”);
printf(“%d”, strlen(str1));
}
Neste exemplo, será exibido o número 5, que é o número de caracteres contidos
em str1.
tipo: Especifica o tipo valor que a função deve retornar para o programa
principal. Uma função não necessita retornar um valor se for o caso. Como exemplo
já visto, fizemos o uso da função main() que não retorna valor. Exemplo: a função
getch() retorna um caracter digitado pelo teclado.
A lista_de_parâmetros é uma lista de nomes de variáveis e seus respectivos
tipos de dados, que receberão os argumentos quando a função for chamada dentro do
programa principal. Uma função não precisa necessariamente conter parâmetros.
Exemplo de função sem parâmetros:
void main() {
int num1, num2;
scanf(“%d %d”, &num1, &num2);
soma_num(num1, num2);
Algoritmos e Linguagem de Programação
62
}
void soma_num(int n1, int n2) {
int total;
total = n1+n2;
printf( “Total: %d”, total);
}
main(){ func1()
comando1; comando1
comando2; ;
comando3; comando2
func1();
comando5;
func2()
comando6;
func2(); comando1
comando7; ;
} comando2
main(){
func1();
func2();
7As variáveis n1 e n2 são variáveis locas à função soma_num(), pois somente
poderão ser usadas dentro desta função.
Algoritmos e Linguagem de Programação
63
}
func1(){
int a;
a = 10;
}
func2(){
int a=10;
printf(“%d”, a);
}
Se uma variável global e uma local tiverem o mesmo nome, todas referências a
essa variável dentro da função na qual a variável local foi declarada dirão respeito à
variável local e não terá efeito sobre a variável global.
As variáveis globais são úteis quando se usa os mesmos dados nas várias
funções do programa. Deve-se evitar o uso de variáveis globais desnecessárias:
1. pôr ocupar espaço na memória durante toda a execução do programa e não
apenas quando são necessárias ( como as variáveis locais ).
2. Pode levar a erros imprevisíveis, pôr não conhecer as causas de possíveis
efeitos colaterais.
3. As funções ficam menos generalizadas.
soma(a,b);
}
soma( int n1, int n2){
printf(“Soma: %d”, n1+n2);
}
Alguns compiladores C aceitam um outro tipo de declaração dos parâmetros da
função, conforme mostra o exemplo a seguir:
soma(n1,n2)
int n1,n2;
{ // Início da função
printf(“Soma: %d”, n1+n2);
}// Término da função.
int var_global;
main(){
int a,b;
}
func2(){
int f2;
}
void main() {
double, num,c;
printf(“Entre com um número: “);
scanf(“%lf”, &num);
c=cubo(num);
printf(“O Cubo é: %lf”, c);
}// end main
double cubo(double n){
double c;
c= n*n*n;
return(c);
} // end cubo
main(){
int n1=10;
printf(“%d”, quadrado(n1));
printf(“%d”, n1);
} // end main
quadrado( int n2) {
n2 = n2*n2;
return(n2);
} // end quadrado
main(){
int a,b;
a=10;
b=20;
printf(“A: %d B: %d”, a,b); // Imprime os valores 10 e 20 respectivamente
troca(&a,&b);
printf(“A: %d B: %d”, a,b); // Imprime os valores 20 e 10 respectivamente
}
troca(int *n1, int *n2){
int aux;
aux = *n1;
*n1 = *n2;
*n2 = aux;
}
11. Ponteiros
Um ponteiro é uma variável que contém um endereço de memória, ou seja, o
endereço de uma outra variável na memória. Se uma variável contiver o endereço de
uma outra variável, pode-se dizer que uma aponta para a outra, conforme ilustra a
figura a seguir.
1000 1003
1001
1002
1003
1004
main() {
int *end_cont, cont, valor;
cont = 256; // Atribui a constante 256 à variável cont
end_cont = &cont; // Atribui o endereço de cont à variável end_cont
valor = *end-cont; // Atribui o valor contido na variável end_cont
}
main(){
int *p1,*p2, val;
val = 200;
p1 = &val;
p2 = p1;
}
main(){
char str[100], *s;
s = str;
}
Algoritmos e Linguagem de Programação
68
12. Arquivos
FILE *fp;
Para abrir um arquivo em disco, utiliza-se a função fopen(). Esta função retorna
um ponteiro do tipo FILE que aponta para a localização na memória da estrutura
FILE. Forma de declaração:
Exemplo:
fp = fopen(“func.dat”, “w”);
func.dat é o nome do arquivo que será manipulado. As informações sobre o
arquivo serão armazenadas na variável fp. A string “w”, informa o tipo de abertura,
que é para a gravação de dados no arquivo. Existe outros tipos de abertura:
- “r” Abrir um arquivo do tipo texto para leitura. O arquivo deve existir em
disco.
- “a” Abrir um arquivo texto para a gravação. Os dados serão adicionados no
final do arquivo existente. Se o arquivo não existir em disco, este é então criado.
- “w” Abrir um arquivo texto para a gravação. Se arquivo existir, ele será
destruído e novamente criado. O conteúdo anteriormente armazenado será destruído.
Se o arquivo não existir, ele será criado.
“r+” Abrir um arquivo texto para leitura e gravação. O arquivo deve existir e
pode ser atualizado
“a+” Abrir um arquivo texto para atualizações e para adicionar novos dados no
arquivo existente. Se não existir, cria-se um novo arquivo.
“rb” Abrir um arquivo no modo binário para a leitura.
“wb” Abrir um arquivo binário para a gravação
“ab” Abrir um arquivo binário para a gravação de novos dados
Outros modos: “rb+”, “wb+” “ab+”.
#include<stdio.h>
Algoritmos e Linguagem de Programação
71
main(){
FILE *p;
char c;
p = fopen(“arq”, “w”); //Abrir o arquivo arq
do {
printf("\nEntre com um caracter: ");
c= getche();
putc(c, p); // Armazena o caracter
} while (c != ‘\r’);
fclose(p); // Fecha o arquivo
} // término da função main()
#include<stdio.h>
main(){
FILE *p;
char ch;
p = fopen(“arq”, “r”); //Abrir o arquivo arq
while((ch=getc(p)) != EOF )
printf("Caracter: %c\n”, ch );
fclose(p); // Fecha o arquivo
} // término da função main()
Obs: O arquivo arq deve existir em disco, caso contrário, o programa dará erro
em tempo de execução. É importante verificar se a arquivo em disco pode ser
acessado antes de fazermos operações de leitura e escrita, para evitar erros. Se não
houver espaço em disco para armazenar valores em um arquivo, também ocorrerá
erros em tempo de execução.
Caso o arquivo não possa ser aberto ou criado, a função fopen() retorna um
valor nulo (NULL). O trecho a seguir ilustra a abertura de um arquivo testando antes
de acessá-lo.
Exemplo:
#include <stdio.h>
#include <string.h>
main() {
FILE *fp;
char str[50];
fp = fopen(“arq”, “w”);
do {
printf(“\n Entre com o nome: “);
gets(str); // le uma string do teclado
fputs(str, fp); // grava a string lida
fputs(“\n”, fp); // grava o caracter para pula uma linha
} while (strlen(str) != 0 ); // fica lendo enquanto não digitar <ENTER>
fclose(fp);
} // end main()
A função fputs() não coloca o caracter de nova linha ( ‘\n’ ) ao final de cada
linha.
#include <stdio.h>
#include <string.h>
Algoritmos e Linguagem de Programação
73
main() {
FILE *fp;
char str[50];
fp = fopen(“arq”, “r”);
while(fgets(str, 49, fp) != NULL )
printf(“str: %s\n” ,str);
fclose(fp);
} // end main()
A função fgets() termina a leitura após ler um caracter de nova linha (‘\n’) ou
um caracter de fim de arquivo.
Exemplo:
Similar à função printf() onde, para cada valor a ser impresso, deve-se ter um
código de formatação correspondente ao tipo. Todos os formatos de printf() operam
com fprintf().
Exemplo:
#include <stdio.h>
main(){
FILE *fp;
char nome[31];
int depto;
float sal;
fp = fopen(“arq”, “r”)
while (fscanf(fp,”%s %d %f”, nome, &depto, &sal) != EOF)
printf(“%s %d %f\n”, nome, depto, sal);
Algoritmos e Linguagem de Programação
74
fclose(fp);
} // end main()
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void main(){
struct func{
char nome[40];
int depto;
float sal;
} f;
FILE *fp;
fp = fopen( “arq”, “wb”);
do {
printf(“entre com o nome: “);
gets(f.nome);
printf(“entre com o depto: “);
scanf(“%d”, &f.depto);
printf(“salario: “);
scanf(“%f”, &f.sal);
fwrite(&f,sizeof(f),1,fp);
printf(“Adiciona outro: (S/N)? “);
} while(getch() = = ‘s’);
fclose(fp);
} //end main()
Algoritmos e Linguagem de Programação
75
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void main(){
struct func{
char nome[40];
int depto;
float sal;
} f[50];
FILE *fp;
int i=0;
fp = fopen("arq","rb");
while(fread(&f[i], sizeof(f[i]),1,fp) == 1){
printf("%s %d %f\n", f[i].nome, f[i].depto,f[i].sal);
printf("alo\n");
i++;
} //end while()
fclose(fp);
} //end main()
Algoritmos e Linguagem de Programação
76
Referências Bibliográficas
Tremblay J.P.,Bunt R.B. Ciência dos Computadores: Uma Abordagem
Algorítmica. McGraw-Hill.
Forbellone, A.L.V & Eberspächer, H.F. Lógica de Programação - A
Construção de Algoritmos e Estrutura de Dados. Makron Books, 1993.
Mizrahi, Victorine Viviane. Treinamento em Linguagem C - Módulo 1. Editora
McGraw-Hill, 1990.
Mizrahi, Victorine Viviane. Treinamento em Linguagem C - Módulo 2.. Editora
McGraw-Hill, 1990
Schildt, Herbert. Turbo C - Guia do Usuário. McGraw-Hill.
Schildt, Herbert. Turbo C Avançado - Guia do Usuário. McGraw-Hill.